field.h 60.9 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000-2006 MySQL AB
unknown's avatar
unknown committed
2

unknown's avatar
unknown committed
3 4
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
unknown's avatar
unknown committed
5
   the Free Software Foundation; version 2 of the License.
unknown's avatar
unknown committed
6

unknown's avatar
unknown committed
7 8 9 10
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
unknown's avatar
unknown committed
11

unknown's avatar
unknown committed
12 13 14 15 16 17
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


/*
unknown's avatar
unknown committed
18 19
  Because of the function new_field() all field classes that have static
  variables must declare the size_of() member function.
unknown's avatar
unknown committed
20 21
*/

22
#ifdef USE_PRAGMA_INTERFACE
unknown's avatar
unknown committed
23 24 25 26
#pragma interface			/* gcc class implementation */
#endif

#define NOT_FIXED_DEC			31
unknown's avatar
unknown committed
27
#define DATETIME_DEC                     6
unknown's avatar
unknown committed
28 29

class Send_field;
30
class Protocol;
unknown's avatar
unknown committed
31
struct st_cache_field;
32
void field_conv(Field *to,Field *from);
unknown's avatar
unknown committed
33

34 35 36 37 38 39 40 41 42 43 44
inline uint get_enum_pack_length(int elements)
{
  return elements < 256 ? 1 : 2;
}

inline uint get_set_pack_length(int elements)
{
  uint len= (elements + 7) / 8;
  return len > 4 ? 8 : len;
}

45 46
class Field
{
unknown's avatar
unknown committed
47
  Field(const Item &);				/* Prevent use of these */
unknown's avatar
unknown committed
48 49
  void operator=(Field &);
public:
unknown's avatar
unknown committed
50
  static void *operator new(size_t size) {return (void*) sql_alloc((uint) size); }
unknown's avatar
Merge  
unknown committed
51
  static void operator delete(void *ptr_arg, size_t size) { TRASH(ptr_arg, size); }
unknown's avatar
unknown committed
52

53 54
  char		*ptr;			// Position to field in record
  uchar		*null_ptr;		// Byte where null_bit is
55 56 57 58
  /*
    Note that you can use table->in_use as replacement for current_thd member 
    only inside of val_*() and store() members (e.g. you can't use it in cons)
  */
59
  struct st_table *table;		// Pointer for table
60
  struct st_table *orig_table;		// Pointer to original table
unknown's avatar
Merge  
unknown committed
61
  const char	**table_name, *field_name;
62
  LEX_STRING	comment;
63
  query_id_t	query_id;		// For quick test of used fields
unknown's avatar
unknown committed
64
  /* Field is part of the following keys */
65
  key_map	key_start,part_of_key,part_of_sortkey;
66 67 68 69 70 71 72 73
  /* 
    We use three additional unireg types for TIMESTAMP to overcome limitation 
    of current binary format of .frm file. We'd like to be able to support 
    NOW() as default and on update value for such fields but unable to hold 
    this info anywhere except unireg_check field. This issue will be resolved
    in more clean way with transition to new text based .frm format.
    See also comment for Field_timestamp::Field_timestamp().
  */
unknown's avatar
unknown committed
74 75
  enum utype  { NONE,DATE,SHIELD,NOEMPTY,CASEUP,PNR,BGNR,PGNR,YES,NO,REL,
		CHECK,EMPTY,UNKNOWN_FIELD,CASEDN,NEXT_NUMBER,INTERVAL_FIELD,
76 77
                BIT_FIELD, TIMESTAMP_OLD_FIELD, CAPITALIZE, BLOB_FIELD,
                TIMESTAMP_DN_FIELD, TIMESTAMP_UN_FIELD, TIMESTAMP_DNUN_FIELD};
unknown's avatar
unknown committed
78 79 80 81 82 83
  enum geometry_type
  {
    GEOM_GEOMETRY = 0, GEOM_POINT = 1, GEOM_LINESTRING = 2, GEOM_POLYGON = 3,
    GEOM_MULTIPOINT = 4, GEOM_MULTILINESTRING = 5, GEOM_MULTIPOLYGON = 6,
    GEOM_GEOMETRYCOLLECTION = 7
  };
unknown's avatar
unknown committed
84
  enum imagetype { itRAW, itMBR};
unknown's avatar
unknown committed
85

unknown's avatar
unknown committed
86
  utype		unireg_check;
87
  uint32	field_length;		// Length of field
88
  uint          field_index;            // field number in fields array
unknown's avatar
unknown committed
89
  uint16	flags;
90
  uchar		null_bit;		// Bit used to test null bit
unknown's avatar
unknown committed
91 92

  Field(char *ptr_arg,uint32 length_arg,uchar *null_ptr_arg,uchar null_bit_arg,
unknown's avatar
unknown committed
93 94 95
	utype unireg_check_arg, const char *field_name_arg,
	struct st_table *table_arg);
  virtual ~Field() {}
unknown's avatar
unknown committed
96
  /* Store functions returns 1 on overflow and -1 on fatal error */
97 98
  virtual int  store(const char *to,uint length,CHARSET_INFO *cs)=0;
  virtual int  store(double nr)=0;
99
  virtual int  store(longlong nr, bool unsigned_val)=0;
unknown's avatar
unknown committed
100
  virtual int  store_decimal(const my_decimal *d)=0;
unknown's avatar
Merge  
unknown committed
101
  virtual int store_time(TIME *ltime, timestamp_type t_type);
unknown's avatar
unknown committed
102 103
  virtual double val_real(void)=0;
  virtual longlong val_int(void)=0;
unknown's avatar
unknown committed
104
  virtual my_decimal *val_decimal(my_decimal *);
unknown's avatar
unknown committed
105 106 107
  inline String *val_str(String *str) { return val_str(str, str); }
  /*
     val_str(buf1, buf2) gets two buffers and should use them as follows:
108 109 110 111 112 113 114 115 116 117
     if it needs a temp buffer to convert result to string - use buf1
       example Field_tiny::val_str()
     if the value exists as a string already - use buf2
       example Field_string::val_str()
     consequently, buf2 may be created as 'String buf;' - no memory
     will be allocated for it. buf1 will be allocated to hold a
     value if it's too small. Using allocated buffer for buf2 may result in
     an unnecessary free (and later, may be an alloc).
     This trickery is used to decrease a number of malloc calls.
  */
unknown's avatar
unknown committed
118
  virtual String *val_str(String*,String *)=0;
unknown's avatar
Merge  
unknown committed
119
  String *val_int_as_str(String *val_buffer, my_bool unsigned_flag);
unknown's avatar
unknown committed
120 121
  virtual Item_result result_type () const=0;
  virtual Item_result cmp_type () const { return result_type(); }
122
  virtual Item_result cast_to_int_type () const { return result_type(); }
123
  static bool type_can_have_key_part(enum_field_types);
124 125
  static enum_field_types field_type_merge(enum_field_types, enum_field_types);
  static Item_result result_merge_type(enum_field_types);
126
  virtual bool eq(Field *field)
unknown's avatar
Merge  
unknown committed
127 128 129 130
  {
    return (ptr == field->ptr && null_ptr == field->null_ptr &&
            null_bit == field->null_bit);
  }
unknown's avatar
unknown committed
131
  virtual bool eq_def(Field *field);
132 133 134 135 136 137
  
  /*
    pack_length() returns size (in bytes) used to store field data in memory
    (i.e. it returns the maximum size of the field in a row of the table,
    which is located in RAM).
  */
unknown's avatar
unknown committed
138
  virtual uint32 pack_length() const { return (uint32) field_length; }
139 140 141 142 143 144

  /*
    pack_length_in_rec() returns size (in bytes) used to store field data on
    storage (i.e. it returns the maximal size of the field in a row of the
    table, which is located on disk).
  */
unknown's avatar
Merge  
unknown committed
145
  virtual uint32 pack_length_in_rec() const { return pack_length(); }
146 147 148 149 150

  /*
    data_length() return the "real size" of the data in memory.
  */
  virtual uint32 data_length(const char *from) { return pack_length(); }
151
  virtual uint32 sort_length() const { return pack_length(); }
152
  virtual int reset(void) { bzero(ptr,pack_length()); return 0; }
unknown's avatar
unknown committed
153
  virtual void reset_fields() {}
unknown's avatar
unknown committed
154 155
  virtual void set_default()
  {
unknown's avatar
Merge  
unknown committed
156
    my_ptrdiff_t offset = (my_ptrdiff_t) (table->s->default_values -
unknown's avatar
unknown committed
157
					  table->record[0]);
unknown's avatar
SCRUM  
unknown committed
158
    memcpy(ptr, ptr + offset, pack_length());
159 160
    if (null_ptr)
      *null_ptr= ((*null_ptr & (uchar) ~null_bit) |
unknown's avatar
SCRUM  
unknown committed
161
		  null_ptr[offset] & null_bit);
unknown's avatar
unknown committed
162
  }
unknown's avatar
unknown committed
163 164 165 166 167 168 169 170
  virtual bool binary() const { return 1; }
  virtual bool zero_pack() const { return 1; }
  virtual enum ha_base_keytype key_type() const { return HA_KEYTYPE_BINARY; }
  virtual uint32 key_length() const { return pack_length(); }
  virtual enum_field_types type() const =0;
  virtual enum_field_types real_type() const { return type(); }
  inline  int cmp(const char *str) { return cmp(ptr,str); }
  virtual int cmp(const char *,const char *)=0;
unknown's avatar
unknown committed
171
  virtual int cmp_binary(const char *a,const char *b, uint32 max_length=~0L)
unknown's avatar
unknown committed
172
  { return memcmp(a,b,pack_length()); }
173 174 175
  virtual int cmp_offset(uint row_offset)
  { return cmp(ptr,ptr+row_offset); }
  virtual int cmp_binary_offset(uint row_offset)
unknown's avatar
Merge  
unknown committed
176
  { return cmp_binary(ptr, ptr+row_offset); };
unknown's avatar
unknown committed
177 178 179 180 181
  virtual int key_cmp(const byte *a,const byte *b)
  { return cmp((char*) a,(char*) b); }
  virtual int key_cmp(const byte *str, uint length)
  { return cmp(ptr,(char*) str); }
  virtual uint decimals() const { return 0; }
unknown's avatar
unknown committed
182 183 184 185 186
  /*
    Caller beware: sql_type can change str.Ptr, so check
    ptr() to see if it changed if you are using your own buffer
    in str and restore it with set() if needed
  */
187
  virtual void sql_type(String &str) const =0;
188
  virtual uint size_of() const =0;		// For new field
unknown's avatar
unknown committed
189 190 191 192
  inline bool is_null(uint row_offset=0)
  { return null_ptr ? (null_ptr[row_offset] & null_bit ? 1 : 0) : table->null_row; }
  inline bool is_real_null(uint row_offset=0)
    { return null_ptr ? (null_ptr[row_offset] & null_bit ? 1 : 0) : 0; }
unknown's avatar
unknown committed
193 194 195 196 197 198 199
  inline bool is_null_in_record(const uchar *record)
  {
    if (!null_ptr)
      return 0;
    return test(record[(uint) (null_ptr - (uchar*) table->record[0])] &
		null_bit);
  }
unknown's avatar
unknown committed
200 201 202
  inline void set_null(int row_offset=0)
    { if (null_ptr) null_ptr[row_offset]|= null_bit; }
  inline void set_notnull(int row_offset=0)
unknown's avatar
unknown committed
203
    { if (null_ptr) null_ptr[row_offset]&= (uchar) ~null_bit; }
unknown's avatar
unknown committed
204 205
  inline bool maybe_null(void) { return null_ptr != 0 || table->maybe_null; }
  inline bool real_maybe_null(void) { return null_ptr != 0; }
unknown's avatar
Merge  
unknown committed
206
  virtual void make_field(Send_field *);
unknown's avatar
unknown committed
207
  virtual void sort_string(char *buff,uint length)=0;
208
  virtual bool optimize_range(uint idx, uint part);
209 210 211 212 213 214 215 216
  /*
    This should be true for fields which, when compared with constant
    items, can be casted to longlong. In this case we will at 'fix_fields'
    stage cast the constant items to longlongs and at the execution stage
    use field->val_int() for comparison.  Used to optimize clauses like
    'a_column BETWEEN date_const, date_const'.
  */
  virtual bool can_be_compared_as_longlong() const { return FALSE; }
217
  virtual void free() {}
218 219
  virtual Field *new_field(MEM_ROOT *root, struct st_table *new_table,
                           bool keep_type);
unknown's avatar
Merge  
unknown committed
220 221 222
  virtual Field *new_key_field(MEM_ROOT *root, struct st_table *new_table,
                               char *new_ptr, uchar *new_null_ptr,
                               uint new_null_bit);
unknown's avatar
unknown committed
223
  inline void move_field(char *ptr_arg,uchar *null_ptr_arg,uchar null_bit_arg)
unknown's avatar
unknown committed
224 225 226
  {
    ptr=ptr_arg; null_ptr=null_ptr_arg; null_bit=null_bit_arg;
  }
unknown's avatar
unknown committed
227 228 229 230 231 232 233
  inline void move_field(char *ptr_arg) { ptr=ptr_arg; }
  inline void move_field(my_ptrdiff_t ptr_diff)
  {
    ptr=ADD_TO_PTR(ptr,ptr_diff,char*);
    if (null_ptr)
      null_ptr=ADD_TO_PTR(null_ptr,ptr_diff,uchar*);
  }
unknown's avatar
unknown committed
234
  inline void get_image(char *buff,uint length, CHARSET_INFO *cs)
unknown's avatar
unknown committed
235
    { memcpy(buff,ptr,length); }
unknown's avatar
unknown committed
236
  inline void set_image(char *buff,uint length, CHARSET_INFO *cs)
unknown's avatar
unknown committed
237
    { memcpy(ptr,buff,length); }
unknown's avatar
Merge  
unknown committed
238 239 240 241
  virtual void get_key_image(char *buff, uint length, imagetype type)
    { get_image(buff,length, &my_charset_bin); }
  virtual void set_key_image(char *buff,uint length)
    { set_image(buff,length, &my_charset_bin); }
unknown's avatar
unknown committed
242 243 244 245 246 247 248
  inline longlong val_int_offset(uint row_offset)
    {
      ptr+=row_offset;
      longlong tmp=val_int();
      ptr-=row_offset;
      return tmp;
    }
unknown's avatar
Merge  
unknown committed
249 250 251 252 253 254 255 256 257

  inline String *val_str(String *str, char *new_ptr)
  {
    char *old_ptr= ptr;
    ptr= new_ptr;
    val_str(str);
    ptr= old_ptr;
    return str;
  }
unknown's avatar
unknown committed
258
  virtual bool send_binary(Protocol *protocol);
unknown's avatar
unknown committed
259 260
  virtual char *pack(char* to, const char *from, uint max_length=~(uint) 0)
  {
unknown's avatar
unknown committed
261
    uint32 length=pack_length();
unknown's avatar
unknown committed
262 263 264 265 266 267 268 269 270
    memcpy(to,from,length);
    return to+length;
  }
  virtual const char *unpack(char* to, const char *from)
  {
    uint length=pack_length();
    memcpy(to,from,length);
    return from+length;
  }
271 272 273 274 275 276
  virtual char *pack_key(char* to, const char *from, uint max_length)
  {
    return pack(to,from,max_length);
  }
  virtual char *pack_key_from_key_image(char* to, const char *from,
					uint max_length)
unknown's avatar
unknown committed
277 278 279
  {
    return pack(to,from,max_length);
  }
280 281 282 283
  virtual const char *unpack_key(char* to, const char *from, uint max_length)
  {
    return unpack(to,from);
  }
284 285
  virtual uint packed_col_length(const char *to, uint length)
  { return length;}
unknown's avatar
unknown committed
286
  virtual uint max_packed_col_length(uint max_length)
287
  { return max_length;}
unknown's avatar
unknown committed
288

unknown's avatar
Merge  
unknown committed
289 290
  virtual int pack_cmp(const char *a,const char *b, uint key_length_arg,
                       my_bool insert_or_update)
unknown's avatar
unknown committed
291
  { return cmp(a,b); }
unknown's avatar
Merge  
unknown committed
292 293
  virtual int pack_cmp(const char *b, uint key_length_arg,
                       my_bool insert_or_update)
294
  { return cmp(ptr,b); }
295
  uint offset();			// Should be inline ...
unknown's avatar
unknown committed
296 297
  void copy_from_tmp(int offset);
  uint fill_cache_field(struct st_cache_field *copy);
298
  virtual bool get_date(TIME *ltime,uint fuzzydate);
unknown's avatar
unknown committed
299
  virtual bool get_time(TIME *ltime);
unknown's avatar
unknown committed
300
  virtual CHARSET_INFO *charset(void) const { return &my_charset_bin; }
301
  virtual CHARSET_INFO *sort_charset(void) const { return charset(); }
302
  virtual bool has_charset(void) const { return FALSE; }
unknown's avatar
unknown committed
303
  virtual void set_charset(CHARSET_INFO *charset) { }
304 305 306
  virtual enum Derivation derivation(void) const
  { return DERIVATION_IMPLICIT; }
  virtual void set_derivation(enum Derivation derivation) { }
307
  bool set_warning(MYSQL_ERROR::enum_warning_level, unsigned int code,
308
                   int cuted_increment);
unknown's avatar
Merge  
unknown committed
309 310
  bool check_int(const char *str, int length, const char *int_end,
                 CHARSET_INFO *cs);
311
  void set_datetime_warning(MYSQL_ERROR::enum_warning_level, uint code, 
312 313
                            const char *str, uint str_len,
                            timestamp_type ts_type, int cuted_increment);
314
  void set_datetime_warning(MYSQL_ERROR::enum_warning_level, uint code, 
315 316
                            longlong nr, timestamp_type ts_type,
                            int cuted_increment);
317
  void set_datetime_warning(MYSQL_ERROR::enum_warning_level, const uint code, 
318
                            double nr, timestamp_type ts_type);
unknown's avatar
unknown committed
319 320 321 322 323
  inline bool check_overflow(int op_result)
  {
    return (op_result == E_DEC_OVERFLOW);
  }
  int warn_if_overflow(int op_result);
unknown's avatar
unknown committed
324 325
  /* maximum possible display length */
  virtual uint32 max_length()= 0;
unknown's avatar
unknown committed
326 327 328
  /* convert decimal to longlong with overflow check */
  longlong convert_decimal2longlong(const my_decimal *val, bool unsigned_flag,
                                    int *err);
329
  /* The max. number of characters */
330
  inline uint32 char_length() const
331 332 333 334
  {
    return field_length / charset()->mbmaxlen;
  }

unknown's avatar
unknown committed
335 336 337 338 339 340 341 342 343 344 345 346 347 348
  friend bool reopen_table(THD *,struct st_table *,bool);
  friend int cre_myisam(my_string name, register TABLE *form, uint options,
			ulonglong auto_increment_value);
  friend class Copy_field;
  friend class Item_avg_field;
  friend class Item_std_field;
  friend class Item_sum_num;
  friend class Item_sum_sum;
  friend class Item_sum_str;
  friend class Item_sum_count;
  friend class Item_sum_avg;
  friend class Item_sum_std;
  friend class Item_sum_min;
  friend class Item_sum_max;
349
  friend class Item_func_group_concat;
unknown's avatar
unknown committed
350 351 352 353 354 355
};


class Field_num :public Field {
public:
  const uint8 dec;
356
  bool zerofill,unsigned_flag;	// Purify cannot handle bit fields
unknown's avatar
unknown committed
357
  Field_num(char *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
358
	    uchar null_bit_arg, utype unireg_check_arg,
unknown's avatar
unknown committed
359 360
	    const char *field_name_arg,
	    struct st_table *table_arg,
unknown's avatar
unknown committed
361
            uint8 dec_arg, bool zero_arg, bool unsigned_arg);
unknown's avatar
unknown committed
362 363 364 365 366
  Item_result result_type () const { return REAL_RESULT; }
  void prepend_zeros(String *value);
  void add_zerofill_and_unsigned(String &res) const;
  friend class create_field;
  void make_field(Send_field *);
unknown's avatar
unknown committed
367
  uint decimals() const { return (uint) dec; }
unknown's avatar
unknown committed
368 369
  uint size_of() const { return sizeof(*this); }
  bool eq_def(Field *field);
unknown's avatar
unknown committed
370 371
  int store_decimal(const my_decimal *);
  my_decimal *val_decimal(my_decimal *);
unknown's avatar
unknown committed
372 373 374 375
};


class Field_str :public Field {
376 377
protected:
  CHARSET_INFO *field_charset;
378
  enum Derivation field_derivation;
unknown's avatar
unknown committed
379
public:
unknown's avatar
unknown committed
380
  Field_str(char *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
381
	    uchar null_bit_arg, utype unireg_check_arg,
unknown's avatar
unknown committed
382
	    const char *field_name_arg,
unknown's avatar
unknown committed
383
            struct st_table *table_arg, CHARSET_INFO *charset);
unknown's avatar
unknown committed
384 385
  Item_result result_type () const { return STRING_RESULT; }
  uint decimals() const { return NOT_FIXED_DEC; }
unknown's avatar
unknown committed
386
  int  store(double nr);
387
  int  store(longlong nr, bool unsigned_val)=0;
unknown's avatar
unknown committed
388
  int  store_decimal(const my_decimal *);
unknown's avatar
unknown committed
389
  int  store(const char *to,uint length,CHARSET_INFO *cs)=0;
unknown's avatar
unknown committed
390
  uint size_of() const { return sizeof(*this); }
unknown's avatar
unknown committed
391 392
  CHARSET_INFO *charset(void) const { return field_charset; }
  void set_charset(CHARSET_INFO *charset) { field_charset=charset; }
393 394 395
  enum Derivation derivation(void) const { return field_derivation; }
  virtual void set_derivation(enum Derivation derivation_arg)
  { field_derivation= derivation_arg; }
396
  bool binary() const { return field_charset == &my_charset_bin; }
unknown's avatar
unknown committed
397
  uint32 max_length() { return field_length; }
unknown's avatar
unknown committed
398
  friend class create_field;
unknown's avatar
unknown committed
399 400 401
  my_decimal *val_decimal(my_decimal *);
};

402 403 404

/* base class for Field_string, Field_varstring and Field_blob */

unknown's avatar
unknown committed
405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434
class Field_longstr :public Field_str
{
public:
  Field_longstr(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
                uchar null_bit_arg, utype unireg_check_arg,
                const char *field_name_arg,
                struct st_table *table_arg,CHARSET_INFO *charset)
    :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, unireg_check_arg,
               field_name_arg, table_arg, charset)
    {}

  int store_decimal(const my_decimal *d);
};

/* base class for float and double and decimal (old one) */
class Field_real :public Field_num {
public:

  Field_real(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
             uchar null_bit_arg, utype unireg_check_arg,
             const char *field_name_arg,
             struct st_table *table_arg,
             uint8 dec_arg, bool zero_arg, bool unsigned_arg)
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, unireg_check_arg,
               field_name_arg, table_arg, dec_arg, zero_arg, unsigned_arg)
    {}


  int store_decimal(const my_decimal *);
  my_decimal *val_decimal(my_decimal *);
unknown's avatar
unknown committed
435 436 437
};


unknown's avatar
unknown committed
438
class Field_decimal :public Field_real {
unknown's avatar
unknown committed
439 440
public:
  Field_decimal(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
441
		uchar null_bit_arg,
unknown's avatar
unknown committed
442 443
		enum utype unireg_check_arg, const char *field_name_arg,
		struct st_table *table_arg,
unknown's avatar
unknown committed
444
		uint8 dec_arg,bool zero_arg,bool unsigned_arg)
unknown's avatar
unknown committed
445 446 447
    :Field_real(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
                unireg_check_arg, field_name_arg, table_arg,
                dec_arg, zero_arg, unsigned_arg)
unknown's avatar
unknown committed
448 449 450
    {}
  enum_field_types type() const { return FIELD_TYPE_DECIMAL;}
  enum ha_base_keytype key_type() const
451
  { return zerofill ? HA_KEYTYPE_BINARY : HA_KEYTYPE_NUM; }
452 453 454
  int reset(void);
  int store(const char *to,uint length,CHARSET_INFO *charset);
  int store(double nr);
455
  int store(longlong nr, bool unsigned_val);
unknown's avatar
unknown committed
456 457 458 459 460 461 462 463
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*,String *);
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  void overflow(bool negative);
  bool zero_pack() const { return 0; }
  void sql_type(String &str) const;
unknown's avatar
unknown committed
464
  uint32 max_length() { return field_length; }
unknown's avatar
unknown committed
465 466 467
};


unknown's avatar
unknown committed
468 469 470
/* New decimal/numeric field which use fixed point arithmetic */
class Field_new_decimal :public Field_num {
public:
unknown's avatar
unknown committed
471 472
  /* The maximum number of decimal digits can be stored */
  uint precision;
unknown's avatar
unknown committed
473
  uint bin_size;
unknown's avatar
unknown committed
474 475 476 477 478 479
  /*
    Constructors take max_length of the field as a parameter - not the
    precision as the number of decimal digits allowed.
    So for example we need to count length from precision handling
    CREATE TABLE ( DECIMAL(x,y)) 
  */
unknown's avatar
unknown committed
480 481 482 483 484 485 486
  Field_new_decimal(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
                    uchar null_bit_arg,
                    enum utype unireg_check_arg, const char *field_name_arg,
                    struct st_table *table_arg,
                    uint8 dec_arg, bool zero_arg, bool unsigned_arg);
  Field_new_decimal(uint32 len_arg, bool maybe_null_arg,
                    const char *field_name_arg,
unknown's avatar
unknown committed
487 488
                    struct st_table *table_arg, uint8 dec_arg,
                    bool unsigned_arg);
unknown's avatar
unknown committed
489 490 491
  enum_field_types type() const { return FIELD_TYPE_NEWDECIMAL;}
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_BINARY; }
  Item_result result_type () const { return DECIMAL_RESULT; }
492
  int  reset(void);
unknown's avatar
unknown committed
493 494 495 496
  bool store_value(const my_decimal *decimal_value);
  void set_value_on_overflow(my_decimal *decimal_value, bool sign);
  int  store(const char *to, uint length, CHARSET_INFO *charset);
  int  store(double nr);
497
  int  store(longlong nr, bool unsigned_val);
498
  int store_time(TIME *ltime, timestamp_type t_type);
unknown's avatar
unknown committed
499 500 501 502 503 504 505 506 507
  int  store_decimal(const my_decimal *);
  double val_real(void);
  longlong val_int(void);
  my_decimal *val_decimal(my_decimal *);
  String *val_str(String*, String *);
  int cmp(const char *, const char*);
  void sort_string(char *buff, uint length);
  bool zero_pack() const { return 0; }
  void sql_type(String &str) const;
unknown's avatar
unknown committed
508
  uint32 max_length() { return field_length; }
unknown's avatar
unknown committed
509 510 511 512 513
  uint size_of() const { return sizeof(*this); } 
  uint32 pack_length() const { return (uint32) bin_size; }
};


unknown's avatar
unknown committed
514 515 516
class Field_tiny :public Field_num {
public:
  Field_tiny(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
517
	     uchar null_bit_arg,
unknown's avatar
unknown committed
518 519 520 521 522 523 524 525 526 527 528
	     enum utype unireg_check_arg, const char *field_name_arg,
	     struct st_table *table_arg,
	     bool zero_arg, bool unsigned_arg)
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg,
	       0, zero_arg,unsigned_arg)
    {}
  enum Item_result result_type () const { return INT_RESULT; }
  enum_field_types type() const { return FIELD_TYPE_TINY;}
  enum ha_base_keytype key_type() const
    { return unsigned_flag ? HA_KEYTYPE_BINARY : HA_KEYTYPE_INT8; }
529 530
  int store(const char *to,uint length,CHARSET_INFO *charset);
  int store(double nr);
531
  int store(longlong nr, bool unsigned_val);
532
  int reset(void) { ptr[0]=0; return 0; }
unknown's avatar
unknown committed
533 534 535
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*,String *);
536
  bool send_binary(Protocol *protocol);
unknown's avatar
unknown committed
537 538 539 540
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint32 pack_length() const { return 1; }
  void sql_type(String &str) const;
unknown's avatar
unknown committed
541
  uint32 max_length() { return 4; }
unknown's avatar
unknown committed
542 543 544 545 546 547
};


class Field_short :public Field_num {
public:
  Field_short(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
548
	      uchar null_bit_arg,
unknown's avatar
unknown committed
549 550 551 552 553 554 555
	      enum utype unireg_check_arg, const char *field_name_arg,
	      struct st_table *table_arg,
	      bool zero_arg, bool unsigned_arg)
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg,
	       0, zero_arg,unsigned_arg)
    {}
556 557 558 559 560
  Field_short(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
	      struct st_table *table_arg,bool unsigned_arg)
    :Field_num((char*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0,0,
	       NONE, field_name_arg, table_arg,0,0,unsigned_arg)
    {}
unknown's avatar
unknown committed
561 562 563 564
  enum Item_result result_type () const { return INT_RESULT; }
  enum_field_types type() const { return FIELD_TYPE_SHORT;}
  enum ha_base_keytype key_type() const
    { return unsigned_flag ? HA_KEYTYPE_USHORT_INT : HA_KEYTYPE_SHORT_INT;}
565 566
  int store(const char *to,uint length,CHARSET_INFO *charset);
  int store(double nr);
567
  int store(longlong nr, bool unsigned_val);
568
  int reset(void) { ptr[0]=ptr[1]=0; return 0; }
unknown's avatar
unknown committed
569 570 571
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*,String *);
572
  bool send_binary(Protocol *protocol);
unknown's avatar
unknown committed
573 574 575 576
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint32 pack_length() const { return 2; }
  void sql_type(String &str) const;
unknown's avatar
unknown committed
577
  uint32 max_length() { return 6; }
unknown's avatar
unknown committed
578 579 580 581 582 583
};


class Field_medium :public Field_num {
public:
  Field_medium(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
584
	      uchar null_bit_arg,
unknown's avatar
unknown committed
585 586 587 588 589 590 591 592 593 594 595
	      enum utype unireg_check_arg, const char *field_name_arg,
	      struct st_table *table_arg,
	      bool zero_arg, bool unsigned_arg)
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg,
	       0, zero_arg,unsigned_arg)
    {}
  enum Item_result result_type () const { return INT_RESULT; }
  enum_field_types type() const { return FIELD_TYPE_INT24;}
  enum ha_base_keytype key_type() const
    { return unsigned_flag ? HA_KEYTYPE_UINT24 : HA_KEYTYPE_INT24; }
596 597
  int store(const char *to,uint length,CHARSET_INFO *charset);
  int store(double nr);
598
  int store(longlong nr, bool unsigned_val);
599
  int reset(void) { ptr[0]=ptr[1]=ptr[2]=0; return 0; }
unknown's avatar
unknown committed
600 601 602
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*,String *);
603
  bool send_binary(Protocol *protocol);
unknown's avatar
unknown committed
604 605 606 607
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint32 pack_length() const { return 3; }
  void sql_type(String &str) const;
unknown's avatar
unknown committed
608
  uint32 max_length() { return 8; }
unknown's avatar
unknown committed
609 610 611 612 613 614
};


class Field_long :public Field_num {
public:
  Field_long(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
615
	     uchar null_bit_arg,
unknown's avatar
unknown committed
616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631
	     enum utype unireg_check_arg, const char *field_name_arg,
	     struct st_table *table_arg,
	     bool zero_arg, bool unsigned_arg)
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg,
	       0, zero_arg,unsigned_arg)
    {}
  Field_long(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
	     struct st_table *table_arg,bool unsigned_arg)
    :Field_num((char*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0,0,
	       NONE, field_name_arg, table_arg,0,0,unsigned_arg)
    {}
  enum Item_result result_type () const { return INT_RESULT; }
  enum_field_types type() const { return FIELD_TYPE_LONG;}
  enum ha_base_keytype key_type() const
    { return unsigned_flag ? HA_KEYTYPE_ULONG_INT : HA_KEYTYPE_LONG_INT; }
632 633
  int store(const char *to,uint length,CHARSET_INFO *charset);
  int store(double nr);
634
  int store(longlong nr, bool unsigned_val);
635
  int reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=0; return 0; }
unknown's avatar
unknown committed
636 637
  double val_real(void);
  longlong val_int(void);
638
  bool send_binary(Protocol *protocol);
unknown's avatar
unknown committed
639 640 641 642 643
  String *val_str(String*,String *);
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint32 pack_length() const { return 4; }
  void sql_type(String &str) const;
unknown's avatar
unknown committed
644
  uint32 max_length() { return 11; }
unknown's avatar
unknown committed
645 646 647 648 649 650 651
};


#ifdef HAVE_LONG_LONG
class Field_longlong :public Field_num {
public:
  Field_longlong(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
652
	      uchar null_bit_arg,
unknown's avatar
unknown committed
653 654 655 656 657 658 659
	      enum utype unireg_check_arg, const char *field_name_arg,
	      struct st_table *table_arg,
	      bool zero_arg, bool unsigned_arg)
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg,
	       0, zero_arg,unsigned_arg)
    {}
660 661 662
  Field_longlong(uint32 len_arg,bool maybe_null_arg,
		 const char *field_name_arg,
		 struct st_table *table_arg, bool unsigned_arg)
unknown's avatar
unknown committed
663
    :Field_num((char*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0,0,
664
	       NONE, field_name_arg, table_arg,0,0,unsigned_arg)
unknown's avatar
unknown committed
665 666 667 668 669
    {}
  enum Item_result result_type () const { return INT_RESULT; }
  enum_field_types type() const { return FIELD_TYPE_LONGLONG;}
  enum ha_base_keytype key_type() const
    { return unsigned_flag ? HA_KEYTYPE_ULONGLONG : HA_KEYTYPE_LONGLONG; }
670 671
  int store(const char *to,uint length,CHARSET_INFO *charset);
  int store(double nr);
672
  int store(longlong nr, bool unsigned_val);
673 674 675 676 677
  int reset(void)
  {
    ptr[0]=ptr[1]=ptr[2]=ptr[3]=ptr[4]=ptr[5]=ptr[6]=ptr[7]=0;
    return 0;
  }
unknown's avatar
unknown committed
678 679 680
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*,String *);
681
  bool send_binary(Protocol *protocol);
unknown's avatar
unknown committed
682 683 684 685
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint32 pack_length() const { return 8; }
  void sql_type(String &str) const;
686
  bool can_be_compared_as_longlong() const { return TRUE; }
unknown's avatar
unknown committed
687
  uint32 max_length() { return 20; }
unknown's avatar
unknown committed
688 689 690
};
#endif

unknown's avatar
unknown committed
691 692

class Field_float :public Field_real {
unknown's avatar
unknown committed
693 694
public:
  Field_float(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
695
	      uchar null_bit_arg,
unknown's avatar
unknown committed
696 697
	      enum utype unireg_check_arg, const char *field_name_arg,
	      struct st_table *table_arg,
unknown's avatar
unknown committed
698 699 700 701
              uint8 dec_arg,bool zero_arg,bool unsigned_arg)
    :Field_real(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
                unireg_check_arg, field_name_arg, table_arg,
                dec_arg, zero_arg, unsigned_arg)
unknown's avatar
unknown committed
702
    {}
703 704
  Field_float(uint32 len_arg, bool maybe_null_arg, const char *field_name_arg,
	      struct st_table *table_arg, uint8 dec_arg)
unknown's avatar
unknown committed
705 706
    :Field_real((char*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0, (uint) 0,
                NONE, field_name_arg, table_arg, dec_arg, 0, 0)
707
    {}
unknown's avatar
unknown committed
708 709
  enum_field_types type() const { return FIELD_TYPE_FLOAT;}
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_FLOAT; }
710 711
  int store(const char *to,uint length,CHARSET_INFO *charset);
  int store(double nr);
712
  int store(longlong nr, bool unsigned_val);
713
  int reset(void) { bzero(ptr,sizeof(float)); return 0; }
unknown's avatar
unknown committed
714 715 716
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*,String *);
717
  bool send_binary(Protocol *protocol);
unknown's avatar
unknown committed
718 719 720 721
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint32 pack_length() const { return sizeof(float); }
  void sql_type(String &str) const;
unknown's avatar
unknown committed
722
  uint32 max_length() { return 24; }
unknown's avatar
unknown committed
723 724 725
};


unknown's avatar
unknown committed
726
class Field_double :public Field_real {
unknown's avatar
unknown committed
727 728
public:
  Field_double(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
729
	       uchar null_bit_arg,
unknown's avatar
unknown committed
730 731
	       enum utype unireg_check_arg, const char *field_name_arg,
	       struct st_table *table_arg,
unknown's avatar
unknown committed
732
	       uint8 dec_arg,bool zero_arg,bool unsigned_arg)
unknown's avatar
unknown committed
733 734 735
    :Field_real(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
                unireg_check_arg, field_name_arg, table_arg,
                dec_arg, zero_arg, unsigned_arg)
unknown's avatar
unknown committed
736 737
    {}
  Field_double(uint32 len_arg, bool maybe_null_arg, const char *field_name_arg,
unknown's avatar
unknown committed
738
	       struct st_table *table_arg, uint8 dec_arg)
unknown's avatar
unknown committed
739 740
    :Field_real((char*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0, (uint) 0,
                NONE, field_name_arg, table_arg, dec_arg, 0, 0)
unknown's avatar
unknown committed
741 742 743
    {}
  enum_field_types type() const { return FIELD_TYPE_DOUBLE;}
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_DOUBLE; }
744 745
  int  store(const char *to,uint length,CHARSET_INFO *charset);
  int  store(double nr);
746
  int  store(longlong nr, bool unsigned_val);
747
  int reset(void) { bzero(ptr,sizeof(double)); return 0; }
unknown's avatar
unknown committed
748 749 750
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*,String *);
751
  bool send_binary(Protocol *protocol);
unknown's avatar
unknown committed
752 753 754 755
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint32 pack_length() const { return sizeof(double); }
  void sql_type(String &str) const;
unknown's avatar
unknown committed
756
  uint32 max_length() { return 53; }
unknown's avatar
unknown committed
757 758 759
};


unknown's avatar
unknown committed
760
/* Everything saved in this will disappear. It will always return NULL */
unknown's avatar
unknown committed
761 762 763 764 765 766

class Field_null :public Field_str {
  static uchar null[1];
public:
  Field_null(char *ptr_arg, uint32 len_arg,
	     enum utype unireg_check_arg, const char *field_name_arg,
767
	     struct st_table *table_arg, CHARSET_INFO *cs)
unknown's avatar
unknown committed
768
    :Field_str(ptr_arg, len_arg, null, 1,
769
	       unireg_check_arg, field_name_arg, table_arg, cs)
unknown's avatar
unknown committed
770 771
    {}
  enum_field_types type() const { return FIELD_TYPE_NULL;}
772 773
  int  store(const char *to, uint length, CHARSET_INFO *cs)
  { null[0]=1; return 0; }
774
  int store(double nr)   { null[0]=1; return 0; }
775 776
  int store(longlong nr, bool unsigned_val) { null[0]=1; return 0; }
  int store_decimal(const my_decimal *d)  { null[0]=1; return 0; }
777
  int reset(void)	  { return 0; }
unknown's avatar
unknown committed
778 779
  double val_real(void)		{ return 0.0;}
  longlong val_int(void)	{ return 0;}
unknown's avatar
unknown committed
780
  my_decimal *val_decimal(my_decimal *) { return 0; }
unknown's avatar
unknown committed
781 782 783 784 785
  String *val_str(String *value,String *value2)
  { value2->length(0); return value2;}
  int cmp(const char *a, const char *b) { return 0;}
  void sort_string(char *buff, uint length)  {}
  uint32 pack_length() const { return 0; }
786
  void sql_type(String &str) const;
unknown's avatar
unknown committed
787
  uint size_of() const { return sizeof(*this); }
unknown's avatar
unknown committed
788
  uint32 max_length() { return 4; }
unknown's avatar
unknown committed
789 790 791
};


792
class Field_timestamp :public Field_str {
unknown's avatar
unknown committed
793 794
public:
  Field_timestamp(char *ptr_arg, uint32 len_arg,
795
                  uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
796
		  enum utype unireg_check_arg, const char *field_name_arg,
797 798
		  struct st_table *table_arg,
		  CHARSET_INFO *cs);
799 800
  Field_timestamp(bool maybe_null_arg, const char *field_name_arg,
		 struct st_table *table_arg, CHARSET_INFO *cs);
unknown's avatar
unknown committed
801 802
  enum_field_types type() const { return FIELD_TYPE_TIMESTAMP;}
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONG_INT; }
803
  enum Item_result cmp_type () const { return INT_RESULT; }
804 805
  int  store(const char *to,uint length,CHARSET_INFO *charset);
  int  store(double nr);
806
  int  store(longlong nr, bool unsigned_val);
807
  int  reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=0; return 0; }
unknown's avatar
unknown committed
808 809 810
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*,String *);
811
  bool send_binary(Protocol *protocol);
unknown's avatar
unknown committed
812 813 814 815
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint32 pack_length() const { return 4; }
  void sql_type(String &str) const;
816
  bool can_be_compared_as_longlong() const { return TRUE; }
unknown's avatar
unknown committed
817 818
  bool zero_pack() const { return 0; }
  void set_time();
unknown's avatar
unknown committed
819 820
  virtual void set_default()
  {
821 822
    if (table->timestamp_field == this &&
        unireg_check != TIMESTAMP_UN_FIELD)
823 824 825
      set_time();
    else
      Field::set_default();
unknown's avatar
unknown committed
826
  }
827 828
  /* Get TIMESTAMP field value as seconds since begging of Unix Epoch */
  inline long get_timestamp(my_bool *null_value)
unknown's avatar
unknown committed
829
  {
830 831
    if ((*null_value= is_null()))
      return 0;
unknown's avatar
unknown committed
832
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
833
    if (table && table->s->db_low_byte_first)
unknown's avatar
unknown committed
834 835 836 837 838 839
      return sint4korr(ptr);
#endif
    long tmp;
    longget(tmp,ptr);
    return tmp;
  }
840
  bool get_date(TIME *ltime,uint fuzzydate);
unknown's avatar
unknown committed
841
  bool get_time(TIME *ltime);
842
  timestamp_auto_set_type get_auto_set_type() const;
unknown's avatar
unknown committed
843 844 845 846 847 848
};


class Field_year :public Field_tiny {
public:
  Field_year(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
849
	     uchar null_bit_arg,
unknown's avatar
unknown committed
850 851 852 853 854 855
	     enum utype unireg_check_arg, const char *field_name_arg,
	     struct st_table *table_arg)
    :Field_tiny(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
		unireg_check_arg, field_name_arg, table_arg, 1, 1)
    {}
  enum_field_types type() const { return FIELD_TYPE_YEAR;}
856 857
  int  store(const char *to,uint length,CHARSET_INFO *charset);
  int  store(double nr);
858
  int  store(longlong nr, bool unsigned_val);
unknown's avatar
unknown committed
859 860 861
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*,String *);
862
  bool send_binary(Protocol *protocol);
unknown's avatar
unknown committed
863
  void sql_type(String &str) const;
864
  bool can_be_compared_as_longlong() const { return TRUE; }
unknown's avatar
unknown committed
865 866 867 868 869
};


class Field_date :public Field_str {
public:
unknown's avatar
unknown committed
870
  Field_date(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
871
	     enum utype unireg_check_arg, const char *field_name_arg,
872
	     struct st_table *table_arg, CHARSET_INFO *cs)
unknown's avatar
unknown committed
873
    :Field_str(ptr_arg, 10, null_ptr_arg, null_bit_arg,
874
	       unireg_check_arg, field_name_arg, table_arg, cs)
unknown's avatar
unknown committed
875
    {}
876
  Field_date(bool maybe_null_arg, const char *field_name_arg,
877
		 struct st_table *table_arg, CHARSET_INFO *cs)
878
    :Field_str((char*) 0,10, maybe_null_arg ? (uchar*) "": 0,0,
879
	       NONE, field_name_arg, table_arg, cs) {}
unknown's avatar
unknown committed
880 881 882
  enum_field_types type() const { return FIELD_TYPE_DATE;}
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONG_INT; }
  enum Item_result cmp_type () const { return INT_RESULT; }
883 884
  int store(const char *to,uint length,CHARSET_INFO *charset);
  int store(double nr);
885
  int store(longlong nr, bool unsigned_val);
886
  int reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=0; return 0; }
unknown's avatar
unknown committed
887 888 889
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*,String *);
890
  bool send_binary(Protocol *protocol);
unknown's avatar
unknown committed
891 892 893 894
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint32 pack_length() const { return 4; }
  void sql_type(String &str) const;
895
  bool can_be_compared_as_longlong() const { return TRUE; }
unknown's avatar
unknown committed
896 897 898 899 900
  bool zero_pack() const { return 1; }
};

class Field_newdate :public Field_str {
public:
unknown's avatar
unknown committed
901
  Field_newdate(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
902
		enum utype unireg_check_arg, const char *field_name_arg,
903
		struct st_table *table_arg, CHARSET_INFO *cs)
unknown's avatar
unknown committed
904
    :Field_str(ptr_arg, 10, null_ptr_arg, null_bit_arg,
905
	       unireg_check_arg, field_name_arg, table_arg, cs)
unknown's avatar
unknown committed
906 907 908 909 910
    {}
  enum_field_types type() const { return FIELD_TYPE_DATE;}
  enum_field_types real_type() const { return FIELD_TYPE_NEWDATE; }
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_UINT24; }
  enum Item_result cmp_type () const { return INT_RESULT; }
911 912
  int  store(const char *to,uint length,CHARSET_INFO *charset);
  int  store(double nr);
913
  int  store(longlong nr, bool unsigned_val);
unknown's avatar
Merge  
unknown committed
914
  int store_time(TIME *ltime, timestamp_type type);
915
  int reset(void) { ptr[0]=ptr[1]=ptr[2]=0; return 0; }
unknown's avatar
unknown committed
916 917 918
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*,String *);
919
  bool send_binary(Protocol *protocol);
unknown's avatar
unknown committed
920 921 922 923
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint32 pack_length() const { return 3; }
  void sql_type(String &str) const;
924
  bool can_be_compared_as_longlong() const { return TRUE; }
unknown's avatar
unknown committed
925
  bool zero_pack() const { return 1; }
926
  bool get_date(TIME *ltime,uint fuzzydate);
unknown's avatar
unknown committed
927 928 929 930 931 932
  bool get_time(TIME *ltime);
};


class Field_time :public Field_str {
public:
unknown's avatar
unknown committed
933
  Field_time(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
934
	     enum utype unireg_check_arg, const char *field_name_arg,
935
	     struct st_table *table_arg, CHARSET_INFO *cs)
unknown's avatar
unknown committed
936
    :Field_str(ptr_arg, 8, null_ptr_arg, null_bit_arg,
937
	       unireg_check_arg, field_name_arg, table_arg, cs)
unknown's avatar
unknown committed
938
    {}
939
  Field_time(bool maybe_null_arg, const char *field_name_arg,
940
		 struct st_table *table_arg, CHARSET_INFO *cs)
941
    :Field_str((char*) 0,8, maybe_null_arg ? (uchar*) "": 0,0,
942
	       NONE, field_name_arg, table_arg, cs) {}
unknown's avatar
unknown committed
943 944 945
  enum_field_types type() const { return FIELD_TYPE_TIME;}
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_INT24; }
  enum Item_result cmp_type () const { return INT_RESULT; }
unknown's avatar
Merge  
unknown committed
946
  int store_time(TIME *ltime, timestamp_type type);
947 948
  int store(const char *to,uint length,CHARSET_INFO *charset);
  int store(double nr);
949
  int store(longlong nr, bool unsigned_val);
950
  int reset(void) { ptr[0]=ptr[1]=ptr[2]=0; return 0; }
unknown's avatar
unknown committed
951 952 953
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*,String *);
unknown's avatar
unknown committed
954
  bool get_date(TIME *ltime, uint fuzzydate);
955
  bool send_binary(Protocol *protocol);
unknown's avatar
unknown committed
956 957 958 959 960
  bool get_time(TIME *ltime);
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint32 pack_length() const { return 3; }
  void sql_type(String &str) const;
961
  bool can_be_compared_as_longlong() const { return TRUE; }
unknown's avatar
unknown committed
962 963 964 965 966 967
  bool zero_pack() const { return 1; }
};


class Field_datetime :public Field_str {
public:
unknown's avatar
unknown committed
968
  Field_datetime(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
969
		 enum utype unireg_check_arg, const char *field_name_arg,
970
		 struct st_table *table_arg, CHARSET_INFO *cs)
unknown's avatar
unknown committed
971
    :Field_str(ptr_arg, 19, null_ptr_arg, null_bit_arg,
972
	       unireg_check_arg, field_name_arg, table_arg, cs)
unknown's avatar
unknown committed
973
    {}
974
  Field_datetime(bool maybe_null_arg, const char *field_name_arg,
975
		 struct st_table *table_arg, CHARSET_INFO *cs)
976
    :Field_str((char*) 0,19, maybe_null_arg ? (uchar*) "": 0,0,
977
	       NONE, field_name_arg, table_arg, cs) {}
unknown's avatar
unknown committed
978 979 980 981 982
  enum_field_types type() const { return FIELD_TYPE_DATETIME;}
#ifdef HAVE_LONG_LONG
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONGLONG; }
#endif
  enum Item_result cmp_type () const { return INT_RESULT; }
unknown's avatar
unknown committed
983
  uint decimals() const { return DATETIME_DEC; }
984 985
  int  store(const char *to,uint length,CHARSET_INFO *charset);
  int  store(double nr);
986
  int  store(longlong nr, bool unsigned_val);
unknown's avatar
Merge  
unknown committed
987
  int store_time(TIME *ltime, timestamp_type type);
988 989 990 991 992
  int reset(void)
  {
    ptr[0]=ptr[1]=ptr[2]=ptr[3]=ptr[4]=ptr[5]=ptr[6]=ptr[7]=0;
    return 0;
  }
unknown's avatar
unknown committed
993 994 995
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*,String *);
996
  bool send_binary(Protocol *protocol);
unknown's avatar
unknown committed
997 998 999 1000
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint32 pack_length() const { return 8; }
  void sql_type(String &str) const;
1001
  bool can_be_compared_as_longlong() const { return TRUE; }
unknown's avatar
unknown committed
1002
  bool zero_pack() const { return 1; }
1003
  bool get_date(TIME *ltime,uint fuzzydate);
unknown's avatar
unknown committed
1004 1005 1006 1007
  bool get_time(TIME *ltime);
};


unknown's avatar
unknown committed
1008
class Field_string :public Field_longstr {
unknown's avatar
unknown committed
1009
public:
1010
  bool can_alter_field_type;
unknown's avatar
unknown committed
1011
  Field_string(char *ptr_arg, uint32 len_arg,uchar *null_ptr_arg,
unknown's avatar
unknown committed
1012
	       uchar null_bit_arg,
unknown's avatar
unknown committed
1013
	       enum utype unireg_check_arg, const char *field_name_arg,
1014
	       struct st_table *table_arg, CHARSET_INFO *cs)
unknown's avatar
unknown committed
1015
    :Field_longstr(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
1016 1017
                   unireg_check_arg, field_name_arg, table_arg, cs),
     can_alter_field_type(1) {};
unknown's avatar
unknown committed
1018
  Field_string(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
unknown's avatar
unknown committed
1019 1020
               struct st_table *table_arg, CHARSET_INFO *cs)
    :Field_longstr((char*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0, 0,
1021 1022
                   NONE, field_name_arg, table_arg, cs),
     can_alter_field_type(1) {};
unknown's avatar
unknown committed
1023 1024 1025

  enum_field_types type() const
  {
1026
    return ((can_alter_field_type && orig_table &&
unknown's avatar
Merge  
unknown committed
1027 1028 1029 1030
             orig_table->s->db_create_options & HA_OPTION_PACK_RECORD &&
	     field_length >= 4) &&
            orig_table->s->frm_version < FRM_VER_TRUE_VARCHAR ?
	    MYSQL_TYPE_VAR_STRING : MYSQL_TYPE_STRING);
unknown's avatar
unknown committed
1031 1032
  }
  enum ha_base_keytype key_type() const
1033
    { return binary() ? HA_KEYTYPE_BINARY : HA_KEYTYPE_TEXT; }
unknown's avatar
unknown committed
1034
  bool zero_pack() const { return 0; }
1035 1036
  int reset(void)
  {
1037 1038
    charset()->cset->fill(charset(),ptr,field_length,
                          (has_charset() ? ' ' : 0));
1039 1040 1041
    return 0;
  }
  int store(const char *to,uint length,CHARSET_INFO *charset);
1042
  int store(longlong nr, bool unsigned_val);
1043
  int store(double nr) { return Field_str::store(nr); } /* QQ: To be deleted */
unknown's avatar
unknown committed
1044 1045 1046
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*,String *);
unknown's avatar
unknown committed
1047
  my_decimal *val_decimal(my_decimal *);
unknown's avatar
unknown committed
1048 1049 1050 1051 1052
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  void sql_type(String &str) const;
  char *pack(char *to, const char *from, uint max_length=~(uint) 0);
  const char *unpack(char* to, const char *from);
unknown's avatar
Merge  
unknown committed
1053 1054 1055
  int pack_cmp(const char *a,const char *b,uint key_length,
               my_bool insert_or_update);
  int pack_cmp(const char *b,uint key_length,my_bool insert_or_update);
1056
  uint packed_col_length(const char *to, uint length);
unknown's avatar
unknown committed
1057 1058 1059
  uint max_packed_col_length(uint max_length);
  uint size_of() const { return sizeof(*this); }
  enum_field_types real_type() const { return FIELD_TYPE_STRING; }
1060 1061
  bool has_charset(void) const
  { return charset() == &my_charset_bin ? FALSE : TRUE; }
1062
  Field *new_field(MEM_ROOT *root, struct st_table *new_table, bool keep_type);
unknown's avatar
unknown committed
1063 1064 1065
};


unknown's avatar
unknown committed
1066
class Field_varstring :public Field_longstr {
unknown's avatar
unknown committed
1067
public:
unknown's avatar
Merge  
unknown committed
1068 1069 1070 1071 1072
  /* Store number of bytes used to store length (1 or 2) */
  uint32 length_bytes;
  Field_varstring(char *ptr_arg,
                  uint32 len_arg, uint length_bytes_arg,
                  uchar *null_ptr_arg,
unknown's avatar
unknown committed
1073
		  uchar null_bit_arg,
unknown's avatar
unknown committed
1074
		  enum utype unireg_check_arg, const char *field_name_arg,
1075
		  struct st_table *table_arg, CHARSET_INFO *cs)
unknown's avatar
unknown committed
1076 1077 1078
    :Field_longstr(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
                   unireg_check_arg, field_name_arg, table_arg, cs),
     length_bytes(length_bytes_arg)
unknown's avatar
Merge  
unknown committed
1079 1080 1081 1082
  {
    if (table)
      table->s->varchar_fields++;
  }
unknown's avatar
unknown committed
1083
  Field_varstring(uint32 len_arg,bool maybe_null_arg,
unknown's avatar
unknown committed
1084 1085 1086 1087 1088
                  const char *field_name_arg,
                  struct st_table *table_arg, CHARSET_INFO *cs)
    :Field_longstr((char*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0, 0,
                   NONE, field_name_arg, table_arg, cs),
     length_bytes(len_arg < 256 ? 1 :2)
unknown's avatar
Merge  
unknown committed
1089 1090 1091 1092
  {
    if (table)
      table->s->varchar_fields++;
  }
unknown's avatar
unknown committed
1093

unknown's avatar
Merge  
unknown committed
1094 1095
  enum_field_types type() const { return MYSQL_TYPE_VARCHAR; }
  enum ha_base_keytype key_type() const;
unknown's avatar
unknown committed
1096
  bool zero_pack() const { return 0; }
1097
  int  reset(void) { bzero(ptr,field_length+length_bytes); return 0; }
unknown's avatar
Merge  
unknown committed
1098
  uint32 pack_length() const { return (uint32) field_length+length_bytes; }
unknown's avatar
unknown committed
1099
  uint32 key_length() const { return (uint32) field_length; }
1100 1101 1102 1103 1104
  uint32 sort_length() const
  {
    return (uint32) field_length + (field_charset == &my_charset_bin ?
                                    length_bytes : 0);
  }
1105
  int  store(const char *to,uint length,CHARSET_INFO *charset);
1106
  int  store(longlong nr, bool unsigned_val);
1107
  int  store(double nr) { return Field_str::store(nr); } /* QQ: To be deleted */
unknown's avatar
unknown committed
1108 1109 1110
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*,String *);
unknown's avatar
unknown committed
1111
  my_decimal *val_decimal(my_decimal *);
unknown's avatar
unknown committed
1112 1113
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
unknown's avatar
Merge  
unknown committed
1114 1115
  void get_key_image(char *buff,uint length, imagetype type);
  void set_key_image(char *buff,uint length);
unknown's avatar
unknown committed
1116 1117
  void sql_type(String &str) const;
  char *pack(char *to, const char *from, uint max_length=~(uint) 0);
1118
  char *pack_key(char *to, const char *from, uint max_length);
unknown's avatar
Merge  
unknown committed
1119
  char *pack_key_from_key_image(char* to, const char *from, uint max_length);
unknown's avatar
unknown committed
1120
  const char *unpack(char* to, const char *from);
unknown's avatar
Merge  
unknown committed
1121 1122 1123 1124 1125 1126 1127
  const char *unpack_key(char* to, const char *from, uint max_length);
  int pack_cmp(const char *a, const char *b, uint key_length,
               my_bool insert_or_update);
  int pack_cmp(const char *b, uint key_length,my_bool insert_or_update);
  int cmp_binary(const char *a,const char *b, uint32 max_length=~0L);
  int key_cmp(const byte *,const byte*);
  int key_cmp(const byte *str, uint length);
1128
  uint packed_col_length(const char *to, uint length);
unknown's avatar
unknown committed
1129
  uint max_packed_col_length(uint max_length);
unknown's avatar
unknown committed
1130
  uint32 data_length(const char *from);
unknown's avatar
unknown committed
1131
  uint size_of() const { return sizeof(*this); }
unknown's avatar
Merge  
unknown committed
1132
  enum_field_types real_type() const { return MYSQL_TYPE_VARCHAR; }
1133 1134
  bool has_charset(void) const
  { return charset() == &my_charset_bin ? FALSE : TRUE; }
1135
  Field *new_field(MEM_ROOT *root, struct st_table *new_table, bool keep_type);
unknown's avatar
Merge  
unknown committed
1136 1137 1138
  Field *new_key_field(MEM_ROOT *root, struct st_table *new_table,
                       char *new_ptr, uchar *new_null_ptr,
                       uint new_null_bit);
unknown's avatar
unknown committed
1139 1140 1141
};


unknown's avatar
unknown committed
1142
class Field_blob :public Field_longstr {
unknown's avatar
unknown committed
1143
protected:
unknown's avatar
unknown committed
1144
  uint packlength;
1145
  String value;				// For temporaries
unknown's avatar
unknown committed
1146
public:
unknown's avatar
unknown committed
1147
  Field_blob(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
1148 1149
	     enum utype unireg_check_arg, const char *field_name_arg,
	     struct st_table *table_arg,uint blob_pack_length,
1150
	     CHARSET_INFO *cs);
unknown's avatar
unknown committed
1151
  Field_blob(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
1152
	     struct st_table *table_arg, CHARSET_INFO *cs)
unknown's avatar
unknown committed
1153 1154
    :Field_longstr((char*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0, 0,
                   NONE, field_name_arg, table_arg, cs),
unknown's avatar
unknown committed
1155
    packlength(4)
unknown's avatar
unknown committed
1156 1157 1158
  {
    flags|= BLOB_FLAG;
  }
1159 1160 1161 1162 1163 1164 1165 1166 1167
  Field_blob(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
	     struct st_table *table_arg, CHARSET_INFO *cs, bool set_packlength)
    :Field_longstr((char*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0, 0,
                   NONE, field_name_arg, table_arg, cs)
  {
    flags|= BLOB_FLAG;
    packlength= 4;
    if (set_packlength)
    {
unknown's avatar
unknown committed
1168
      uint32 char_length= len_arg/cs->mbmaxlen;
1169 1170 1171 1172 1173
      packlength= char_length <= 255 ? 1 :
                  char_length <= 65535 ? 2 :
                  char_length <= 16777215 ? 3 : 4;
    }
  }
unknown's avatar
unknown committed
1174 1175
  enum_field_types type() const { return FIELD_TYPE_BLOB;}
  enum ha_base_keytype key_type() const
unknown's avatar
Merge  
unknown committed
1176
    { return binary() ? HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2; }
1177 1178
  int  store(const char *to,uint length,CHARSET_INFO *charset);
  int  store(double nr);
1179
  int  store(longlong nr, bool unsigned_val);
unknown's avatar
unknown committed
1180 1181 1182
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*,String *);
unknown's avatar
unknown committed
1183
  my_decimal *val_decimal(my_decimal *);
unknown's avatar
unknown committed
1184
  int cmp(const char *,const char*);
unknown's avatar
unknown committed
1185 1186
  int cmp(const char *a, uint32 a_length, const char *b, uint32 b_length);
  int cmp_binary(const char *a,const char *b, uint32 max_length=~0L);
unknown's avatar
unknown committed
1187 1188 1189 1190
  int key_cmp(const byte *,const byte*);
  int key_cmp(const byte *str, uint length);
  uint32 key_length() const { return 0; }
  void sort_string(char *buff,uint length);
unknown's avatar
unknown committed
1191
  uint32 pack_length() const
unknown's avatar
Merge  
unknown committed
1192
  { return (uint32) (packlength+table->s->blob_ptr_size); }
1193
  uint32 sort_length() const;
1194
  inline uint32 max_data_length() const
1195
  {
1196
    return (uint32) (((ulonglong) 1 << (packlength*8)) -1);
1197
  }
1198
  int reset(void) { bzero(ptr, packlength+sizeof(char*)); return 0; }
unknown's avatar
unknown committed
1199
  void reset_fields() { bzero((char*) &value,sizeof(value)); }
unknown's avatar
unknown committed
1200 1201
  void store_length(uint32 number);
  inline uint32 get_length(uint row_offset=0)
unknown's avatar
unknown committed
1202
  { return get_length(ptr+row_offset); }
unknown's avatar
unknown committed
1203
  uint32 get_length(const char *ptr);
1204
  void put_length(char *pos, uint32 length);
unknown's avatar
unknown committed
1205 1206 1207 1208 1209 1210 1211 1212 1213
  inline void get_ptr(char **str)
    {
      memcpy_fixed(str,ptr+packlength,sizeof(char*));
    }
  inline void set_ptr(char *length,char *data)
    {
      memcpy(ptr,length,packlength);
      memcpy_fixed(ptr+packlength,&data,sizeof(char*));
    }
unknown's avatar
unknown committed
1214
  inline void set_ptr(uint32 length,char *data)
unknown's avatar
unknown committed
1215 1216 1217 1218
    {
      store_length(length);
      memcpy_fixed(ptr+packlength,&data,sizeof(char*));
    }
unknown's avatar
Merge  
unknown committed
1219 1220
  void get_key_image(char *buff,uint length, imagetype type);
  void set_key_image(char *buff,uint length);
unknown's avatar
unknown committed
1221 1222 1223 1224
  void sql_type(String &str) const;
  inline bool copy()
  { char *tmp;
    get_ptr(&tmp);
1225
    if (value.copy(tmp,get_length(),charset()))
unknown's avatar
unknown committed
1226 1227 1228 1229 1230 1231 1232
    {
      Field_blob::reset();
      return 1;
    }
    tmp=(char*) value.ptr(); memcpy_fixed(ptr+packlength,&tmp,sizeof(char*));
    return 0;
  }
1233 1234 1235
  char *pack(char *to, const char *from, uint max_length= ~(uint) 0);
  char *pack_key(char *to, const char *from, uint max_length);
  char *pack_key_from_key_image(char* to, const char *from, uint max_length);
unknown's avatar
Merge  
unknown committed
1236
  const char *unpack(char *to, const char *from);
1237
  const char *unpack_key(char* to, const char *from, uint max_length);
unknown's avatar
Merge  
unknown committed
1238 1239 1240
  int pack_cmp(const char *a, const char *b, uint key_length,
               my_bool insert_or_update);
  int pack_cmp(const char *b, uint key_length,my_bool insert_or_update);
1241 1242
  uint packed_col_length(const char *col_ptr, uint length);
  uint max_packed_col_length(uint max_length);
1243
  void free() { value.free(); }
unknown's avatar
unknown committed
1244 1245 1246
  inline void clear_temporary() { bzero((char*) &value,sizeof(value)); }
  friend void field_conv(Field *to,Field *from);
  uint size_of() const { return sizeof(*this); }
1247
  bool has_charset(void) const
1248
  { return charset() == &my_charset_bin ? FALSE : TRUE; }
1249 1250 1251
  uint32 max_length();
};

unknown's avatar
Merge  
unknown committed
1252

unknown's avatar
unknown committed
1253
#ifdef HAVE_SPATIAL
unknown's avatar
unknown committed
1254 1255
class Field_geom :public Field_blob {
public:
unknown's avatar
unknown committed
1256
  enum geometry_type geom_type;
1257

unknown's avatar
unknown committed
1258 1259
  Field_geom(char *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg,
	     enum utype unireg_check_arg, const char *field_name_arg,
unknown's avatar
unknown committed
1260 1261
	     struct st_table *table_arg,uint blob_pack_length,
	     enum geometry_type geom_type_arg)
unknown's avatar
unknown committed
1262
     :Field_blob(ptr_arg, null_ptr_arg, null_bit_arg, unireg_check_arg, 
unknown's avatar
unknown committed
1263 1264
                 field_name_arg, table_arg, blob_pack_length,&my_charset_bin)
  { geom_type= geom_type_arg; }
unknown's avatar
unknown committed
1265
  Field_geom(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
unknown's avatar
unknown committed
1266
	     struct st_table *table_arg, enum geometry_type geom_type_arg)
unknown's avatar
unknown committed
1267
     :Field_blob(len_arg, maybe_null_arg, field_name_arg,
unknown's avatar
unknown committed
1268 1269
                 table_arg, &my_charset_bin)
  { geom_type= geom_type_arg; }
unknown's avatar
Merge  
unknown committed
1270
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_VARBINARY2; }
unknown's avatar
unknown committed
1271
  enum_field_types type() const { return FIELD_TYPE_GEOMETRY; }
unknown's avatar
unknown committed
1272
  void sql_type(String &str) const;
unknown's avatar
unknown committed
1273
  int  store(const char *to, uint length, CHARSET_INFO *charset);
1274
  int  store(double nr);
1275
  int  store(longlong nr, bool unsigned_val);
1276
  int  store_decimal(const my_decimal *);
unknown's avatar
Merge  
unknown committed
1277
  void get_key_image(char *buff,uint length,imagetype type);
1278
  uint size_of() const { return sizeof(*this); }
1279
  int  reset(void) { return !maybe_null(); }
unknown's avatar
unknown committed
1280
};
unknown's avatar
unknown committed
1281
#endif /*HAVE_SPATIAL*/
unknown's avatar
unknown committed
1282

unknown's avatar
Merge  
unknown committed
1283

unknown's avatar
unknown committed
1284 1285 1286 1287 1288 1289
class Field_enum :public Field_str {
protected:
  uint packlength;
public:
  TYPELIB *typelib;
  Field_enum(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
1290
		 uchar null_bit_arg,
unknown's avatar
unknown committed
1291 1292
		 enum utype unireg_check_arg, const char *field_name_arg,
		 struct st_table *table_arg,uint packlength_arg,
1293 1294
		 TYPELIB *typelib_arg,
		 CHARSET_INFO *charset_arg)
unknown's avatar
unknown committed
1295
    :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
1296
	       unireg_check_arg, field_name_arg, table_arg, charset_arg),
unknown's avatar
unknown committed
1297
    packlength(packlength_arg),typelib(typelib_arg)
unknown's avatar
unknown committed
1298
  {
unknown's avatar
unknown committed
1299
      flags|=ENUM_FLAG;
unknown's avatar
unknown committed
1300
  }
unknown's avatar
unknown committed
1301 1302
  enum_field_types type() const { return FIELD_TYPE_STRING; }
  enum Item_result cmp_type () const { return INT_RESULT; }
1303
  enum Item_result cast_to_int_type () const { return INT_RESULT; }
unknown's avatar
unknown committed
1304
  enum ha_base_keytype key_type() const;
1305 1306
  int  store(const char *to,uint length,CHARSET_INFO *charset);
  int  store(double nr);
1307
  int  store(longlong nr, bool unsigned_val);
1308
  int reset() { bzero(ptr,packlength); return 0; }
unknown's avatar
unknown committed
1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*,String *);
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint32 pack_length() const { return (uint32) packlength; }
  void store_type(ulonglong value);
  void sql_type(String &str) const;
  uint size_of() const { return sizeof(*this); }
  enum_field_types real_type() const { return FIELD_TYPE_ENUM; }
  virtual bool zero_pack() const { return 0; }
1320
  bool optimize_range(uint idx, uint part) { return 0; }
unknown's avatar
unknown committed
1321
  bool eq_def(Field *field);
1322
  bool has_charset(void) const { return TRUE; }
1323 1324
  /* enum and set are sorted as integers */
  CHARSET_INFO *sort_charset(void) const { return &my_charset_bin; }
unknown's avatar
unknown committed
1325 1326 1327 1328 1329 1330
};


class Field_set :public Field_enum {
public:
  Field_set(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
1331
	    uchar null_bit_arg,
unknown's avatar
unknown committed
1332 1333
	    enum utype unireg_check_arg, const char *field_name_arg,
	    struct st_table *table_arg,uint32 packlength_arg,
1334
	    TYPELIB *typelib_arg, CHARSET_INFO *charset_arg)
unknown's avatar
unknown committed
1335 1336 1337
    :Field_enum(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
		    unireg_check_arg, field_name_arg,
		    table_arg, packlength_arg,
1338
		    typelib_arg,charset_arg)
unknown's avatar
unknown committed
1339 1340 1341
    {
      flags=(flags & ~ENUM_FLAG) | SET_FLAG;
    }
1342
  int  store(const char *to,uint length,CHARSET_INFO *charset);
1343 1344
  int  store(double nr) { return Field_set::store((longlong) nr, FALSE); }
  int  store(longlong nr, bool unsigned_val);
unknown's avatar
unknown committed
1345 1346 1347 1348
  virtual bool zero_pack() const { return 1; }
  String *val_str(String*,String *);
  void sql_type(String &str) const;
  enum_field_types real_type() const { return FIELD_TYPE_SET; }
1349
  bool has_charset(void) const { return TRUE; }
unknown's avatar
unknown committed
1350 1351 1352
};


unknown's avatar
Merge  
unknown committed
1353 1354 1355 1356 1357
class Field_bit :public Field {
public:
  uchar *bit_ptr;     // position in record where 'uneven' bits store
  uchar bit_ofs;      // offset to 'uneven' high bits
  uint bit_len;       // number of 'uneven' high bits
unknown's avatar
unknown committed
1358
  uint bytes_in_rec;
unknown's avatar
Merge  
unknown committed
1359 1360 1361 1362 1363 1364
  Field_bit(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
            uchar null_bit_arg, uchar *bit_ptr_arg, uchar bit_ofs_arg,
            enum utype unireg_check_arg, const char *field_name_arg,
            struct st_table *table_arg);
  enum_field_types type() const { return FIELD_TYPE_BIT; }
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_BIT; }
unknown's avatar
unknown committed
1365 1366
  uint32 key_length() const { return (uint32) (field_length + 7) / 8; }
  uint32 max_length() { return field_length; }
unknown's avatar
Merge  
unknown committed
1367 1368
  uint size_of() const { return sizeof(*this); }
  Item_result result_type () const { return INT_RESULT; }
1369
  int reset(void) { bzero(ptr, bytes_in_rec); return 0; }
unknown's avatar
Merge  
unknown committed
1370 1371
  int store(const char *to, uint length, CHARSET_INFO *charset);
  int store(double nr);
1372
  int store(longlong nr, bool unsigned_val);
unknown's avatar
unknown committed
1373
  int store_decimal(const my_decimal *);
unknown's avatar
Merge  
unknown committed
1374 1375 1376
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*, String *);
unknown's avatar
unknown committed
1377
  my_decimal *val_decimal(my_decimal *);
unknown's avatar
Merge  
unknown committed
1378 1379 1380 1381 1382 1383
  int cmp(const char *a, const char *b)
  { return cmp_binary(a, b); }
  int key_cmp(const byte *a, const byte *b)
  { return cmp_binary((char *) a, (char *) b); }
  int key_cmp(const byte *str, uint length);
  int cmp_offset(uint row_offset);
1384 1385
  int cmp_binary_offset(uint row_offset)
  { return cmp_offset(row_offset); }
unknown's avatar
Merge  
unknown committed
1386 1387 1388 1389 1390
  void get_key_image(char *buff, uint length, imagetype type);
  void set_key_image(char *buff, uint length)
  { Field_bit::store(buff, length, &my_charset_bin); }
  void sort_string(char *buff, uint length)
  { get_key_image(buff, length, itRAW); }
unknown's avatar
unknown committed
1391 1392
  uint32 pack_length() const { return (uint32) (field_length + 7) / 8; }
  uint32 pack_length_in_rec() const { return bytes_in_rec; }
unknown's avatar
Merge  
unknown committed
1393 1394 1395 1396 1397 1398
  void sql_type(String &str) const;
  char *pack(char *to, const char *from, uint max_length=~(uint) 0);
  const char *unpack(char* to, const char *from);
  Field *new_key_field(MEM_ROOT *root, struct st_table *new_table,
                       char *new_ptr, uchar *new_null_ptr,
                       uint new_null_bit);
unknown's avatar
unknown committed
1399 1400 1401 1402 1403
  void set_bit_ptr(uchar *bit_ptr_arg, uchar bit_ofs_arg)
  {
    bit_ptr= bit_ptr_arg;
    bit_ofs= bit_ofs_arg;
  }
1404 1405 1406 1407 1408 1409 1410
  bool eq(Field *field)
  {
    return (Field::eq(field) &&
            field->type() == type() &&
            bit_ptr == ((Field_bit *)field)->bit_ptr &&
            bit_ofs == ((Field_bit *)field)->bit_ofs);
  }
unknown's avatar
Merge  
unknown committed
1411 1412
};

1413

1414 1415 1416
class Field_bit_as_char: public Field_bit {
public:
  Field_bit_as_char(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
1417
                    uchar null_bit_arg,
1418 1419 1420
                    enum utype unireg_check_arg, const char *field_name_arg,
                    struct st_table *table_arg);
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_BINARY; }
unknown's avatar
unknown committed
1421
  uint size_of() const { return sizeof(*this); }
1422 1423
  int store(const char *to, uint length, CHARSET_INFO *charset);
  int store(double nr) { return Field_bit::store(nr); }
1424 1425
  int store(longlong nr, bool unsigned_val)
  { return Field_bit::store(nr, unsigned_val); }
1426 1427 1428 1429
  void sql_type(String &str) const;
};


unknown's avatar
unknown committed
1430
/*
unknown's avatar
unknown committed
1431
  Create field class for CREATE TABLE
unknown's avatar
unknown committed
1432 1433
*/

1434 1435
class create_field :public Sql_alloc
{
unknown's avatar
unknown committed
1436 1437
public:
  const char *field_name;
1438 1439
  const char *change;			// If done with alter table
  const char *after;			// Put column after this one
unknown's avatar
unknown committed
1440
  LEX_STRING comment;			// Comment for field
1441
  Item	*def;				// Default value
unknown's avatar
unknown committed
1442
  enum	enum_field_types sql_type;
1443 1444 1445 1446
  /*
    At various stages in execution this can be length of field in bytes or
    max number of characters. 
  */
unknown's avatar
unknown committed
1447
  ulong length;
unknown's avatar
unknown committed
1448
  /*
1449 1450
    The value of `length' as set by parser: is the number of characters
    for most of the types, or of bytes for BLOBs or numeric types.
unknown's avatar
unknown committed
1451
  */
1452
  uint32 char_length;
unknown's avatar
Merge  
unknown committed
1453
  uint  decimals, flags, pack_length, key_length;
unknown's avatar
unknown committed
1454
  Field::utype unireg_check;
1455
  TYPELIB *interval;			// Which interval to use
unknown's avatar
unknown committed
1456 1457
  TYPELIB *save_interval;               // Temporary copy for the above
                                        // Used only for UCS2 intervals
1458
  List<String> interval_list;
1459
  CHARSET_INFO *charset;
unknown's avatar
unknown committed
1460
  Field::geometry_type geom_type;
1461
  Field *field;				// For alter table
unknown's avatar
unknown committed
1462

1463
  uint8 row,col,sc_length,interval_id;	// For rea_create_table
unknown's avatar
unknown committed
1464 1465
  uint	offset,pack_flag;
  create_field() :after(0) {}
1466
  create_field(Field *field, Field *orig_field);
1467
  void create_length_to_internal_length(void);
1468 1469 1470 1471 1472

  /* Init for a tmp table field. To be extended if need be. */
  void init_for_tmp_table(enum_field_types sql_type_arg,
                          uint32 max_length, uint32 decimals,
                          bool maybe_null, bool is_unsigned);
1473 1474 1475 1476 1477 1478

  bool init(THD *thd, char *field_name, enum_field_types type, char *length,
            char *decimals, uint type_modifier, Item *default_value,
            Item *on_update_value, LEX_STRING *comment, char *change,
            List<String> *interval_list, CHARSET_INFO *cs,
            uint uint_geom_type);
unknown's avatar
unknown committed
1479 1480 1481 1482
};


/*
unknown's avatar
unknown committed
1483
  A class for sending info to the client
unknown's avatar
unknown committed
1484 1485 1486 1487
*/

class Send_field {
 public:
unknown's avatar
unknown committed
1488 1489 1490
  const char *db_name;
  const char *table_name,*org_table_name;
  const char *col_name,*org_col_name;
1491 1492
  ulong length;
  uint charsetnr, flags, decimals;
unknown's avatar
unknown committed
1493 1494 1495 1496 1497 1498
  enum_field_types type;
  Send_field() {}
};


/*
1499
  A class for quick copying data to fields
unknown's avatar
unknown committed
1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510
*/

class Copy_field :public Sql_alloc {
  void (*get_copy_func(Field *to,Field *from))(Copy_field *);
public:
  char *from_ptr,*to_ptr;
  uchar *from_null_ptr,*to_null_ptr;
  my_bool *null_row;
  uint	from_bit,to_bit;
  uint from_length,to_length;
  Field *from_field,*to_field;
1511
  String tmp;					// For items
unknown's avatar
unknown committed
1512 1513 1514

  Copy_field() {}
  ~Copy_field() {}
1515 1516
  void set(Field *to,Field *from,bool save);	// Field to field 
  void set(char *to,Field *from);		// Field to string
unknown's avatar
unknown committed
1517
  void (*do_copy)(Copy_field *);
1518
  void (*do_copy2)(Copy_field *);		// Used to handle null values
unknown's avatar
unknown committed
1519 1520 1521 1522
};


Field *make_field(char *ptr, uint32 field_length,
unknown's avatar
unknown committed
1523
		  uchar *null_pos, uchar null_bit,
1524
		  uint pack_flag, enum_field_types field_type,
1525
		  CHARSET_INFO *cs,
unknown's avatar
unknown committed
1526
		  Field::geometry_type geom_type,
1527
		  Field::utype unireg_check,
unknown's avatar
unknown committed
1528 1529 1530
		  TYPELIB *interval, const char *field_name,
		  struct st_table *table);
uint pack_length_to_packflag(uint type);
unknown's avatar
Merge  
unknown committed
1531
enum_field_types get_blob_type_from_length(ulong length);
unknown's avatar
unknown committed
1532
uint32 calc_pack_length(enum_field_types type,uint32 length);
unknown's avatar
unknown committed
1533 1534
int set_field_to_null(Field *field);
int set_field_to_null_with_conversions(Field *field, bool no_conversions);
unknown's avatar
unknown committed
1535 1536

/*
1537
  The following are for the interface with the .frm file
unknown's avatar
unknown committed
1538 1539 1540
*/

#define FIELDFLAG_DECIMAL		1
1541
#define FIELDFLAG_BINARY		1	// Shares same flag
unknown's avatar
unknown committed
1542 1543
#define FIELDFLAG_NUMBER		2
#define FIELDFLAG_ZEROFILL		4
1544
#define FIELDFLAG_PACK			120	// Bits used for packing
1545 1546 1547 1548
#define FIELDFLAG_INTERVAL		256     // mangled with decimals!
#define FIELDFLAG_BITFIELD		512	// mangled with decimals!
#define FIELDFLAG_BLOB			1024	// mangled with decimals!
#define FIELDFLAG_GEOM			2048    // mangled with decimals!
unknown's avatar
unknown committed
1549

1550 1551
#define FIELDFLAG_TREAT_BIT_AS_CHAR     4096    /* use Field_bit_as_char */

unknown's avatar
unknown committed
1552 1553
#define FIELDFLAG_LEFT_FULLSCREEN	8192
#define FIELDFLAG_RIGHT_FULLSCREEN	16384
1554
#define FIELDFLAG_FORMAT_NUMBER		16384	// predit: ###,,## in output
unknown's avatar
Merge  
unknown committed
1555
#define FIELDFLAG_NO_DEFAULT		16384   /* sql */
1556 1557
#define FIELDFLAG_SUM			((uint) 32768)// predit: +#fieldflag
#define FIELDFLAG_MAYBE_NULL		((uint) 32768)// sql
unknown's avatar
unknown committed
1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570
#define FIELDFLAG_PACK_SHIFT		3
#define FIELDFLAG_DEC_SHIFT		8
#define FIELDFLAG_MAX_DEC		31
#define FIELDFLAG_NUM_SCREEN_TYPE	0x7F01
#define FIELDFLAG_ALFA_SCREEN_TYPE	0x7800

#define MTYP_TYPENR(type) (type & 127)	/* Remove bits from type */

#define f_is_dec(x)		((x) & FIELDFLAG_DECIMAL)
#define f_is_num(x)		((x) & FIELDFLAG_NUMBER)
#define f_is_zerofill(x)	((x) & FIELDFLAG_ZEROFILL)
#define f_is_packed(x)		((x) & FIELDFLAG_PACK)
#define f_packtype(x)		(((x) >> FIELDFLAG_PACK_SHIFT) & 15)
unknown's avatar
unknown committed
1571
#define f_decimals(x)		((uint8) (((x) >> FIELDFLAG_DEC_SHIFT) & FIELDFLAG_MAX_DEC))
unknown's avatar
unknown committed
1572
#define f_is_alpha(x)		(!f_is_num(x))
1573
#define f_is_binary(x)          ((x) & FIELDFLAG_BINARY) // 4.0- compatibility
1574 1575
#define f_is_enum(x)            (((x) & (FIELDFLAG_INTERVAL | FIELDFLAG_NUMBER)) == FIELDFLAG_INTERVAL)
#define f_is_bitfield(x)        (((x) & (FIELDFLAG_BITFIELD | FIELDFLAG_NUMBER)) == FIELDFLAG_BITFIELD)
unknown's avatar
unknown committed
1576
#define f_is_blob(x)		(((x) & (FIELDFLAG_BLOB | FIELDFLAG_NUMBER)) == FIELDFLAG_BLOB)
1577
#define f_is_geom(x)		(((x) & (FIELDFLAG_GEOM | FIELDFLAG_NUMBER)) == FIELDFLAG_GEOM)
unknown's avatar
unknown committed
1578 1579 1580
#define f_is_equ(x)		((x) & (1+2+FIELDFLAG_PACK+31*256))
#define f_settype(x)		(((int) x) << FIELDFLAG_PACK_SHIFT)
#define f_maybe_null(x)		(x & FIELDFLAG_MAYBE_NULL)
unknown's avatar
Merge  
unknown committed
1581
#define f_no_default(x)		(x & FIELDFLAG_NO_DEFAULT)
1582
#define f_bit_as_char(x)        ((x) & FIELDFLAG_TREAT_BIT_AS_CHAR)