field.h 39.5 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
unknown's avatar
unknown committed
2

unknown's avatar
unknown committed
3 4 5 6
   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
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
unknown's avatar
unknown committed
7

unknown's avatar
unknown committed
8 9 10 11
   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
12

unknown's avatar
unknown committed
13 14 15 16 17 18
   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
19 20
  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
21 22 23 24 25 26 27 28 29 30
*/

#ifdef __GNUC__
#pragma interface			/* gcc class implementation */
#endif

#define NOT_FIXED_DEC			31

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

class Field {
unknown's avatar
unknown committed
34
  Field(const Item &);				/* Prevent use of these */
unknown's avatar
unknown committed
35 36
  void operator=(Field &);
public:
unknown's avatar
unknown committed
37
  static void *operator new(size_t size) {return (void*) sql_alloc((uint) size); }
unknown's avatar
unknown committed
38 39
  static void operator delete(void *ptr_arg, size_t size) {} /*lint -e715 */

40 41 42
  char		*ptr;			// Position to field in record
  uchar		*null_ptr;		// Byte where null_bit is
  struct st_table *table;		// Pointer for table
unknown's avatar
unknown committed
43
  const char	*table_name,*field_name;
44
  ulong		query_id;		// For quick test of used fields
unknown's avatar
unknown committed
45
  /* Field is part of the following keys */
unknown's avatar
unknown committed
46 47 48 49 50
  key_map 	key_start,part_of_key,part_of_sortkey;
  enum utype  { NONE,DATE,SHIELD,NOEMPTY,CASEUP,PNR,BGNR,PGNR,YES,NO,REL,
		CHECK,EMPTY,UNKNOWN_FIELD,CASEDN,NEXT_NUMBER,INTERVAL_FIELD,
		BIT_FIELD, TIMESTAMP_FIELD,CAPITALIZE,BLOB_FIELD};
  utype		unireg_check;
51
  uint32	field_length;		// Length of field
unknown's avatar
unknown committed
52
  uint16	flags;
53
  uchar		null_bit;		// Bit used to test null bit
unknown's avatar
unknown committed
54 55

  Field(char *ptr_arg,uint32 length_arg,uchar *null_ptr_arg,uchar null_bit_arg,
unknown's avatar
unknown committed
56 57 58 59 60 61 62 63 64 65 66 67
	utype unireg_check_arg, const char *field_name_arg,
	struct st_table *table_arg);
  virtual ~Field() {}
  virtual void store(const char *to,uint length)=0;
  virtual void store(double nr)=0;
  virtual void store(longlong nr)=0;
  virtual void store_time(TIME *ltime,timestamp_type t_type);
  virtual double val_real(void)=0;
  virtual longlong val_int(void)=0;
  virtual String *val_str(String*,String *)=0;
  virtual Item_result result_type () const=0;
  virtual Item_result cmp_type () const { return result_type(); }
68
  bool eq(Field *field) { return ptr == field->ptr && null_ptr == field->null_ptr; }
unknown's avatar
unknown committed
69 70 71 72
  virtual bool eq_def(Field *field);
  virtual uint32 pack_length() const { return (uint32) field_length; }
  virtual void reset(void) { bzero(ptr,pack_length()); }
  virtual void reset_fields() {}
unknown's avatar
unknown committed
73 74
  virtual void set_default()
  {
unknown's avatar
unknown committed
75 76 77
    my_ptrdiff_t offset = (my_ptrdiff_t) (table->record[2] -
					  table->record[0]);
    memcpy(ptr, ptr + offset, pack_length());
78 79
    if (null_ptr)
      *null_ptr= ((*null_ptr & (uchar) ~null_bit) |
unknown's avatar
unknown committed
80
		  null_ptr[offset] & null_bit);
unknown's avatar
unknown committed
81
  }
unknown's avatar
unknown committed
82 83 84 85 86 87 88 89
  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
90
  virtual int cmp_binary(const char *a,const char *b, uint32 max_length=~0L)
unknown's avatar
unknown committed
91 92 93 94 95 96 97 98 99 100
  { return memcmp(a,b,pack_length()); }
  virtual int cmp_offset(uint row_offset)
  { return memcmp(ptr,ptr+row_offset,pack_length()); }
  virtual int cmp_binary_offset(uint row_offset)
  { return memcmp(ptr,ptr+row_offset,pack_length()); }
  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
101 102 103 104 105
  /*
    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
  */
106
  virtual void sql_type(String &str) const =0;
107
  virtual uint size_of() const =0;		// For new field
unknown's avatar
unknown committed
108 109 110 111 112 113 114
  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; }
  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
115
    { if (null_ptr) null_ptr[row_offset]&= (uchar) ~null_bit; }
unknown's avatar
unknown committed
116 117 118 119
  inline bool maybe_null(void) { return null_ptr != 0 || table->maybe_null; }
  inline bool real_maybe_null(void) { return null_ptr != 0; }
  virtual void make_field(Send_field *)=0;
  virtual void sort_string(char *buff,uint length)=0;
120
  virtual bool optimize_range(uint idx);
unknown's avatar
unknown committed
121
  virtual bool store_for_compare() { return 0; }
unknown's avatar
unknown committed
122 123 124 125
  Field *new_field(MEM_ROOT *root, struct st_table *new_table)
  {
    Field *tmp= (Field*) memdup_root(root,(char*) this,size_of());
    if (tmp)
unknown's avatar
unknown committed
126
    {
127 128
      if (tmp->table->maybe_null)
	tmp->flags&= ~NOT_NULL_FLAG;
unknown's avatar
unknown committed
129 130 131 132 133
      tmp->table=new_table;
      tmp->key_start=tmp->part_of_key=tmp->part_of_sortkey=0;
      tmp->unireg_check=Field::NONE;
      tmp->flags&= (NOT_NULL_FLAG | BLOB_FLAG | UNSIGNED_FLAG | ZEROFILL_FLAG | BINARY_FLAG | ENUM_FLAG | SET_FLAG);
      tmp->reset_fields();
unknown's avatar
unknown committed
134
    }
unknown's avatar
unknown committed
135 136 137 138 139 140
    return tmp;
  }
  inline void move_field(char *ptr_arg,uchar *null_ptr_arg,uchar null_bit_arg)
  {
    ptr=ptr_arg; null_ptr=null_ptr_arg; null_bit=null_bit_arg;
  }
unknown's avatar
unknown committed
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
  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*);
  }
  inline void get_image(char *buff,uint length)
    { memcpy(buff,ptr,length); }
  inline void set_image(char *buff,uint length)
    { memcpy(ptr,buff,length); }
  virtual void get_key_image(char *buff,uint length)
    { get_image(buff,length); }
  virtual void set_key_image(char *buff,uint length)
    { set_image(buff,length); }
  inline int cmp_image(char *buff,uint length)
    {
      if (binary())
	return memcmp(ptr,buff,length);
      else
	return my_casecmp(ptr,buff,length);
    }
  inline longlong val_int_offset(uint row_offset)
    {
      ptr+=row_offset;
      longlong tmp=val_int();
      ptr-=row_offset;
      return tmp;
    }
170
  bool send(THD *thd, String *packet);
unknown's avatar
unknown committed
171 172
  virtual char *pack(char* to, const char *from, uint max_length=~(uint) 0)
  {
unknown's avatar
unknown committed
173
    uint32 length=pack_length();
unknown's avatar
unknown committed
174 175 176 177 178 179 180 181 182
    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;
  }
183 184 185 186 187 188
  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
189 190 191
  {
    return pack(to,from,max_length);
  }
192 193
  virtual uint packed_col_length(const char *to, uint length)
  { return length;}
unknown's avatar
unknown committed
194
  virtual uint max_packed_col_length(uint max_length)
195
  { return max_length;}
unknown's avatar
unknown committed
196 197 198

  virtual int pack_cmp(const char *a,const char *b, uint key_length_arg)
  { return cmp(a,b); }
199 200
  virtual int pack_cmp(const char *b, uint key_length_arg)
  { return cmp(ptr,b); }
201
  uint offset();			// Should be inline ...
unknown's avatar
unknown committed
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225
  void copy_from_tmp(int offset);
  uint fill_cache_field(struct st_cache_field *copy);
  virtual bool get_date(TIME *ltime,bool fuzzydate);
  virtual bool get_time(TIME *ltime);
  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;
};


class Field_num :public Field {
public:
  const uint8 dec;
226
  bool zerofill,unsigned_flag;	// Purify cannot handle bit fields
unknown's avatar
unknown committed
227
  Field_num(char *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
228
	    uchar null_bit_arg, utype unireg_check_arg,
unknown's avatar
unknown committed
229 230
	    const char *field_name_arg,
	    struct st_table *table_arg,
unknown's avatar
unknown committed
231
	    uint8 dec_arg,bool zero_arg,bool unsigned_arg)
unknown's avatar
unknown committed
232 233 234 235 236 237 238 239 240 241 242 243 244 245
    :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
	   unireg_check_arg, field_name_arg, table_arg),
     dec(dec_arg),zerofill(zero_arg),unsigned_flag(unsigned_arg)
    {
      if (zerofill)
	flags|=ZEROFILL_FLAG;
      if (unsigned_flag)
	flags|=UNSIGNED_FLAG;
    }
  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
246
  uint decimals() const { return (uint) dec; }
unknown's avatar
unknown committed
247 248 249 250 251 252 253 254
  uint size_of() const { return sizeof(*this); }
  bool eq_def(Field *field);
};


class Field_str :public Field {
public:
  Field_str(char *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
255
	    uchar null_bit_arg, utype unireg_check_arg,
unknown's avatar
unknown committed
256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
	    const char *field_name_arg,
	    struct st_table *table_arg)
    :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
	   unireg_check_arg, field_name_arg, table_arg)
    {}
  Item_result result_type () const { return STRING_RESULT; }
  uint decimals() const { return NOT_FIXED_DEC; }
  friend class create_field;
  void make_field(Send_field *);
  uint size_of() const { return sizeof(*this); }
};


class Field_decimal :public Field_num {
public:
  Field_decimal(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
272
		uchar null_bit_arg,
unknown's avatar
unknown committed
273 274
		enum utype unireg_check_arg, const char *field_name_arg,
		struct st_table *table_arg,
unknown's avatar
unknown committed
275
		uint8 dec_arg,bool zero_arg,bool unsigned_arg)
unknown's avatar
unknown committed
276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
    :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)
    {}
  enum_field_types type() const { return FIELD_TYPE_DECIMAL;}
  enum ha_base_keytype key_type() const
    { return zerofill ? HA_KEYTYPE_BINARY : HA_KEYTYPE_NUM; }
  void reset(void);
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
  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;
};


class Field_tiny :public Field_num {
public:
  Field_tiny(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
301
	     uchar null_bit_arg,
unknown's avatar
unknown committed
302 303 304 305 306 307 308 309 310 311 312 313 314 315
	     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; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
316
  void reset(void) { ptr[0]=0; }
unknown's avatar
unknown committed
317 318 319 320 321 322 323 324 325 326 327 328 329
  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 1; }
  void sql_type(String &str) const;
};


class Field_short :public Field_num {
public:
  Field_short(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
330
	      uchar null_bit_arg,
unknown's avatar
unknown committed
331 332 333 334 335 336 337 338 339 340 341 342 343 344
	      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_SHORT;}
  enum ha_base_keytype key_type() const
    { return unsigned_flag ? HA_KEYTYPE_USHORT_INT : HA_KEYTYPE_SHORT_INT;}
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
345
  void reset(void) { ptr[0]=ptr[1]=0; }
unknown's avatar
unknown committed
346 347 348 349 350 351 352 353 354 355 356 357 358
  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 2; }
  void sql_type(String &str) const;
};


class Field_medium :public Field_num {
public:
  Field_medium(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
359
	      uchar null_bit_arg,
unknown's avatar
unknown committed
360 361 362 363 364 365 366 367 368 369 370 371 372 373
	      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; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
374
  void reset(void) { ptr[0]=ptr[1]=ptr[2]=0; }
unknown's avatar
unknown committed
375 376 377 378 379 380 381 382 383 384 385 386 387
  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 3; }
  void sql_type(String &str) const;
};


class Field_long :public Field_num {
public:
  Field_long(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
388
	     uchar null_bit_arg,
unknown's avatar
unknown committed
389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
	     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; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
408
  void reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=0; }
unknown's avatar
unknown committed
409 410 411 412 413 414 415 416 417 418 419 420 421 422
  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 4; }
  void sql_type(String &str) const;
};


#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
423
	      uchar null_bit_arg,
unknown's avatar
unknown committed
424 425 426 427 428 429 430
	      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)
    {}
431 432 433
  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
434
    :Field_num((char*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0,0,
435
	       NONE, field_name_arg, table_arg,0,0,unsigned_arg)
unknown's avatar
unknown committed
436 437 438 439 440 441 442 443
    {}
  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; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
444
  void reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=ptr[4]=ptr[5]=ptr[6]=ptr[7]=0; }
unknown's avatar
unknown committed
445 446 447 448 449 450 451
  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 8; }
  void sql_type(String &str) const;
452
  bool store_for_compare() { return 1; }
unknown's avatar
unknown committed
453 454 455 456 457 458
};
#endif

class Field_float :public Field_num {
public:
  Field_float(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
459
	      uchar null_bit_arg,
unknown's avatar
unknown committed
460 461
	      enum utype unireg_check_arg, const char *field_name_arg,
	      struct st_table *table_arg,
unknown's avatar
unknown committed
462
	      uint8 dec_arg,bool zero_arg,bool unsigned_arg)
unknown's avatar
unknown committed
463 464 465 466 467 468 469 470 471
    :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)
    {}
  enum_field_types type() const { return FIELD_TYPE_FLOAT;}
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_FLOAT; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
472
  void reset(void) { bzero(ptr,sizeof(float)); }
unknown's avatar
unknown committed
473 474 475 476 477 478 479 480 481 482 483 484 485
  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 sizeof(float); }
  void sql_type(String &str) const;
};


class Field_double :public Field_num {
public:
  Field_double(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
486
	       uchar null_bit_arg,
unknown's avatar
unknown committed
487 488
	       enum utype unireg_check_arg, const char *field_name_arg,
	       struct st_table *table_arg,
unknown's avatar
unknown committed
489
	       uint8 dec_arg,bool zero_arg,bool unsigned_arg)
unknown's avatar
unknown committed
490 491 492 493 494
    :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)
    {}
  Field_double(uint32 len_arg, bool maybe_null_arg, const char *field_name_arg,
unknown's avatar
unknown committed
495
	       struct st_table *table_arg, uint8 dec_arg)
unknown's avatar
unknown committed
496 497 498 499 500 501 502 503
    :Field_num((char*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0, (uint) 0,
	       NONE, field_name_arg, table_arg,dec_arg,0,0)
    {}
  enum_field_types type() const { return FIELD_TYPE_DOUBLE;}
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_DOUBLE; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
504
  void reset(void) { bzero(ptr,sizeof(double)); }
unknown's avatar
unknown committed
505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529
  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 sizeof(double); }
  void sql_type(String &str) const;
};


/* Everything saved in this will disapper. It will always return NULL */

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,
	     struct st_table *table_arg)
    :Field_str(ptr_arg, len_arg, null, 1,
	       unireg_check_arg, field_name_arg, table_arg)
    {}
  enum_field_types type() const { return FIELD_TYPE_NULL;}
  void store(const char *to, uint length) { null[0]=1; }
  void store(double nr)   { null[0]=1; }
  void store(longlong nr) { null[0]=1; }
530
  void reset(void)	  {}
unknown's avatar
unknown committed
531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547
  double val_real(void)		{ return 0.0;}
  longlong val_int(void)	{ return 0;}
  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; }
  void sql_type(String &str) const { str.set("null",4); }
  uint size_of() const { return sizeof(*this); }
};


class Field_timestamp :public Field_num {
public:
  Field_timestamp(char *ptr_arg, uint32 len_arg,
		  enum utype unireg_check_arg, const char *field_name_arg,
		  struct st_table *table_arg);
548
  enum Item_result result_type () const;
unknown's avatar
unknown committed
549 550 551 552 553
  enum_field_types type() const { return FIELD_TYPE_TIMESTAMP;}
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONG_INT; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
554
  void reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=0; }
unknown's avatar
unknown committed
555 556 557 558 559 560 561 562 563 564
  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 4; }
  void sql_type(String &str) const;
  bool store_for_compare() { return 1; }
  bool zero_pack() const { return 0; }
  void set_time();
unknown's avatar
unknown committed
565 566 567 568
  virtual void set_default()
  {
    set_time();
  }
unknown's avatar
unknown committed
569 570 571 572 573 574 575 576 577 578 579 580 581
  inline long get_timestamp()
  {
#ifdef WORDS_BIGENDIAN
    if (table->db_low_byte_first)
      return sint4korr(ptr);
#endif
    long tmp;
    longget(tmp,ptr);
    return tmp;
  }
  void fill_and_store(char *from,uint len);
  bool get_date(TIME *ltime,bool fuzzydate);
  bool get_time(TIME *ltime);
582
  void make_field(Send_field *field);
unknown's avatar
unknown committed
583 584 585 586 587 588
};


class Field_year :public Field_tiny {
public:
  Field_year(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
589
	     uchar null_bit_arg,
unknown's avatar
unknown committed
590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607
	     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;}
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*,String *);
  void sql_type(String &str) const;
};


class Field_date :public Field_str {
public:
unknown's avatar
unknown committed
608
  Field_date(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
609 610 611 612 613
	     enum utype unireg_check_arg, const char *field_name_arg,
	     struct st_table *table_arg)
    :Field_str(ptr_arg, 10, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg)
    {}
614 615 616 617
  Field_date(bool maybe_null_arg, const char *field_name_arg,
		 struct st_table *table_arg)
    :Field_str((char*) 0,10, maybe_null_arg ? (uchar*) "": 0,0,
	       NONE, field_name_arg, table_arg) {}
unknown's avatar
unknown committed
618 619 620 621 622 623
  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; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
624
  void reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=0; }
unknown's avatar
unknown committed
625 626 627 628 629 630 631 632 633 634 635 636 637
  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 4; }
  void sql_type(String &str) const;
  bool store_for_compare() { return 1; }
  bool zero_pack() const { return 1; }
};

class Field_newdate :public Field_str {
public:
unknown's avatar
unknown committed
638
  Field_newdate(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
639 640 641 642 643 644 645 646 647 648 649 650 651
		enum utype unireg_check_arg, const char *field_name_arg,
		struct st_table *table_arg)
    :Field_str(ptr_arg, 10, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg)
    {}
  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; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
  void store_time(TIME *ltime,timestamp_type type);
652
  void reset(void) { ptr[0]=ptr[1]=ptr[2]=0; }
unknown's avatar
unknown committed
653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668
  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 3; }
  void sql_type(String &str) const;
  bool store_for_compare() { return 1; }
  bool zero_pack() const { return 1; }
  bool get_date(TIME *ltime,bool fuzzydate);
  bool get_time(TIME *ltime);
};


class Field_time :public Field_str {
public:
unknown's avatar
unknown committed
669
  Field_time(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
670 671 672 673 674
	     enum utype unireg_check_arg, const char *field_name_arg,
	     struct st_table *table_arg)
    :Field_str(ptr_arg, 8, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg)
    {}
675 676 677 678
  Field_time(bool maybe_null_arg, const char *field_name_arg,
		 struct st_table *table_arg)
    :Field_str((char*) 0,8, maybe_null_arg ? (uchar*) "": 0,0,
	       NONE, field_name_arg, table_arg) {}
unknown's avatar
unknown committed
679 680 681 682 683 684
  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; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
685
  void reset(void) { ptr[0]=ptr[1]=ptr[2]=0; }
unknown's avatar
unknown committed
686 687 688 689 690 691 692 693 694 695 696 697 698 699 700
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*,String *);
  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;
  bool store_for_compare() { return 1; }
  bool zero_pack() const { return 1; }
};


class Field_datetime :public Field_str {
public:
unknown's avatar
unknown committed
701
  Field_datetime(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
702 703 704 705 706
		 enum utype unireg_check_arg, const char *field_name_arg,
		 struct st_table *table_arg)
    :Field_str(ptr_arg, 19, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg)
    {}
707 708 709 710
  Field_datetime(bool maybe_null_arg, const char *field_name_arg,
		 struct st_table *table_arg)
    :Field_str((char*) 0,19, maybe_null_arg ? (uchar*) "": 0,0,
	       NONE, field_name_arg, table_arg) {}
unknown's avatar
unknown committed
711 712 713 714 715 716 717 718 719
  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; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
  void store_time(TIME *ltime,timestamp_type type);
720
  void reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=ptr[4]=ptr[5]=ptr[6]=ptr[7]=0; }
unknown's avatar
unknown committed
721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738
  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 8; }
  void sql_type(String &str) const;
  bool store_for_compare() { return 1; }
  bool zero_pack() const { return 1; }
  bool get_date(TIME *ltime,bool fuzzydate);
  bool get_time(TIME *ltime);
};


class Field_string :public Field_str {
  bool binary_flag;
public:
  Field_string(char *ptr_arg, uint32 len_arg,uchar *null_ptr_arg,
unknown's avatar
unknown committed
739
	       uchar null_bit_arg,
unknown's avatar
unknown committed
740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781
	       enum utype unireg_check_arg, const char *field_name_arg,
	       struct st_table *table_arg,bool binary_arg)
    :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg),
    binary_flag(binary_arg)
    {
      if (binary_arg)
	flags|=BINARY_FLAG;
    }
  Field_string(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
	       struct st_table *table_arg, bool binary_arg)
    :Field_str((char*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0,0,
	       NONE, field_name_arg, table_arg),
    binary_flag(binary_arg)
    {
      if (binary_arg)
	flags|=BINARY_FLAG;
    }

  enum_field_types type() const
  {
    return ((table && table->db_create_options & HA_OPTION_PACK_RECORD &&
	     field_length >= 4) ?
	    FIELD_TYPE_VAR_STRING : FIELD_TYPE_STRING);
  }
  enum ha_base_keytype key_type() const
    { return binary_flag ? HA_KEYTYPE_BINARY : HA_KEYTYPE_TEXT; }
  bool zero_pack() const { return 0; }
  bool binary() const { return binary_flag; }
  void reset(void) { bfill(ptr,field_length,' '); }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
  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 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);
  int pack_cmp(const char *a,const char *b,uint key_length);
782
  int pack_cmp(const char *b,uint key_length);
783
  uint packed_col_length(const char *to, uint length);
unknown's avatar
unknown committed
784 785 786 787 788 789 790 791 792 793
  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; }
};


class Field_varstring :public Field_str {
  bool binary_flag;
public:
  Field_varstring(char *ptr_arg, uint32 len_arg,uchar *null_ptr_arg,
unknown's avatar
unknown committed
794
		  uchar null_bit_arg,
unknown's avatar
unknown committed
795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833
		  enum utype unireg_check_arg, const char *field_name_arg,
		  struct st_table *table_arg,bool binary_arg)
    :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg),
    binary_flag(binary_arg)
    {
      if (binary_arg)
	flags|=BINARY_FLAG;
    }
  Field_varstring(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
		  struct st_table *table_arg, bool binary_arg)
    :Field_str((char*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0,0,
	       NONE, field_name_arg, table_arg),
    binary_flag(binary_arg)
    {
      if (binary_arg)
	flags|=BINARY_FLAG;
    }

  enum_field_types type() const { return FIELD_TYPE_VAR_STRING; }
  enum ha_base_keytype key_type() const
    { return binary_flag ? HA_KEYTYPE_VARBINARY : HA_KEYTYPE_VARTEXT; }
  bool zero_pack() const { return 0; }
  bool binary() const { return binary_flag; }
  void reset(void) { bzero(ptr,field_length+2); }
  uint32 pack_length() const { return (uint32) field_length+2; }
  uint32 key_length() const { return (uint32) field_length; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
  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 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);
  int pack_cmp(const char *a, const char *b, uint key_length);
834
  int pack_cmp(const char *b, uint key_length);
835
  uint packed_col_length(const char *to, uint length);
unknown's avatar
unknown committed
836 837 838 839 840 841 842 843
  uint max_packed_col_length(uint max_length);
  uint size_of() const { return sizeof(*this); }
  enum_field_types real_type() const { return FIELD_TYPE_VAR_STRING; }
};


class Field_blob :public Field_str {
  uint packlength;
844
  String value;				// For temporaries
unknown's avatar
unknown committed
845 846
  bool binary_flag;
public:
unknown's avatar
unknown committed
847
  Field_blob(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870
	     enum utype unireg_check_arg, const char *field_name_arg,
	     struct st_table *table_arg,uint blob_pack_length,
	     bool binary_arg);
  Field_blob(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
	     struct st_table *table_arg, bool binary_arg)
    :Field_str((char*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0,0,
	       NONE, field_name_arg, table_arg),
    packlength(3),binary_flag(binary_arg)
    {
      flags|= BLOB_FLAG;
      if (binary_arg)
	flags|=BINARY_FLAG;
    }
  enum_field_types type() const { return FIELD_TYPE_BLOB;}
  enum ha_base_keytype key_type() const
    { return binary_flag ? HA_KEYTYPE_VARBINARY : HA_KEYTYPE_VARTEXT; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
  double val_real(void);
  longlong val_int(void);
  String *val_str(String*,String *);
  int cmp(const char *,const char*);
unknown's avatar
unknown committed
871
  int cmp(const char *a, uint32 a_length, const char *b, uint32 b_length);
unknown's avatar
unknown committed
872
  int cmp_offset(uint offset);
unknown's avatar
unknown committed
873
  int cmp_binary(const char *a,const char *b, uint32 max_length=~0L);
unknown's avatar
unknown committed
874 875 876 877 878
  int cmp_binary_offset(uint row_offset);
  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
879 880 881
  uint32 pack_length() const
  { return (uint32) (packlength+table->blob_ptr_size); }
  void reset(void) { bzero(ptr, packlength+sizeof(char*)); }
unknown's avatar
unknown committed
882
  void reset_fields() { bzero((char*) &value,sizeof(value)); }
unknown's avatar
unknown committed
883 884
  void store_length(uint32 number);
  inline uint32 get_length(uint row_offset=0)
unknown's avatar
unknown committed
885
  { return get_length(ptr+row_offset); }
unknown's avatar
unknown committed
886
  uint32 get_length(const char *ptr);
unknown's avatar
unknown committed
887 888 889 890 891 892 893 894 895 896
  bool binary() const { return binary_flag; }
  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
897
  inline void set_ptr(uint32 length,char *data)
unknown's avatar
unknown committed
898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915
    {
      store_length(length);
      memcpy_fixed(ptr+packlength,&data,sizeof(char*));
    }
  void get_key_image(char *buff,uint length);
  void set_key_image(char *buff,uint length);
  void sql_type(String &str) const;
  inline bool copy()
  { char *tmp;
    get_ptr(&tmp);
    if (value.copy(tmp,get_length()))
    {
      Field_blob::reset();
      return 1;
    }
    tmp=(char*) value.ptr(); memcpy_fixed(ptr+packlength,&tmp,sizeof(char*));
    return 0;
  }
916 917 918 919
  char *pack(char *to, const char *from, uint max_length= ~(uint) 0);
  const char *unpack(char *to, const char *from);
  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
unknown committed
920
  int pack_cmp(const char *a, const char *b, uint key_length);
921
  int pack_cmp(const char *b, uint key_length);
922 923
  uint packed_col_length(const char *col_ptr, uint length);
  uint max_packed_col_length(uint max_length);
unknown's avatar
unknown committed
924 925 926 927 928 929 930 931 932 933 934 935 936
  inline void free() { value.free(); }
  inline void clear_temporary() { bzero((char*) &value,sizeof(value)); }
  friend void field_conv(Field *to,Field *from);
  uint size_of() const { return sizeof(*this); }
};


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
937
		 uchar null_bit_arg,
unknown's avatar
unknown committed
938 939 940 941 942 943
		 enum utype unireg_check_arg, const char *field_name_arg,
		 struct st_table *table_arg,uint packlength_arg,
		 TYPELIB *typelib_arg)
    :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg),
    packlength(packlength_arg),typelib(typelib_arg)
unknown's avatar
unknown committed
944
  {
unknown's avatar
unknown committed
945
      flags|=ENUM_FLAG;
unknown's avatar
unknown committed
946
  }
unknown's avatar
unknown committed
947 948 949 950 951 952
  enum_field_types type() const { return FIELD_TYPE_STRING; }
  enum Item_result cmp_type () const { return INT_RESULT; }
  enum ha_base_keytype key_type() const;
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
953
  void reset() { bzero(ptr,packlength); }
unknown's avatar
unknown committed
954 955 956 957 958 959 960 961 962 963 964
  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; }
965
  bool optimize_range(uint idx) { return 0; }
unknown's avatar
unknown committed
966 967 968 969 970 971 972 973
  bool binary() const { return 0; }
  bool eq_def(Field *field);
};


class Field_set :public Field_enum {
public:
  Field_set(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
974
	    uchar null_bit_arg,
unknown's avatar
unknown committed
975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995
	    enum utype unireg_check_arg, const char *field_name_arg,
	    struct st_table *table_arg,uint32 packlength_arg,
	    TYPELIB *typelib_arg)
    :Field_enum(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
		    unireg_check_arg, field_name_arg,
		    table_arg, packlength_arg,
		    typelib_arg)
    {
      flags=(flags & ~ENUM_FLAG) | SET_FLAG;
    }
  void store(const char *to,uint length);
  void store(double nr) { Field_set::store((longlong) nr); }
  void store(longlong nr);
  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; }
};


/*
unknown's avatar
unknown committed
996
  Create field class for CREATE TABLE
unknown's avatar
unknown committed
997 998 999 1000 1001
*/

class create_field :public Sql_alloc {
public:
  const char *field_name;
1002 1003 1004
  const char *change;			// If done with alter table
  const char *after;			// Put column after this one
  Item	*def;				// Default value
unknown's avatar
unknown committed
1005 1006 1007 1008
  enum	enum_field_types sql_type;
  uint32 length;
  uint decimals,flags,pack_length;
  Field::utype unireg_check;
1009 1010
  TYPELIB *interval;			// Which interval to use
  Field *field;				// For alter table
unknown's avatar
unknown committed
1011

1012
  uint8 row,col,sc_length,interval_id;	// For rea_create_table
unknown's avatar
unknown committed
1013 1014
  uint	offset,pack_flag;
  create_field() :after(0) {}
1015
  create_field(Field *field, Field *orig_field);
unknown's avatar
unknown committed
1016 1017 1018 1019
};


/*
unknown's avatar
unknown committed
1020
  A class for sending info to the client
unknown's avatar
unknown committed
1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
*/

class Send_field {
 public:
  const char *table_name,*col_name;
  uint length,flags,decimals;
  enum_field_types type;
  Send_field() {}
};


/*
1033
  A class for quick copying data to fields
unknown's avatar
unknown committed
1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044
*/

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;
1045
  String tmp;					// For items
unknown's avatar
unknown committed
1046 1047 1048

  Copy_field() {}
  ~Copy_field() {}
1049 1050
  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
1051
  void (*do_copy)(Copy_field *);
1052
  void (*do_copy2)(Copy_field *);		// Used to handle null values
unknown's avatar
unknown committed
1053 1054 1055 1056
};


Field *make_field(char *ptr, uint32 field_length,
unknown's avatar
unknown committed
1057
		  uchar *null_pos, uchar null_bit,
1058 1059 1060
		  uint pack_flag,
		  enum_field_types field_type,
		  Field::utype unireg_check,
unknown's avatar
unknown committed
1061 1062 1063 1064 1065
		  TYPELIB *interval, const char *field_name,
		  struct st_table *table);
uint pack_length_to_packflag(uint type);
uint32 calc_pack_length(enum_field_types type,uint32 length);
bool set_field_to_null(Field *field);
1066
bool set_field_to_null_with_conversions(Field *field, bool no_conversions);
unknown's avatar
unknown committed
1067 1068 1069 1070 1071
uint find_enum(TYPELIB *typelib,const char *x, uint length);
ulonglong find_set(TYPELIB *typelib,const char *x, uint length);
bool test_if_int(const char *str,int length);

/*
1072
  The following are for the interface with the .frm file
unknown's avatar
unknown committed
1073 1074 1075
*/

#define FIELDFLAG_DECIMAL		1
1076
#define FIELDFLAG_BINARY		1	// Shares same flag 
unknown's avatar
unknown committed
1077 1078
#define FIELDFLAG_NUMBER		2
#define FIELDFLAG_ZEROFILL		4
1079
#define FIELDFLAG_PACK			120	// Bits used for packing
unknown's avatar
unknown committed
1080
#define FIELDFLAG_INTERVAL		256
1081 1082
#define FIELDFLAG_BITFIELD		512	// mangled with dec!
#define FIELDFLAG_BLOB			1024	// mangled with dec!
1083
#define FIELDFLAG_GEOM			2048
unknown's avatar
unknown committed
1084 1085
#define FIELDFLAG_LEFT_FULLSCREEN	8192
#define FIELDFLAG_RIGHT_FULLSCREEN	16384
1086 1087 1088
#define FIELDFLAG_FORMAT_NUMBER		16384	// predit: ###,,## in output
#define FIELDFLAG_SUM			((uint) 32768)// predit: +#fieldflag
#define FIELDFLAG_MAYBE_NULL		((uint) 32768)// sql
unknown's avatar
unknown committed
1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103
#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 FIELD_SORT_REVERSE		16384

#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
1104
#define f_decimals(x)		((uint8) (((x) >> FIELDFLAG_DEC_SHIFT) & FIELDFLAG_MAX_DEC))
unknown's avatar
unknown committed
1105 1106 1107 1108 1109
#define f_is_alpha(x)		(!f_is_num(x))
#define f_is_binary(x)		((x) & FIELDFLAG_BINARY)
#define f_is_enum(x)	((x) & FIELDFLAG_INTERVAL)
#define f_is_bitfield(x)	((x) & FIELDFLAG_BITFIELD)
#define f_is_blob(x)		(((x) & (FIELDFLAG_BLOB | FIELDFLAG_NUMBER)) == FIELDFLAG_BLOB)
1110
#define f_is_geom(x)		((x) & FIELDFLAG_GEOM)
unknown's avatar
unknown committed
1111 1112 1113
#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)