← Back to branch summary

~mysql/mysql-server/mysql-6.0

« back to all changes in this revision

Viewing changes to sql/field.h

  • Committer: bk at mysql
  • Date: 2000-07-31 19:29:14 UTC
  • Revision ID: sp1r-bk@work.mysql.com-20000731192914-08846
Import changeset

Show diffs side-by-side

added added

removed removed

Lines of Context:
sql/field.h
 
1
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
 
2
   
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; either version 2 of the License, or
 
6
   (at your option) any later version.
 
7
   
 
8
   This program is distributed in the hope that it will be useful,
 
9
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
   GNU General Public License for more details.
 
12
   
 
13
   You should have received a copy of the GNU General Public License
 
14
   along with this program; if not, write to the Free Software
 
15
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
16
 
 
17
 
 
18
/*
 
19
** Because of the function new_field all field classes that have static
 
20
** variables must declare the size_of() member function.
 
21
*/
 
22
 
 
23
#ifdef __GNUC__
 
24
#pragma interface                       /* gcc class implementation */
 
25
#endif
 
26
 
 
27
#define NOT_FIXED_DEC                   31
 
28
 
 
29
class Send_field;
 
30
struct st_cache_field;
 
31
 
 
32
class Field {
 
33
  Field(const Item &);                          /* Prevent use of theese */
 
34
  void operator=(Field &);
 
35
public:
 
36
  static void *operator new(size_t size) {return (void*) sql_alloc(size); }
 
37
  static void operator delete(void *ptr_arg, size_t size) {} /*lint -e715 */
 
38
 
 
39
  enum utype { NONE,DATE,SHIELD,NOEMPTY,CASEUP,PNR,BGNR,PGNR,YES,NO,REL,
 
40
               CHECK,EMPTY,UNKNOWN,CASEDN,NEXT_NUMBER,INTERVAL_FIELD,BIT_FIELD,
 
41
               TIMESTAMP_FIELD,CAPITALIZE,BLOB_FIELD};
 
42
  char  *ptr;                           // Position to field in record
 
43
  uchar         *null_ptr;              // Byte where null_bit is
 
44
  uint8         null_bit;               // And position to it
 
45
  struct st_table *table;               // Pointer for table
 
46
  ulong query_id;                       // For quick test of used fields
 
47
  key_map key_start,part_of_key;        // Which keys a field is in
 
48
  const char *table_name,*field_name;
 
49
  utype unireg_check;
 
50
  uint32 field_length;                  // Length of field
 
51
  uint16 flags;
 
52
 
 
53
  Field(char *ptr_arg,uint32 length_arg,uchar *null_ptr_arg,uint null_bit_arg,
 
54
        utype unireg_check_arg, const char *field_name_arg,
 
55
        struct st_table *table_arg);
 
56
  virtual ~Field() {}
 
57
  virtual void store(const char *to,uint length)=0;
 
58
  virtual void store(double nr)=0;
 
59
  virtual void store(longlong nr)=0;
 
60
  virtual void store_time(TIME *ltime,timestamp_type t_type);
 
61
  virtual double val_real(void)=0;
 
62
  virtual longlong val_int(void)=0;
 
63
  virtual String *val_str(String*,String *)=0;
 
64
  virtual Item_result result_type () const=0;
 
65
  virtual Item_result cmp_type () const { return result_type(); }
 
66
  bool eq(Field *field) { return ptr == field->ptr; }
 
67
  virtual bool eq_def(Field *field);
 
68
  virtual uint32 pack_length() const { return (uint32) field_length; }
 
69
  virtual void reset(void) { bzero(ptr,pack_length()); }
 
70
  virtual void reset_fields() {}
 
71
  virtual bool binary() const { return 1; }
 
72
  virtual bool zero_pack() const { return 1; }
 
73
  virtual enum ha_base_keytype key_type() const { return HA_KEYTYPE_BINARY; }
 
74
  virtual uint32 key_length() const { return pack_length(); }
 
75
  virtual enum_field_types type() const =0;
 
76
  virtual enum_field_types real_type() const { return type(); }
 
77
  inline  int cmp(const char *str) { return cmp(ptr,str); }
 
78
  virtual int cmp(const char *,const char *)=0;
 
79
  virtual int cmp_binary(const char *a,const char *b, ulong max_length=~0L)
 
80
  { return memcmp(a,b,pack_length()); }
 
81
  virtual int cmp_offset(uint row_offset)
 
82
  { return memcmp(ptr,ptr+row_offset,pack_length()); }
 
83
  virtual int cmp_binary_offset(uint row_offset)
 
84
  { return memcmp(ptr,ptr+row_offset,pack_length()); }
 
85
  virtual int key_cmp(const byte *a,const byte *b)
 
86
  { return cmp((char*) a,(char*) b); }
 
87
  virtual int key_cmp(const byte *str, uint length)
 
88
  { return cmp(ptr,(char*) str); }
 
89
  virtual uint decimals() const { return 0; }
 
90
  virtual void sql_type(String &str) const =0;
 
91
  // Caller beware: sql_type can change str.Ptr, so check
 
92
  // ptr() to see if it changed if you are using your own buffer
 
93
  // in str and restore it with set() if needed
 
94
  
 
95
  virtual uint size_of() const =0;                      // For new field
 
96
  inline bool is_null(uint row_offset=0)
 
97
  { return null_ptr ? (null_ptr[row_offset] & null_bit ? 1 : 0) : table->null_row; }
 
98
  inline bool is_real_null(uint row_offset=0)
 
99
    { return null_ptr ? (null_ptr[row_offset] & null_bit ? 1 : 0) : 0; }
 
100
  inline void set_null(int row_offset=0)
 
101
    { if (null_ptr) null_ptr[row_offset]|= null_bit; }
 
102
  inline void set_notnull(int row_offset=0)
 
103
    { if (null_ptr) null_ptr[row_offset]&= ~null_bit; }
 
104
  inline bool maybe_null(void) { return null_ptr != 0 || table->maybe_null; }
 
105
  inline bool real_maybe_null(void) { return null_ptr != 0; }
 
106
  virtual void make_field(Send_field *)=0;
 
107
  virtual void sort_string(char *buff,uint length)=0;
 
108
  virtual bool optimize_range();
 
109
  virtual bool store_for_compare() { return 0; }
 
110
  inline Field *new_field(struct st_table *new_table)
 
111
    {
 
112
      Field *tmp= (Field*) sql_memdup((char*) this,size_of());
 
113
      if (tmp)
 
114
      {
 
115
        tmp->table=new_table;
 
116
        tmp->key_start=tmp->part_of_key=0;
 
117
        tmp->unireg_check=Field::NONE;
 
118
        tmp->flags&= (NOT_NULL_FLAG | BLOB_FLAG | UNSIGNED_FLAG | ZEROFILL_FLAG | BINARY_FLAG | ENUM_FLAG | SET_FLAG);
 
119
        tmp->reset_fields();
 
120
      }
 
121
      return tmp;
 
122
    }
 
123
  inline void move_field(char *ptr_arg,uchar *null_ptr_arg,uint null_bit_arg)
 
124
    {
 
125
      ptr=ptr_arg; null_ptr=null_ptr_arg; null_bit=null_bit_arg;
 
126
    }
 
127
  inline void move_field(char *ptr_arg) { ptr=ptr_arg; }
 
128
  inline void move_field(my_ptrdiff_t ptr_diff)
 
129
  {
 
130
    ptr=ADD_TO_PTR(ptr,ptr_diff,char*);
 
131
    if (null_ptr)
 
132
      null_ptr=ADD_TO_PTR(null_ptr,ptr_diff,uchar*);
 
133
  }
 
134
  inline void get_image(char *buff,uint length)
 
135
    { memcpy(buff,ptr,length); }
 
136
  inline void set_image(char *buff,uint length)
 
137
    { memcpy(ptr,buff,length); }
 
138
  virtual void get_key_image(char *buff,uint length)
 
139
    { get_image(buff,length); }
 
140
  virtual void set_key_image(char *buff,uint length)
 
141
    { set_image(buff,length); }
 
142
  inline int cmp_image(char *buff,uint length)
 
143
    {
 
144
      if (binary())
 
145
        return memcmp(ptr,buff,length);
 
146
      else
 
147
        return my_casecmp(ptr,buff,length);
 
148
    }
 
149
  inline longlong val_int_offset(uint row_offset)
 
150
    {
 
151
      ptr+=row_offset;
 
152
      longlong tmp=val_int();
 
153
      ptr-=row_offset;
 
154
      return tmp;
 
155
    }
 
156
  bool send(String *packet);
 
157
  virtual char *pack(char* to, const char *from, uint max_length=~(uint) 0)
 
158
  {
 
159
    uint length=pack_length();
 
160
    memcpy(to,from,length);
 
161
    return to+length;
 
162
  }
 
163
  virtual const char *unpack(char* to, const char *from)
 
164
  {
 
165
    uint length=pack_length();
 
166
    memcpy(to,from,length);
 
167
    return from+length;
 
168
  }
 
169
  virtual char *keypack(char* to, const char *from, uint max_length=~(uint) 0)
 
170
  {
 
171
    return pack(to,from,max_length);
 
172
  }
 
173
  virtual uint packed_col_length(const char *to)
 
174
  { return pack_length();}
 
175
  virtual uint max_packed_col_length(uint max_length)
 
176
  { return pack_length();}
 
177
 
 
178
  virtual int pack_cmp(const char *a,const char *b, uint key_length_arg)
 
179
  { return cmp(a,b); }
 
180
  uint offset();                                // Should be inline ...
 
181
  void copy_from_tmp(int offset);
 
182
  uint fill_cache_field(struct st_cache_field *copy);
 
183
  virtual bool get_date(TIME *ltime,bool fuzzydate);
 
184
  virtual bool get_time(TIME *ltime);
 
185
  friend bool reopen_table(THD *,struct st_table *,bool);
 
186
  friend int cre_myisam(my_string name, register TABLE *form, uint options,
 
187
                        ulonglong auto_increment_value);
 
188
  friend class Copy_field;
 
189
  friend class Item_avg_field;
 
190
  friend class Item_std_field;
 
191
  friend class Item_sum_num;
 
192
  friend class Item_sum_sum;
 
193
  friend class Item_sum_str;
 
194
  friend class Item_sum_count;
 
195
  friend class Item_sum_avg;
 
196
  friend class Item_sum_std;
 
197
  friend class Item_sum_min;
 
198
  friend class Item_sum_max;
 
199
};
 
200
 
 
201
 
 
202
class Field_num :public Field {
 
203
public:
 
204
  const uint8 dec;
 
205
  bool zerofill,unsigned_flag;          // Purify cannot handle bit fields
 
206
  Field_num(char *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
 
207
            uint null_bit_arg, utype unireg_check_arg,
 
208
            const char *field_name_arg,
 
209
            struct st_table *table_arg,
 
210
            uint dec_arg,bool zero_arg,bool unsigned_arg)
 
211
    :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 
212
           unireg_check_arg, field_name_arg, table_arg),
 
213
     dec(dec_arg),zerofill(zero_arg),unsigned_flag(unsigned_arg)
 
214
    {
 
215
      if (zerofill)
 
216
        flags|=ZEROFILL_FLAG;
 
217
      if (unsigned_flag)
 
218
        flags|=UNSIGNED_FLAG;
 
219
    }
 
220
  Item_result result_type () const { return REAL_RESULT; }
 
221
  void prepend_zeros(String *value);
 
222
  void add_zerofill_and_unsigned(String &res) const;
 
223
  friend class create_field;
 
224
  void make_field(Send_field *);
 
225
  uint decimals() const { return dec; }
 
226
  uint size_of() const { return sizeof(*this); }
 
227
  bool eq_def(Field *field);
 
228
};
 
229
 
 
230
 
 
231
class Field_str :public Field {
 
232
public:
 
233
  Field_str(char *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
 
234
            uint null_bit_arg, utype unireg_check_arg,
 
235
            const char *field_name_arg,
 
236
            struct st_table *table_arg)
 
237
    :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 
238
           unireg_check_arg, field_name_arg, table_arg)
 
239
    {}
 
240
  Item_result result_type () const { return STRING_RESULT; }
 
241
  uint decimals() const { return NOT_FIXED_DEC; }
 
242
  friend class create_field;
 
243
  void make_field(Send_field *);
 
244
  uint size_of() const { return sizeof(*this); }
 
245
};
 
246
 
 
247
 
 
248
class Field_decimal :public Field_num {
 
249
public:
 
250
  Field_decimal(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 
251
                uint null_bit_arg,
 
252
                enum utype unireg_check_arg, const char *field_name_arg,
 
253
                struct st_table *table_arg,
 
254
                uint dec_arg,bool zero_arg,bool unsigned_arg)
 
255
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 
256
               unireg_check_arg, field_name_arg, table_arg,
 
257
               dec_arg, zero_arg,unsigned_arg)
 
258
    {}
 
259
  enum_field_types type() const { return FIELD_TYPE_DECIMAL;}
 
260
  enum ha_base_keytype key_type() const
 
261
    { return zerofill ? HA_KEYTYPE_BINARY : HA_KEYTYPE_NUM; }
 
262
  void reset(void);
 
263
  void store(const char *to,uint length);
 
264
  void store(double nr);
 
265
  void store(longlong nr);
 
266
  double val_real(void);
 
267
  longlong val_int(void);
 
268
  String *val_str(String*,String *);
 
269
  int cmp(const char *,const char*);
 
270
  void sort_string(char *buff,uint length);
 
271
  void overflow(bool negative);
 
272
  bool zero_pack() const { return 0; }
 
273
  void sql_type(String &str) const;
 
274
};
 
275
 
 
276
 
 
277
class Field_tiny :public Field_num {
 
278
public:
 
279
  Field_tiny(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 
280
             uint null_bit_arg,
 
281
             enum utype unireg_check_arg, const char *field_name_arg,
 
282
             struct st_table *table_arg,
 
283
             bool zero_arg, bool unsigned_arg)
 
284
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 
285
               unireg_check_arg, field_name_arg, table_arg,
 
286
               0, zero_arg,unsigned_arg)
 
287
    {}
 
288
  enum Item_result result_type () const { return INT_RESULT; }
 
289
  enum_field_types type() const { return FIELD_TYPE_TINY;}
 
290
  enum ha_base_keytype key_type() const
 
291
    { return unsigned_flag ? HA_KEYTYPE_BINARY : HA_KEYTYPE_INT8; }
 
292
  void store(const char *to,uint length);
 
293
  void store(double nr);
 
294
  void store(longlong nr);
 
295
  double val_real(void);
 
296
  longlong val_int(void);
 
297
  String *val_str(String*,String *);
 
298
  int cmp(const char *,const char*);
 
299
  void sort_string(char *buff,uint length);
 
300
  uint32 pack_length() const { return 1; }
 
301
  void sql_type(String &str) const;
 
302
};
 
303
 
 
304
 
 
305
class Field_short :public Field_num {
 
306
public:
 
307
  Field_short(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 
308
              uint null_bit_arg,
 
309
              enum utype unireg_check_arg, const char *field_name_arg,
 
310
              struct st_table *table_arg,
 
311
              bool zero_arg, bool unsigned_arg)
 
312
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 
313
               unireg_check_arg, field_name_arg, table_arg,
 
314
               0, zero_arg,unsigned_arg)
 
315
    {}
 
316
  enum Item_result result_type () const { return INT_RESULT; }
 
317
  enum_field_types type() const { return FIELD_TYPE_SHORT;}
 
318
  enum ha_base_keytype key_type() const
 
319
    { return unsigned_flag ? HA_KEYTYPE_USHORT_INT : HA_KEYTYPE_SHORT_INT;}
 
320
  void store(const char *to,uint length);
 
321
  void store(double nr);
 
322
  void store(longlong nr);
 
323
  double val_real(void);
 
324
  longlong val_int(void);
 
325
  String *val_str(String*,String *);
 
326
  int cmp(const char *,const char*);
 
327
  void sort_string(char *buff,uint length);
 
328
  uint32 pack_length() const { return 2; }
 
329
  void sql_type(String &str) const;
 
330
};
 
331
 
 
332
 
 
333
class Field_medium :public Field_num {
 
334
public:
 
335
  Field_medium(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 
336
              uint null_bit_arg,
 
337
              enum utype unireg_check_arg, const char *field_name_arg,
 
338
              struct st_table *table_arg,
 
339
              bool zero_arg, bool unsigned_arg)
 
340
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 
341
               unireg_check_arg, field_name_arg, table_arg,
 
342
               0, zero_arg,unsigned_arg)
 
343
    {}
 
344
  enum Item_result result_type () const { return INT_RESULT; }
 
345
  enum_field_types type() const { return FIELD_TYPE_INT24;}
 
346
  enum ha_base_keytype key_type() const
 
347
    { return unsigned_flag ? HA_KEYTYPE_UINT24 : HA_KEYTYPE_INT24; }
 
348
  void store(const char *to,uint length);
 
349
  void store(double nr);
 
350
  void store(longlong nr);
 
351
  double val_real(void);
 
352
  longlong val_int(void);
 
353
  String *val_str(String*,String *);
 
354
  int cmp(const char *,const char*);
 
355
  void sort_string(char *buff,uint length);
 
356
  uint32 pack_length() const { return 3; }
 
357
  void sql_type(String &str) const;
 
358
};
 
359
 
 
360
 
 
361
class Field_long :public Field_num {
 
362
public:
 
363
  Field_long(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 
364
             uint null_bit_arg,
 
365
             enum utype unireg_check_arg, const char *field_name_arg,
 
366
             struct st_table *table_arg,
 
367
             bool zero_arg, bool unsigned_arg)
 
368
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 
369
               unireg_check_arg, field_name_arg, table_arg,
 
370
               0, zero_arg,unsigned_arg)
 
371
    {}
 
372
  Field_long(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
 
373
             struct st_table *table_arg,bool unsigned_arg)
 
374
    :Field_num((char*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0,0,
 
375
               NONE, field_name_arg, table_arg,0,0,unsigned_arg)
 
376
    {}
 
377
  enum Item_result result_type () const { return INT_RESULT; }
 
378
  enum_field_types type() const { return FIELD_TYPE_LONG;}
 
379
  enum ha_base_keytype key_type() const
 
380
    { return unsigned_flag ? HA_KEYTYPE_ULONG_INT : HA_KEYTYPE_LONG_INT; }
 
381
  void store(const char *to,uint length);
 
382
  void store(double nr);
 
383
  void store(longlong nr);
 
384
  double val_real(void);
 
385
  longlong val_int(void);
 
386
  String *val_str(String*,String *);
 
387
  int cmp(const char *,const char*);
 
388
  void sort_string(char *buff,uint length);
 
389
  uint32 pack_length() const { return 4; }
 
390
  void sql_type(String &str) const;
 
391
};
 
392
 
 
393
 
 
394
#ifdef HAVE_LONG_LONG
 
395
class Field_longlong :public Field_num {
 
396
public:
 
397
  Field_longlong(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 
398
              uint null_bit_arg,
 
399
              enum utype unireg_check_arg, const char *field_name_arg,
 
400
              struct st_table *table_arg,
 
401
              bool zero_arg, bool unsigned_arg)
 
402
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 
403
               unireg_check_arg, field_name_arg, table_arg,
 
404
               0, zero_arg,unsigned_arg)
 
405
    {}
 
406
  Field_longlong(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
 
407
                 struct st_table *table_arg)
 
408
    :Field_num((char*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0,0,
 
409
               NONE, field_name_arg, table_arg,0,0,0)
 
410
    {}
 
411
  enum Item_result result_type () const { return INT_RESULT; }
 
412
  enum_field_types type() const { return FIELD_TYPE_LONGLONG;}
 
413
  enum ha_base_keytype key_type() const
 
414
    { return unsigned_flag ? HA_KEYTYPE_ULONGLONG : HA_KEYTYPE_LONGLONG; }
 
415
  void store(const char *to,uint length);
 
416
  void store(double nr);
 
417
  void store(longlong nr);
 
418
  double val_real(void);
 
419
  longlong val_int(void);
 
420
  String *val_str(String*,String *);
 
421
  int cmp(const char *,const char*);
 
422
  void sort_string(char *buff,uint length);
 
423
  uint32 pack_length() const { return 8; }
 
424
  void sql_type(String &str) const;
 
425
};
 
426
#endif
 
427
 
 
428
class Field_float :public Field_num {
 
429
public:
 
430
  Field_float(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 
431
              uint null_bit_arg,
 
432
              enum utype unireg_check_arg, const char *field_name_arg,
 
433
              struct st_table *table_arg,
 
434
               uint dec_arg,bool zero_arg,bool unsigned_arg)
 
435
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 
436
               unireg_check_arg, field_name_arg, table_arg,
 
437
               dec_arg, zero_arg,unsigned_arg)
 
438
    {}
 
439
  enum_field_types type() const { return FIELD_TYPE_FLOAT;}
 
440
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_FLOAT; }
 
441
  void store(const char *to,uint length);
 
442
  void store(double nr);
 
443
  void store(longlong nr);
 
444
  double val_real(void);
 
445
  longlong val_int(void);
 
446
  String *val_str(String*,String *);
 
447
  int cmp(const char *,const char*);
 
448
  void sort_string(char *buff,uint length);
 
449
  uint32 pack_length() const { return sizeof(float); }
 
450
  void sql_type(String &str) const;
 
451
};
 
452
 
 
453
 
 
454
class Field_double :public Field_num {
 
455
public:
 
456
  Field_double(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 
457
               uint null_bit_arg,
 
458
               enum utype unireg_check_arg, const char *field_name_arg,
 
459
               struct st_table *table_arg,
 
460
               uint dec_arg,bool zero_arg,bool unsigned_arg)
 
461
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 
462
               unireg_check_arg, field_name_arg, table_arg,
 
463
               dec_arg, zero_arg,unsigned_arg)
 
464
    {}
 
465
  Field_double(uint32 len_arg, bool maybe_null_arg, const char *field_name_arg,
 
466
               struct st_table *table_arg, uint dec_arg)
 
467
    :Field_num((char*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0, (uint) 0,
 
468
               NONE, field_name_arg, table_arg,dec_arg,0,0)
 
469
    {}
 
470
  enum_field_types type() const { return FIELD_TYPE_DOUBLE;}
 
471
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_DOUBLE; }
 
472
  void store(const char *to,uint length);
 
473
  void store(double nr);
 
474
  void store(longlong nr);
 
475
  double val_real(void);
 
476
  longlong val_int(void);
 
477
  String *val_str(String*,String *);
 
478
  int cmp(const char *,const char*);
 
479
  void sort_string(char *buff,uint length);
 
480
  uint32 pack_length() const { return sizeof(double); }
 
481
  void sql_type(String &str) const;
 
482
};
 
483
 
 
484
 
 
485
/* Everything saved in this will disapper. It will always return NULL */
 
486
 
 
487
class Field_null :public Field_str {
 
488
  static uchar null[1];
 
489
public:
 
490
  Field_null(char *ptr_arg, uint32 len_arg,
 
491
             enum utype unireg_check_arg, const char *field_name_arg,
 
492
             struct st_table *table_arg)
 
493
    :Field_str(ptr_arg, len_arg, null, 1,
 
494
               unireg_check_arg, field_name_arg, table_arg)
 
495
    {}
 
496
  enum_field_types type() const { return FIELD_TYPE_NULL;}
 
497
  void store(const char *to, uint length) { null[0]=1; }
 
498
  void store(double nr)   { null[0]=1; }
 
499
  void store(longlong nr) { null[0]=1; }
 
500
  double val_real(void)         { return 0.0;}
 
501
  longlong val_int(void)        { return 0;}
 
502
  String *val_str(String *value,String *value2)
 
503
  { value2->length(0); return value2;}
 
504
  int cmp(const char *a, const char *b) { return 0;}
 
505
  void sort_string(char *buff, uint length)  {}
 
506
  uint32 pack_length() const { return 0; }
 
507
  void sql_type(String &str) const { str.set("null",4); }
 
508
  uint size_of() const { return sizeof(*this); }
 
509
};
 
510
 
 
511
 
 
512
class Field_timestamp :public Field_num {
 
513
public:
 
514
  Field_timestamp(char *ptr_arg, uint32 len_arg,
 
515
                  enum utype unireg_check_arg, const char *field_name_arg,
 
516
                  struct st_table *table_arg);
 
517
  enum Item_result result_type () const { return INT_RESULT; }
 
518
  enum_field_types type() const { return FIELD_TYPE_TIMESTAMP;}
 
519
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONG_INT; }
 
520
  void store(const char *to,uint length);
 
521
  void store(double nr);
 
522
  void store(longlong nr);
 
523
  double val_real(void);
 
524
  longlong val_int(void);
 
525
  String *val_str(String*,String *);
 
526
  int cmp(const char *,const char*);
 
527
  void sort_string(char *buff,uint length);
 
528
  uint32 pack_length() const { return 4; }
 
529
  void sql_type(String &str) const;
 
530
  bool store_for_compare() { return 1; }
 
531
  bool zero_pack() const { return 0; }
 
532
  void set_time();
 
533
  inline long get_timestamp()
 
534
  {
 
535
#ifdef WORDS_BIGENDIAN
 
536
    if (table->db_low_byte_first)
 
537
      return sint4korr(ptr);
 
538
#endif
 
539
    long tmp;
 
540
    longget(tmp,ptr);
 
541
    return tmp;
 
542
  }
 
543
  void fill_and_store(char *from,uint len);
 
544
  bool get_date(TIME *ltime,bool fuzzydate);
 
545
  bool get_time(TIME *ltime);
 
546
};
 
547
 
 
548
 
 
549
class Field_year :public Field_tiny {
 
550
public:
 
551
  Field_year(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 
552
             uint null_bit_arg,
 
553
             enum utype unireg_check_arg, const char *field_name_arg,
 
554
             struct st_table *table_arg)
 
555
    :Field_tiny(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 
556
                unireg_check_arg, field_name_arg, table_arg, 1, 1)
 
557
    {}
 
558
  enum_field_types type() const { return FIELD_TYPE_YEAR;}
 
559
  void store(const char *to,uint length);
 
560
  void store(double nr);
 
561
  void store(longlong nr);
 
562
  double val_real(void);
 
563
  longlong val_int(void);
 
564
  String *val_str(String*,String *);
 
565
  void sql_type(String &str) const;
 
566
};
 
567
 
 
568
 
 
569
class Field_date :public Field_str {
 
570
public:
 
571
  Field_date(char *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg,
 
572
             enum utype unireg_check_arg, const char *field_name_arg,
 
573
             struct st_table *table_arg)
 
574
    :Field_str(ptr_arg, 10, null_ptr_arg, null_bit_arg,
 
575
               unireg_check_arg, field_name_arg, table_arg)
 
576
    {}
 
577
  enum_field_types type() const { return FIELD_TYPE_DATE;}
 
578
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONG_INT; }
 
579
  enum Item_result cmp_type () const { return INT_RESULT; }
 
580
  void store(const char *to,uint length);
 
581
  void store(double nr);
 
582
  void store(longlong nr);
 
583
  double val_real(void);
 
584
  longlong val_int(void);
 
585
  String *val_str(String*,String *);
 
586
  int cmp(const char *,const char*);
 
587
  void sort_string(char *buff,uint length);
 
588
  uint32 pack_length() const { return 4; }
 
589
  void sql_type(String &str) const;
 
590
  bool store_for_compare() { return 1; }
 
591
  bool zero_pack() const { return 1; }
 
592
};
 
593
 
 
594
class Field_newdate :public Field_str {
 
595
public:
 
596
  Field_newdate(char *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg,
 
597
                enum utype unireg_check_arg, const char *field_name_arg,
 
598
                struct st_table *table_arg)
 
599
    :Field_str(ptr_arg, 10, null_ptr_arg, null_bit_arg,
 
600
               unireg_check_arg, field_name_arg, table_arg)
 
601
    {}
 
602
  enum_field_types type() const { return FIELD_TYPE_DATE;}
 
603
  enum_field_types real_type() const { return FIELD_TYPE_NEWDATE; }
 
604
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_UINT24; }
 
605
  enum Item_result cmp_type () const { return INT_RESULT; }
 
606
  void store(const char *to,uint length);
 
607
  void store(double nr);
 
608
  void store(longlong nr);
 
609
  void store_time(TIME *ltime,timestamp_type type);
 
610
  double val_real(void);
 
611
  longlong val_int(void);
 
612
  String *val_str(String*,String *);
 
613
  int cmp(const char *,const char*);
 
614
  void sort_string(char *buff,uint length);
 
615
  uint32 pack_length() const { return 3; }
 
616
  void sql_type(String &str) const;
 
617
  bool store_for_compare() { return 1; }
 
618
  bool zero_pack() const { return 1; }
 
619
  bool get_date(TIME *ltime,bool fuzzydate);
 
620
  bool get_time(TIME *ltime);
 
621
};
 
622
 
 
623
 
 
624
class Field_time :public Field_str {
 
625
public:
 
626
  Field_time(char *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg,
 
627
             enum utype unireg_check_arg, const char *field_name_arg,
 
628
             struct st_table *table_arg)
 
629
    :Field_str(ptr_arg, 8, null_ptr_arg, null_bit_arg,
 
630
               unireg_check_arg, field_name_arg, table_arg)
 
631
    {}
 
632
  enum_field_types type() const { return FIELD_TYPE_TIME;}
 
633
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_INT24; }
 
634
  enum Item_result cmp_type () const { return INT_RESULT; }
 
635
  void store(const char *to,uint length);
 
636
  void store(double nr);
 
637
  void store(longlong nr);
 
638
  double val_real(void);
 
639
  longlong val_int(void);
 
640
  String *val_str(String*,String *);
 
641
  bool get_time(TIME *ltime);
 
642
  int cmp(const char *,const char*);
 
643
  void sort_string(char *buff,uint length);
 
644
  uint32 pack_length() const { return 3; }
 
645
  void sql_type(String &str) const;
 
646
  bool store_for_compare() { return 1; }
 
647
  bool zero_pack() const { return 1; }
 
648
};
 
649
 
 
650
 
 
651
class Field_datetime :public Field_str {
 
652
public:
 
653
  Field_datetime(char *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg,
 
654
                 enum utype unireg_check_arg, const char *field_name_arg,
 
655
                 struct st_table *table_arg)
 
656
    :Field_str(ptr_arg, 19, null_ptr_arg, null_bit_arg,
 
657
               unireg_check_arg, field_name_arg, table_arg)
 
658
    {}
 
659
  enum_field_types type() const { return FIELD_TYPE_DATETIME;}
 
660
#ifdef HAVE_LONG_LONG
 
661
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONGLONG; }
 
662
#endif
 
663
  enum Item_result cmp_type () const { return INT_RESULT; }
 
664
  void store(const char *to,uint length);
 
665
  void store(double nr);
 
666
  void store(longlong nr);
 
667
  void store_time(TIME *ltime,timestamp_type type);
 
668
  double val_real(void);
 
669
  longlong val_int(void);
 
670
  String *val_str(String*,String *);
 
671
  int cmp(const char *,const char*);
 
672
  void sort_string(char *buff,uint length);
 
673
  uint32 pack_length() const { return 8; }
 
674
  void sql_type(String &str) const;
 
675
  bool store_for_compare() { return 1; }
 
676
  bool zero_pack() const { return 1; }
 
677
  bool get_date(TIME *ltime,bool fuzzydate);
 
678
  bool get_time(TIME *ltime);
 
679
};
 
680
 
 
681
 
 
682
class Field_string :public Field_str {
 
683
  bool binary_flag;
 
684
public:
 
685
  Field_string(char *ptr_arg, uint32 len_arg,uchar *null_ptr_arg,
 
686
               uint null_bit_arg,
 
687
               enum utype unireg_check_arg, const char *field_name_arg,
 
688
               struct st_table *table_arg,bool binary_arg)
 
689
    :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 
690
               unireg_check_arg, field_name_arg, table_arg),
 
691
    binary_flag(binary_arg)
 
692
    {
 
693
      if (binary_arg)
 
694
        flags|=BINARY_FLAG;
 
695
    }
 
696
  Field_string(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
 
697
               struct st_table *table_arg, bool binary_arg)
 
698
    :Field_str((char*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0,0,
 
699
               NONE, field_name_arg, table_arg),
 
700
    binary_flag(binary_arg)
 
701
    {
 
702
      if (binary_arg)
 
703
        flags|=BINARY_FLAG;
 
704
    }
 
705
 
 
706
  enum_field_types type() const
 
707
  {
 
708
    return ((table && table->db_create_options & HA_OPTION_PACK_RECORD &&
 
709
             field_length >= 4) ?
 
710
            FIELD_TYPE_VAR_STRING : FIELD_TYPE_STRING);
 
711
  }
 
712
  enum ha_base_keytype key_type() const
 
713
    { return binary_flag ? HA_KEYTYPE_BINARY : HA_KEYTYPE_TEXT; }
 
714
  bool zero_pack() const { return 0; }
 
715
  bool binary() const { return binary_flag; }
 
716
  void reset(void) { bfill(ptr,field_length,' '); }
 
717
  void store(const char *to,uint length);
 
718
  void store(double nr);
 
719
  void store(longlong nr);
 
720
  double val_real(void);
 
721
  longlong val_int(void);
 
722
  String *val_str(String*,String *);
 
723
  int cmp(const char *,const char*);
 
724
  void sort_string(char *buff,uint length);
 
725
  void sql_type(String &str) const;
 
726
  char *pack(char *to, const char *from, uint max_length=~(uint) 0);
 
727
  const char *unpack(char* to, const char *from);
 
728
  int pack_cmp(const char *a,const char *b,uint key_length);
 
729
  uint packed_col_length(const char *to);
 
730
  uint max_packed_col_length(uint max_length);
 
731
  uint size_of() const { return sizeof(*this); }
 
732
  enum_field_types real_type() const { return FIELD_TYPE_STRING; }
 
733
};
 
734
 
 
735
 
 
736
class Field_varstring :public Field_str {
 
737
  bool binary_flag;
 
738
public:
 
739
  Field_varstring(char *ptr_arg, uint32 len_arg,uchar *null_ptr_arg,
 
740
                  uint null_bit_arg,
 
741
                  enum utype unireg_check_arg, const char *field_name_arg,
 
742
                  struct st_table *table_arg,bool binary_arg)
 
743
    :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 
744
               unireg_check_arg, field_name_arg, table_arg),
 
745
    binary_flag(binary_arg)
 
746
    {
 
747
      if (binary_arg)
 
748
        flags|=BINARY_FLAG;
 
749
    }
 
750
  Field_varstring(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
 
751
                  struct st_table *table_arg, bool binary_arg)
 
752
    :Field_str((char*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0,0,
 
753
               NONE, field_name_arg, table_arg),
 
754
    binary_flag(binary_arg)
 
755
    {
 
756
      if (binary_arg)
 
757
        flags|=BINARY_FLAG;
 
758
    }
 
759
 
 
760
  enum_field_types type() const { return FIELD_TYPE_VAR_STRING; }
 
761
  enum ha_base_keytype key_type() const
 
762
    { return binary_flag ? HA_KEYTYPE_VARBINARY : HA_KEYTYPE_VARTEXT; }
 
763
  bool zero_pack() const { return 0; }
 
764
  bool binary() const { return binary_flag; }
 
765
  void reset(void) { bzero(ptr,field_length+2); }
 
766
  uint32 pack_length() const { return (uint32) field_length+2; }
 
767
  uint32 key_length() const { return (uint32) field_length; }
 
768
  void store(const char *to,uint length);
 
769
  void store(double nr);
 
770
  void store(longlong nr);
 
771
  double val_real(void);
 
772
  longlong val_int(void);
 
773
  String *val_str(String*,String *);
 
774
  int cmp(const char *,const char*);
 
775
  void sort_string(char *buff,uint length);
 
776
  void sql_type(String &str) const;
 
777
  char *pack(char *to, const char *from, uint max_length=~(uint) 0);
 
778
  const char *unpack(char* to, const char *from);
 
779
  int pack_cmp(const char *a, const char *b, uint key_length);
 
780
  uint packed_col_length(const char *to);
 
781
  uint max_packed_col_length(uint max_length);
 
782
  uint size_of() const { return sizeof(*this); }
 
783
  enum_field_types real_type() const { return FIELD_TYPE_VAR_STRING; }
 
784
};
 
785
 
 
786
 
 
787
class Field_blob :public Field_str {
 
788
  uint packlength;
 
789
  String value;                                 // For temporaries
 
790
  bool binary_flag;
 
791
public:
 
792
  Field_blob(char *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg,
 
793
             enum utype unireg_check_arg, const char *field_name_arg,
 
794
             struct st_table *table_arg,uint blob_pack_length,
 
795
             bool binary_arg);
 
796
  Field_blob(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
 
797
             struct st_table *table_arg, bool binary_arg)
 
798
    :Field_str((char*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0,0,
 
799
               NONE, field_name_arg, table_arg),
 
800
    packlength(3),binary_flag(binary_arg)
 
801
    {
 
802
      flags|= BLOB_FLAG;
 
803
      if (binary_arg)
 
804
        flags|=BINARY_FLAG;
 
805
    }
 
806
  enum_field_types type() const { return FIELD_TYPE_BLOB;}
 
807
  enum ha_base_keytype key_type() const
 
808
    { return binary_flag ? HA_KEYTYPE_VARBINARY : HA_KEYTYPE_VARTEXT; }
 
809
  void store(const char *to,uint length);
 
810
  void store(double nr);
 
811
  void store(longlong nr);
 
812
  double val_real(void);
 
813
  longlong val_int(void);
 
814
  String *val_str(String*,String *);
 
815
  int cmp(const char *,const char*);
 
816
  int cmp(const char *a, ulong a_length, const char *b, ulong b_length);
 
817
  int cmp_offset(uint offset);
 
818
  int cmp_binary(const char *a,const char *b, ulong max_length=~0L);
 
819
  int cmp_binary_offset(uint row_offset);
 
820
  int key_cmp(const byte *,const byte*);
 
821
  int key_cmp(const byte *str, uint length);
 
822
  uint32 key_length() const { return 0; }
 
823
  void sort_string(char *buff,uint length);
 
824
  uint32 pack_length() const { return (uint32) (packlength+table->blob_ptr_size); }
 
825
  void reset(void) { bzero(ptr,packlength+sizeof(char*)); }
 
826
  void reset_fields() { bzero((char*) &value,sizeof(value)); }
 
827
  void store_length(ulong number);
 
828
  inline ulong get_length(uint row_offset=0)
 
829
  { return get_length(ptr+row_offset); }
 
830
  ulong get_length(const char *ptr);
 
831
  bool binary() const { return binary_flag; }
 
832
  inline void get_ptr(char **str)
 
833
    {
 
834
      memcpy_fixed(str,ptr+packlength,sizeof(char*));
 
835
    }
 
836
  inline void set_ptr(char *length,char *data)
 
837
    {
 
838
      memcpy(ptr,length,packlength);
 
839
      memcpy_fixed(ptr+packlength,&data,sizeof(char*));
 
840
    }
 
841
  inline void set_ptr(ulong length,char *data)
 
842
    {
 
843
      store_length(length);
 
844
      memcpy_fixed(ptr+packlength,&data,sizeof(char*));
 
845
    }
 
846
  void get_key_image(char *buff,uint length);
 
847
  void set_key_image(char *buff,uint length);
 
848
  void sql_type(String &str) const;
 
849
  inline bool copy()
 
850
  { char *tmp;
 
851
    get_ptr(&tmp);
 
852
    if (value.copy(tmp,get_length()))
 
853
    {
 
854
      Field_blob::reset();
 
855
      return 1;
 
856
    }
 
857
    tmp=(char*) value.ptr(); memcpy_fixed(ptr+packlength,&tmp,sizeof(char*));
 
858
    return 0;
 
859
  }
 
860
  char *pack(char *to, const char *from, uint max_length= ~(uint) 0)
 
861
  {
 
862
    ulong length=get_length();
 
863
    if (length > max_length)
 
864
    {
 
865
      length=max_length;
 
866
      char *save=ptr;
 
867
      ptr=to;
 
868
      store_length(length);
 
869
      ptr=save;
 
870
    }
 
871
    else
 
872
      memcpy(to,from,packlength);
 
873
    if (length)
 
874
    {
 
875
      get_ptr((char**) &from);
 
876
      memcpy(to+packlength, from,length);
 
877
      return to+packlength+length;
 
878
    }
 
879
    return to+packlength;
 
880
  }
 
881
  const char *unpack(char *to, const char *from)
 
882
  {
 
883
    memcpy(to,from,packlength);
 
884
    from+=packlength;
 
885
    ulong length=get_length();
 
886
    if (length)
 
887
      memcpy_fixed(to+packlength, &from, sizeof(from));
 
888
    else
 
889
      bzero(to+packlength,sizeof(from));
 
890
    return from+length;
 
891
  }
 
892
  char *pack_key(char *to, const char *from, uint max_length=~(uint) 0);
 
893
  int pack_cmp(const char *a, const char *b, uint key_length);
 
894
  uint packed_col_length(const char *col_ptr)
 
895
  { return get_length(col_ptr)+packlength;}
 
896
  virtual uint max_packed_col_length(uint max_length)
 
897
  { return packlength+max_length; }
 
898
 
 
899
  inline void free() { value.free(); }
 
900
  inline void clear_temporary() { bzero((char*) &value,sizeof(value)); }
 
901
  friend void field_conv(Field *to,Field *from);
 
902
  uint size_of() const { return sizeof(*this); }
 
903
};
 
904
 
 
905
 
 
906
class Field_enum :public Field_str {
 
907
protected:
 
908
  uint packlength;
 
909
public:
 
910
  TYPELIB *typelib;
 
911
  Field_enum(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 
912
                 uint null_bit_arg,
 
913
                 enum utype unireg_check_arg, const char *field_name_arg,
 
914
                 struct st_table *table_arg,uint packlength_arg,
 
915
                 TYPELIB *typelib_arg)
 
916
    :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 
917
               unireg_check_arg, field_name_arg, table_arg),
 
918
    packlength(packlength_arg),typelib(typelib_arg)
 
919
    {
 
920
      flags|=ENUM_FLAG;
 
921
    }
 
922
  enum_field_types type() const { return FIELD_TYPE_STRING; }
 
923
  enum Item_result cmp_type () const { return INT_RESULT; }
 
924
  enum ha_base_keytype key_type() const;
 
925
  void store(const char *to,uint length);
 
926
  void store(double nr);
 
927
  void store(longlong nr);
 
928
  double val_real(void);
 
929
  longlong val_int(void);
 
930
  String *val_str(String*,String *);
 
931
  int cmp(const char *,const char*);
 
932
  void sort_string(char *buff,uint length);
 
933
  uint32 pack_length() const { return (uint32) packlength; }
 
934
  void store_type(ulonglong value);
 
935
  void sql_type(String &str) const;
 
936
  uint size_of() const { return sizeof(*this); }
 
937
  enum_field_types real_type() const { return FIELD_TYPE_ENUM; }
 
938
  virtual bool zero_pack() const { return 0; }
 
939
  bool optimize_range() { return 0; }
 
940
  bool binary() const { return 0; }
 
941
  bool eq_def(Field *field);
 
942
};
 
943
 
 
944
 
 
945
class Field_set :public Field_enum {
 
946
public:
 
947
  Field_set(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 
948
            uint null_bit_arg,
 
949
            enum utype unireg_check_arg, const char *field_name_arg,
 
950
            struct st_table *table_arg,uint32 packlength_arg,
 
951
            TYPELIB *typelib_arg)
 
952
    :Field_enum(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 
953
                    unireg_check_arg, field_name_arg,
 
954
                    table_arg, packlength_arg,
 
955
                    typelib_arg)
 
956
    {
 
957
      flags=(flags & ~ENUM_FLAG) | SET_FLAG;
 
958
    }
 
959
  void store(const char *to,uint length);
 
960
  void store(double nr) { Field_set::store((longlong) nr); }
 
961
  void store(longlong nr);
 
962
  virtual bool zero_pack() const { return 1; }
 
963
  String *val_str(String*,String *);
 
964
  void sql_type(String &str) const;
 
965
  enum_field_types real_type() const { return FIELD_TYPE_SET; }
 
966
};
 
967
 
 
968
 
 
969
/*
 
970
** Create field class for CREATE TABLE
 
971
*/
 
972
 
 
973
class create_field :public Sql_alloc {
 
974
public:
 
975
  const char *field_name;
 
976
  const char *change;                           // If done with alter table
 
977
  const char *after;                            // Put column after this one
 
978
  Item  *def;                                   // Default value
 
979
  enum  enum_field_types sql_type;
 
980
  uint32 length;
 
981
  uint decimals,flags,pack_length;
 
982
  Field::utype unireg_check;
 
983
  TYPELIB *interval;                            // Which interval to use
 
984
  Field *field;                                 // For alter table
 
985
 
 
986
  uint8 row,col,sc_length,interval_id;          // For rea_create_table
 
987
  uint  offset,pack_flag;
 
988
  create_field() :after(0) {}
 
989
  create_field(Field *field,bool ignore_default=0);
 
990
};
 
991
 
 
992
 
 
993
/*
 
994
** A class for sending info to the client
 
995
*/
 
996
 
 
997
class Send_field {
 
998
 public:
 
999
  const char *table_name,*col_name;
 
1000
  uint length,flags,decimals;
 
1001
  enum_field_types type;
 
1002
  Send_field() {}
 
1003
};
 
1004
 
 
1005
 
 
1006
/*
 
1007
** A class for quick copying data to fields
 
1008
*/
 
1009
 
 
1010
class Copy_field :public Sql_alloc {
 
1011
  void (*get_copy_func(Field *to,Field *from))(Copy_field *);
 
1012
public:
 
1013
  char *from_ptr,*to_ptr;
 
1014
  uchar *from_null_ptr,*to_null_ptr;
 
1015
  my_bool *null_row;
 
1016
  uint  from_bit,to_bit;
 
1017
  uint from_length,to_length;
 
1018
  Field *from_field,*to_field;
 
1019
  String tmp;                                   // For items
 
1020
 
 
1021
  Copy_field() {}
 
1022
  ~Copy_field() {}
 
1023
  void set(Field *to,Field *from,bool save);    // Field to field
 
1024
  void set(char *to,Field *from);               // Field to string
 
1025
  void (*do_copy)(Copy_field *);
 
1026
  void (*do_copy2)(Copy_field *);               // Used to handle null values
 
1027
};
 
1028
 
 
1029
 
 
1030
Field *make_field(char *ptr, uint32 field_length,
 
1031
                  uchar *null_pos, uint null_bit,
 
1032
                  uint pack_flag, Field::utype unireg_check,
 
1033
                  TYPELIB *interval, const char *field_name,
 
1034
                  struct st_table *table);
 
1035
uint pack_length_to_packflag(uint type);
 
1036
uint32 calc_pack_length(enum_field_types type,uint32 length);
 
1037
bool set_field_to_null(Field *field);
 
1038
uint find_enum(TYPELIB *typelib,const char *x, uint length);
 
1039
ulonglong find_set(TYPELIB *typelib,const char *x, uint length);
 
1040
bool test_if_int(const char *str,int length);
 
1041
 
 
1042
/*
 
1043
** The following are for the interface with the .frm file
 
1044
*/
 
1045
 
 
1046
#define FIELDFLAG_DECIMAL               1
 
1047
#define FIELDFLAG_BINARY                1       // Shares same flag
 
1048
#define FIELDFLAG_NUMBER                2
 
1049
#define FIELDFLAG_ZEROFILL              4
 
1050
#define FIELDFLAG_PACK                  120     // Bits used for packing
 
1051
#define FIELDFLAG_INTERVAL              256
 
1052
#define FIELDFLAG_BITFIELD              512     // mangled with dec!
 
1053
#define FIELDFLAG_BLOB                  1024    // mangled with dec!
 
1054
#define FIELDFLAG_LEFT_FULLSCREEN       8192
 
1055
#define FIELDFLAG_RIGHT_FULLSCREEN      16384
 
1056
#define FIELDFLAG_FORMAT_NUMBER         16384   // predit: ###,,## in output
 
1057
#define FIELDFLAG_SUM                   ((uint) 32768)// predit: +#fieldflag
 
1058
#define FIELDFLAG_MAYBE_NULL            ((uint) 32768)// sql
 
1059
#define FIELDFLAG_PACK_SHIFT            3
 
1060
#define FIELDFLAG_DEC_SHIFT             8
 
1061
#define FIELDFLAG_MAX_DEC               31
 
1062
#define FIELDFLAG_NUM_SCREEN_TYPE       0x7F01
 
1063
#define FIELDFLAG_ALFA_SCREEN_TYPE      0x7800
 
1064
 
 
1065
#define FIELD_SORT_REVERSE              16384
 
1066
 
 
1067
#define MTYP_TYPENR(type) (type & 127)  /* Remove bits from type */
 
1068
 
 
1069
#define f_is_dec(x)             ((x) & FIELDFLAG_DECIMAL)
 
1070
#define f_is_num(x)             ((x) & FIELDFLAG_NUMBER)
 
1071
#define f_is_zerofill(x)        ((x) & FIELDFLAG_ZEROFILL)
 
1072
#define f_is_packed(x)          ((x) & FIELDFLAG_PACK)
 
1073
#define f_packtype(x)           (((x) >> FIELDFLAG_PACK_SHIFT) & 15)
 
1074
#define f_decimals(x)           (((x) >> FIELDFLAG_DEC_SHIFT) & FIELDFLAG_MAX_DEC)
 
1075
#define f_is_alpha(x)           (!f_is_num(x))
 
1076
#define f_is_binary(x)          ((x) & FIELDFLAG_BINARY)
 
1077
#define f_is_enum(x)    ((x) & FIELDFLAG_INTERVAL)
 
1078
#define f_is_bitfield(x)        ((x) & FIELDFLAG_BITFIELD)
 
1079
#define f_is_blob(x)            (((x) & (FIELDFLAG_BLOB | FIELDFLAG_NUMBER)) == FIELDFLAG_BLOB)
 
1080
#define f_is_equ(x)             ((x) & (1+2+FIELDFLAG_PACK+31*256))
 
1081
#define f_settype(x)            (((int) x) << FIELDFLAG_PACK_SHIFT)
 
1082
#define f_maybe_null(x)         (x & FIELDFLAG_MAYBE_NULL)