field.h 41.3 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 */

unknown's avatar
unknown committed
40
  char		*ptr;			// Position to field in record
unknown's avatar
unknown committed
41 42
  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
  LEX_STRING	comment;
unknown's avatar
unknown committed
45 46 47 48 49 50
  ulong		query_id;		// For quick test of used fields
  // Field is part of the following keys
  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};
unknown's avatar
unknown committed
51 52 53

  enum imagetype { itRAW, itMBR};
  
unknown's avatar
unknown committed
54 55 56 57 58 59
  utype		unireg_check;
  uint32	field_length;		// Length of field
  uint16	flags;
  uchar		null_bit;		// Bit used to test null bit

  Field(char *ptr_arg,uint32 length_arg,uchar *null_ptr_arg,uchar null_bit_arg,
unknown's avatar
unknown committed
60 61 62
	utype unireg_check_arg, const char *field_name_arg,
	struct st_table *table_arg);
  virtual ~Field() {}
63
  virtual void store(const char *to,uint length,CHARSET_INFO *cs)=0;
unknown's avatar
unknown committed
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
  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(); }
  bool eq(Field *field) { return ptr == field->ptr; }
  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() {}
  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
85
  virtual int cmp_binary(const char *a,const char *b, uint32 max_length=~0L)
unknown's avatar
unknown committed
86 87 88 89 90 91 92 93 94 95 96 97 98 99
  { 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; }
  virtual void sql_type(String &str) const =0;
  // 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
unknown's avatar
unknown committed
100

unknown's avatar
unknown committed
101 102 103 104 105 106 107 108
  virtual uint size_of() const =0;			// For new field
  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
109
    { if (null_ptr) null_ptr[row_offset]&= (uchar) ~null_bit; }
unknown's avatar
unknown committed
110 111 112 113
  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;
114
  virtual bool optimize_range(uint idx);
unknown's avatar
unknown committed
115
  virtual bool store_for_compare() { return 0; }
unknown's avatar
unknown committed
116 117 118 119
  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
120
    {
unknown's avatar
unknown committed
121 122 123 124 125
      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
126
    }
unknown's avatar
unknown committed
127 128 129 130 131 132
    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
133 134 135 136 137 138 139 140 141 142 143
  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); }
unknown's avatar
unknown committed
144
  virtual void get_key_image(char *buff,uint length, imagetype type)
unknown's avatar
unknown committed
145 146 147 148
    { 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)
149
    { return memcmp(ptr,buff,length); }
unknown's avatar
unknown committed
150 151 152 153 154 155 156
  inline longlong val_int_offset(uint row_offset)
    {
      ptr+=row_offset;
      longlong tmp=val_int();
      ptr-=row_offset;
      return tmp;
    }
157
  bool send(THD *thd, String *packet);
unknown's avatar
unknown committed
158 159
  virtual char *pack(char* to, const char *from, uint max_length=~(uint) 0)
  {
unknown's avatar
unknown committed
160
    uint32 length=pack_length();
unknown's avatar
unknown committed
161 162 163 164 165 166 167 168 169
    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;
  }
170 171 172 173 174 175
  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
176 177 178
  {
    return pack(to,from,max_length);
  }
179 180
  virtual uint packed_col_length(const char *to, uint length)
  { return length;}
unknown's avatar
unknown committed
181
  virtual uint max_packed_col_length(uint max_length)
182
  { return max_length;}
unknown's avatar
unknown committed
183 184 185

  virtual int pack_cmp(const char *a,const char *b, uint key_length_arg)
  { return cmp(a,b); }
186 187
  virtual int pack_cmp(const char *b, uint key_length_arg)
  { return cmp(ptr,b); }
unknown's avatar
unknown committed
188 189 190 191 192
  uint offset();				// Should be inline ...
  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);
unknown's avatar
unknown committed
193
  virtual CHARSET_INFO *charset(void) { return 0; }
unknown's avatar
unknown committed
194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
  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;
  bool zerofill,unsigned_flag;		// Purify cannot handle bit fields
  Field_num(char *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
216
	    uchar null_bit_arg, utype unireg_check_arg,
unknown's avatar
unknown committed
217 218
	    const char *field_name_arg,
	    struct st_table *table_arg,
unknown's avatar
unknown committed
219
	    uint8 dec_arg,bool zero_arg,bool unsigned_arg)
unknown's avatar
unknown committed
220 221 222 223 224 225 226 227 228 229 230 231 232 233
    :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
234
  uint decimals() const { return (uint) dec; }
unknown's avatar
unknown committed
235 236 237 238 239 240
  uint size_of() const { return sizeof(*this); }
  bool eq_def(Field *field);
};


class Field_str :public Field {
241 242
protected:
  CHARSET_INFO *field_charset;
unknown's avatar
unknown committed
243 244
public:
  Field_str(char *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
245
	    uchar null_bit_arg, utype unireg_check_arg,
unknown's avatar
unknown committed
246
	    const char *field_name_arg,
247
	    struct st_table *table_arg,CHARSET_INFO *charset)
unknown's avatar
unknown committed
248 249
    :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
	   unireg_check_arg, field_name_arg, table_arg)
250
    { field_charset=charset; }
unknown's avatar
unknown committed
251 252 253 254
  Item_result result_type () const { return STRING_RESULT; }
  uint decimals() const { return NOT_FIXED_DEC; }
  void make_field(Send_field *);
  uint size_of() const { return sizeof(*this); }
unknown's avatar
unknown committed
255 256
  CHARSET_INFO *charset(void) { return field_charset; }

257
  inline void set_charset(CHARSET_INFO *charset) { field_charset=charset; }
258 259 260 261 262 263 264
  inline int cmp_image(char *buff,uint length)
    {
      if (binary())
	return memcmp(ptr,buff,length);
      else
	return my_strncasecmp(field_charset,ptr,buff,length);
  }
unknown's avatar
unknown committed
265
  friend class create_field;
unknown's avatar
unknown committed
266 267 268 269 270 271
};


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
    :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);
284
  void store(const char *to,uint length,CHARSET_INFO *charset);
unknown's avatar
unknown committed
285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
  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
	     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; }
313
  void store(const char *to,uint length,CHARSET_INFO *charset);
unknown's avatar
unknown committed
314 315
  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
	      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;}
342
  void store(const char *to,uint length,CHARSET_INFO *charset);
unknown's avatar
unknown committed
343 344
  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
	      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; }
371
  void store(const char *to,uint length,CHARSET_INFO *charset);
unknown's avatar
unknown committed
372 373
  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
	     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; }
405
  void store(const char *to,uint length,CHARSET_INFO *charset);
unknown's avatar
unknown committed
406 407
  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
    {}
  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; }
441
  void store(const char *to,uint length,CHARSET_INFO *charset);
unknown's avatar
unknown committed
442 443
  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 452 453 454 455 456 457
  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;
};
#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
458
	      uchar null_bit_arg,
unknown's avatar
unknown committed
459 460
	      enum utype unireg_check_arg, const char *field_name_arg,
	      struct st_table *table_arg,
unknown's avatar
unknown committed
461
	      uint8 dec_arg,bool zero_arg,bool unsigned_arg)
unknown's avatar
unknown committed
462 463 464 465 466 467
    :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; }
468
  void store(const char *to,uint length,CHARSET_INFO *charset);
unknown's avatar
unknown committed
469 470
  void store(double nr);
  void store(longlong nr);
471
  void reset(void) { bzero(ptr,sizeof(float)); }
unknown's avatar
unknown committed
472 473 474 475 476 477 478 479 480 481 482 483 484
  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
485
	       uchar null_bit_arg,
unknown's avatar
unknown committed
486 487
	       enum utype unireg_check_arg, const char *field_name_arg,
	       struct st_table *table_arg,
unknown's avatar
unknown committed
488
	       uint8 dec_arg,bool zero_arg,bool unsigned_arg)
unknown's avatar
unknown committed
489 490 491 492 493
    :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
494
	       struct st_table *table_arg, uint8 dec_arg)
unknown's avatar
unknown committed
495 496 497 498 499
    :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; }
500
  void store(const char *to,uint length,CHARSET_INFO *charset);
unknown's avatar
unknown committed
501 502
  void store(double nr);
  void store(longlong nr);
503
  void reset(void) { bzero(ptr,sizeof(double)); }
unknown's avatar
unknown committed
504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
  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,
523
	       unireg_check_arg, field_name_arg, table_arg, default_charset_info)
unknown's avatar
unknown committed
524 525
    {}
  enum_field_types type() const { return FIELD_TYPE_NULL;}
526
  void store(const char *to, uint length, CHARSET_INFO *cs) { null[0]=1; }
unknown's avatar
unknown committed
527 528
  void store(double nr)   { null[0]=1; }
  void store(longlong nr) { null[0]=1; }
529
  void reset(void)	  {}
unknown's avatar
unknown committed
530 531 532 533 534 535 536
  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; }
537
  void sql_type(String &str) const { str.set("null",4,default_charset_info); }
unknown's avatar
unknown committed
538 539 540 541 542 543 544 545 546
  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);
547
  enum Item_result result_type () const { return field_length == 8 || field_length == 14 ? INT_RESULT : STRING_RESULT; }
unknown's avatar
unknown committed
548 549
  enum_field_types type() const { return FIELD_TYPE_TIMESTAMP;}
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONG_INT; }
550
  void store(const char *to,uint length,CHARSET_INFO *charset);
unknown's avatar
unknown committed
551 552
  void store(double nr);
  void store(longlong nr);
553
  void reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=0; }
unknown's avatar
unknown committed
554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582
  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();
  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);
};


class Field_year :public Field_tiny {
public:
  Field_year(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
unknown's avatar
unknown committed
583
	     uchar null_bit_arg,
unknown's avatar
unknown committed
584 585 586 587 588 589
	     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;}
590
  void store(const char *to,uint length,CHARSET_INFO *charset);
unknown's avatar
unknown committed
591 592 593 594 595 596 597 598 599 600 601
  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
602
  Field_date(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
603 604 605
	     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,
606
	       unireg_check_arg, field_name_arg, table_arg, default_charset_info)
unknown's avatar
unknown committed
607
    {}
608 609 610
  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,
611
	       NONE, field_name_arg, table_arg, default_charset_info) {}
unknown's avatar
unknown committed
612 613 614
  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; }
615
  void store(const char *to,uint length,CHARSET_INFO *charset);
unknown's avatar
unknown committed
616 617
  void store(double nr);
  void store(longlong nr);
618
  void reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=0; }
unknown's avatar
unknown committed
619 620 621 622 623 624 625 626 627 628 629 630 631
  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
632
  Field_newdate(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
633 634 635
		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,
636
	       unireg_check_arg, field_name_arg, table_arg, default_charset_info)
unknown's avatar
unknown committed
637 638 639 640 641
    {}
  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; }
642
  void store(const char *to,uint length,CHARSET_INFO *charset);
unknown's avatar
unknown committed
643 644 645
  void store(double nr);
  void store(longlong nr);
  void store_time(TIME *ltime,timestamp_type type);
646
  void reset(void) { ptr[0]=ptr[1]=ptr[2]=0; }
unknown's avatar
unknown committed
647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
  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
663
  Field_time(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
664 665 666
	     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,
667
	       unireg_check_arg, field_name_arg, table_arg, default_charset_info)
unknown's avatar
unknown committed
668
    {}
669 670 671
  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,
672
	       NONE, field_name_arg, table_arg, default_charset_info) {}
unknown's avatar
unknown committed
673 674 675
  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; }
676
  void store(const char *to,uint length,CHARSET_INFO *charset);
unknown's avatar
unknown committed
677 678
  void store(double nr);
  void store(longlong nr);
679
  void reset(void) { ptr[0]=ptr[1]=ptr[2]=0; }
unknown's avatar
unknown committed
680 681 682 683 684 685 686 687 688 689 690 691 692 693 694
  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
695
  Field_datetime(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
696 697 698
		 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,
699
	       unireg_check_arg, field_name_arg, table_arg, default_charset_info)
unknown's avatar
unknown committed
700
    {}
701 702 703
  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,
704
	       NONE, field_name_arg, table_arg, default_charset_info) {}
unknown's avatar
unknown committed
705 706 707 708 709
  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; }
710
  void store(const char *to,uint length,CHARSET_INFO *charset);
unknown's avatar
unknown committed
711 712 713
  void store(double nr);
  void store(longlong nr);
  void store_time(TIME *ltime,timestamp_type type);
714
  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
715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732
  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
733
	       uchar null_bit_arg,
unknown's avatar
unknown committed
734
	       enum utype unireg_check_arg, const char *field_name_arg,
735
	       struct st_table *table_arg,bool binary_arg, CHARSET_INFO *cs)
unknown's avatar
unknown committed
736
    :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
737
	       unireg_check_arg, field_name_arg, table_arg,cs),
unknown's avatar
unknown committed
738 739 740 741 742 743
    binary_flag(binary_arg)
    {
      if (binary_arg)
	flags|=BINARY_FLAG;
    }
  Field_string(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
744
	       struct st_table *table_arg, bool binary_arg, CHARSET_INFO *cs)
unknown's avatar
unknown committed
745
    :Field_str((char*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0,0,
746
	       NONE, field_name_arg, table_arg, cs),
unknown's avatar
unknown committed
747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763
    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,' '); }
764
  void store(const char *to,uint length,CHARSET_INFO *charset);
unknown's avatar
unknown committed
765 766 767 768 769 770 771 772 773 774 775
  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);
776
  int pack_cmp(const char *b,uint key_length);
777
  uint packed_col_length(const char *to, uint length);
unknown's avatar
unknown committed
778 779 780 781 782 783 784 785 786 787
  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
788
		  uchar null_bit_arg,
unknown's avatar
unknown committed
789
		  enum utype unireg_check_arg, const char *field_name_arg,
790
		  struct st_table *table_arg,bool binary_arg, CHARSET_INFO *cs)
unknown's avatar
unknown committed
791
    :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
792
	       unireg_check_arg, field_name_arg, table_arg, cs),
unknown's avatar
unknown committed
793 794 795 796 797 798
    binary_flag(binary_arg)
    {
      if (binary_arg)
	flags|=BINARY_FLAG;
    }
  Field_varstring(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
799
		  struct st_table *table_arg, bool binary_arg, CHARSET_INFO *cs)
unknown's avatar
unknown committed
800
    :Field_str((char*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0,0,
801
	       NONE, field_name_arg, table_arg, cs),
unknown's avatar
unknown committed
802 803 804 805 806 807 808 809 810 811 812 813 814 815
    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; }
816
  void store(const char *to,uint length,CHARSET_INFO *charset);
unknown's avatar
unknown committed
817 818 819 820 821 822 823 824 825 826 827
  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);
828
  int pack_cmp(const char *b, uint key_length);
829
  uint packed_col_length(const char *to, uint length);
unknown's avatar
unknown committed
830 831 832 833 834 835 836 837 838 839
  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;
  String value;					// For temporaries
  bool binary_flag;
unknown's avatar
unknown committed
840
  bool geom_flag;
unknown's avatar
unknown committed
841
public:
unknown's avatar
unknown committed
842
  Field_blob(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
843 844
	     enum utype unireg_check_arg, const char *field_name_arg,
	     struct st_table *table_arg,uint blob_pack_length,
845
	     bool binary_arg, CHARSET_INFO *cs);
unknown's avatar
unknown committed
846
  Field_blob(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
847
	     struct st_table *table_arg, bool binary_arg, CHARSET_INFO *cs)
unknown's avatar
unknown committed
848
    :Field_str((char*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0,0,
849
	       NONE, field_name_arg, table_arg, cs),
unknown's avatar
unknown committed
850
    packlength(3),binary_flag(binary_arg), geom_flag(true)
unknown's avatar
unknown committed
851 852 853 854 855 856 857 858
    {
      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; }
859
  void store(const char *to,uint length,CHARSET_INFO *charset);
unknown's avatar
unknown committed
860 861 862 863 864 865
  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
866
  int cmp(const char *a, uint32 a_length, const char *b, uint32 b_length);
unknown's avatar
unknown committed
867
  int cmp_offset(uint offset);
unknown's avatar
unknown committed
868
  int cmp_binary(const char *a,const char *b, uint32 max_length=~0L);
unknown's avatar
unknown committed
869 870 871 872 873
  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
874 875 876
  uint32 pack_length() const
  { return (uint32) (packlength+table->blob_ptr_size); }
  void reset(void) { bzero(ptr, packlength+sizeof(char*)); }
unknown's avatar
unknown committed
877
  void reset_fields() { bzero((char*) &value,sizeof(value)); }
unknown's avatar
unknown committed
878 879
  void store_length(uint32 number);
  inline uint32 get_length(uint row_offset=0)
unknown's avatar
unknown committed
880
  { return get_length(ptr+row_offset); }
unknown's avatar
unknown committed
881
  uint32 get_length(const char *ptr);
unknown's avatar
unknown committed
882 883 884 885 886 887 888 889 890 891
  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
892
  inline void set_ptr(uint32 length,char *data)
unknown's avatar
unknown committed
893 894 895 896
    {
      store_length(length);
      memcpy_fixed(ptr+packlength,&data,sizeof(char*));
    }
unknown's avatar
unknown committed
897
  void get_key_image(char *buff,uint length, imagetype type);
unknown's avatar
unknown committed
898 899 900 901 902 903 904 905 906 907 908 909 910
  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;
  }
911 912 913 914
  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
915
  int pack_cmp(const char *a, const char *b, uint key_length);
916
  int pack_cmp(const char *b, uint key_length);
917 918
  uint packed_col_length(const char *col_ptr, uint length);
  uint max_packed_col_length(uint max_length);
unknown's avatar
unknown committed
919 920 921 922 923 924 925
  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); }
};


unknown's avatar
unknown committed
926 927 928 929 930 931 932
class Field_geom :public Field_blob {
public:
  Field_geom(char *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg,
	     enum utype unireg_check_arg, const char *field_name_arg,
	     struct st_table *table_arg,uint blob_pack_length,
             bool binary_arg)
     :Field_blob(ptr_arg, null_ptr_arg, null_bit_arg, unireg_check_arg, 
933 934
                 field_name_arg, table_arg, blob_pack_length,binary_arg,
                 default_charset_info) {}
unknown's avatar
unknown committed
935 936 937
  Field_geom(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
	     struct st_table *table_arg, bool binary_arg)
     :Field_blob(len_arg, maybe_null_arg, field_name_arg,
938
                 table_arg, binary_arg, default_charset_info) {}
unknown's avatar
unknown committed
939 940 941 942 943 944 945
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_VARBINARY; }

  void get_key_image(char *buff,uint length, imagetype type);
  void set_key_image(char *buff,uint length);
};


unknown's avatar
unknown committed
946 947 948 949 950 951
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
952
		 uchar null_bit_arg,
unknown's avatar
unknown committed
953 954 955 956
		 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,
957
	       unireg_check_arg, field_name_arg, table_arg, default_charset_info),
unknown's avatar
unknown committed
958 959 960 961 962 963 964
    packlength(packlength_arg),typelib(typelib_arg)
    {
      flags|=ENUM_FLAG;
    }
  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;
965
  void store(const char *to,uint length,CHARSET_INFO *charset);
unknown's avatar
unknown committed
966 967
  void store(double nr);
  void store(longlong nr);
968
  void reset() { bzero(ptr,packlength); }
unknown's avatar
unknown committed
969 970 971 972 973 974 975 976 977 978 979
  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; }
980
  bool optimize_range(uint idx) { return 0; }
unknown's avatar
unknown committed
981 982 983 984 985 986 987 988
  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
989
	    uchar null_bit_arg,
unknown's avatar
unknown committed
990 991 992 993 994 995 996 997 998 999
	    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;
    }
1000
  void store(const char *to,uint length,CHARSET_INFO *charset);
unknown's avatar
unknown committed
1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018
  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; }
};


/*
** Create field class for CREATE TABLE
*/

class create_field :public Sql_alloc {
public:
  const char *field_name;
  const char *change;				// If done with alter table
  const char *after;				// Put column after this one
1019
  LEX_STRING comment;				// Comment for field
unknown's avatar
unknown committed
1020 1021 1022 1023 1024 1025 1026
  Item	*def;					// Default value
  enum	enum_field_types sql_type;
  uint32 length;
  uint decimals,flags,pack_length;
  Field::utype unireg_check;
  TYPELIB *interval;				// Which interval to use
  Field *field;					// For alter table
1027
  CHARSET_INFO *charset;
unknown's avatar
unknown committed
1028 1029 1030 1031

  uint8 row,col,sc_length,interval_id;		// For rea_create_table
  uint	offset,pack_flag;
  create_field() :after(0) {}
1032
  create_field(Field *field, Field *orig_field);
unknown's avatar
unknown committed
1033 1034 1035 1036 1037 1038 1039 1040 1041
};


/*
** A class for sending info to the client
*/

class Send_field {
 public:
unknown's avatar
unknown committed
1042 1043 1044
  const char *db_name;
  const char *table_name,*org_table_name;
  const char *col_name,*org_col_name;
unknown's avatar
unknown committed
1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
  uint length,flags,decimals;
  enum_field_types type;
  Send_field() {}
};


/*
** A class for quick copying data to fields
*/

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;
  String tmp;					// For items

  Copy_field() {}
  ~Copy_field() {}
  void set(Field *to,Field *from,bool save);	// Field to field
  void set(char *to,Field *from);		// Field to string
  void (*do_copy)(Copy_field *);
  void (*do_copy2)(Copy_field *);		// Used to handle null values
};


Field *make_field(char *ptr, uint32 field_length,
unknown's avatar
unknown committed
1076
		  uchar *null_pos, uchar null_bit,
1077 1078
		  uint pack_flag, enum_field_types field_type,
		  Field::utype unireg_check,
unknown's avatar
unknown committed
1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099
		  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);
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);

/*
** The following are for the interface with the .frm file
*/

#define FIELDFLAG_DECIMAL		1
#define FIELDFLAG_BINARY		1	// Shares same flag
#define FIELDFLAG_NUMBER		2
#define FIELDFLAG_ZEROFILL		4
#define FIELDFLAG_PACK			120	// Bits used for packing
#define FIELDFLAG_INTERVAL		256
#define FIELDFLAG_BITFIELD		512	// mangled with dec!
#define FIELDFLAG_BLOB			1024	// mangled with dec!
unknown's avatar
unknown committed
1100 1101
#define FIELDFLAG_GEOM			2048

unknown's avatar
unknown committed
1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
#define FIELDFLAG_LEFT_FULLSCREEN	8192
#define FIELDFLAG_RIGHT_FULLSCREEN	16384
#define FIELDFLAG_FORMAT_NUMBER		16384	// predit: ###,,## in output
#define FIELDFLAG_SUM			((uint) 32768)// predit: +#fieldflag
#define FIELDFLAG_MAYBE_NULL		((uint) 32768)// sql
#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
1122
#define f_decimals(x)		((uint8) (((x) >> FIELDFLAG_DEC_SHIFT) & FIELDFLAG_MAX_DEC))
unknown's avatar
unknown committed
1123 1124 1125 1126 1127
#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)
unknown's avatar
unknown committed
1128
#define f_is_geom(x)		((x) & FIELDFLAG_GEOM)
unknown's avatar
unknown committed
1129 1130 1131
#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)