← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.h

  • Committer: Monty Taylor
  • Date: 2008-09-16 00:00:48 UTC
  • mto: This revision was merged to the branch mainline in revision 391.
  • Revision ID: monty@inaugust.com-20080916000048-3rvrv3gv9l0ad3gs
Fixed copyright headers in drizzled/

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field.h
22
22
  variables must declare the size_of() member function.
23
23
*/
24
24
 
25
 
#ifndef DRIZZLED_FIELD_H
26
 
#define DRIZZLED_FIELD_H
27
 
 
28
 
#include <drizzled/sql_error.h>
29
 
#include <drizzled/my_decimal.h>
 
25
#ifdef USE_PRAGMA_INTERFACE
 
26
#pragma interface                       /* gcc class implementation */
 
27
#endif
30
28
 
31
29
#define DATETIME_DEC                     6
32
30
#define DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE FLOATING_POINT_BUFFER
39
37
struct st_cache_field;
40
38
int field_conv(Field *to,Field *from);
41
39
 
42
 
inline uint32_t get_enum_pack_length(int elements)
 
40
inline uint get_enum_pack_length(int elements)
43
41
{
44
42
  return elements < 256 ? 1 : 2;
45
43
}
46
44
 
47
 
inline uint32_t get_set_pack_length(int elements)
 
45
inline uint get_set_pack_length(int elements)
48
46
{
49
 
  uint32_t len= (elements + 7) / 8;
 
47
  uint len= (elements + 7) / 8;
50
48
  return len > 4 ? 8 : len;
51
49
}
52
50
 
53
 
class virtual_column_info: public Sql_alloc
54
 
{
55
 
public:
56
 
  Item *expr_item;
57
 
  LEX_STRING expr_str;
58
 
  Item *item_free_list;
59
 
  virtual_column_info() 
60
 
  : expr_item(0), item_free_list(0),
61
 
    field_type(DRIZZLE_TYPE_VIRTUAL),
62
 
    is_stored(false), data_inited(false)
63
 
  {
64
 
    expr_str.str= NULL;
65
 
    expr_str.length= 0;
66
 
  };
67
 
  ~virtual_column_info() {}
68
 
  enum_field_types get_real_type()
69
 
  {
70
 
    assert(data_inited);
71
 
    return data_inited ? field_type : DRIZZLE_TYPE_VIRTUAL;
72
 
  }
73
 
  void set_field_type(enum_field_types fld_type)
74
 
  {
75
 
    /* Calling this function can only be done once. */
76
 
    assert(not data_inited);
77
 
    data_inited= true;
78
 
    field_type= fld_type;
79
 
  }
80
 
  bool get_field_stored()
81
 
  {
82
 
    assert(data_inited);
83
 
    return data_inited ? is_stored : true;
84
 
  }
85
 
  void set_field_stored(bool stored)
86
 
  {
87
 
    is_stored= stored;
88
 
  }
89
 
private:
90
 
  /*
91
 
    The following data is only updated by the parser and read
92
 
    when a Create_field object is created/initialized.
93
 
  */
94
 
  enum_field_types field_type;   /* Real field type*/
95
 
  bool is_stored;             /* Indication that the field is 
96
 
                                    phisically stored in the database*/
97
 
  /*
98
 
    This flag is used to prevent other applications from
99
 
    reading and using incorrect data.
100
 
  */
101
 
  bool data_inited; 
102
 
};
103
 
 
104
51
class Field
105
52
{
106
53
  Field(const Item &);                          /* Prevent use of these */
111
58
                              size_t size __attribute__((unused)))
112
59
  { TRASH(ptr_arg, size); }
113
60
 
114
 
  unsigned char         *ptr;                   // Position to field in record
115
 
  unsigned char         *null_ptr;              // Byte where null_bit is
 
61
  uchar         *ptr;                   // Position to field in record
 
62
  uchar         *null_ptr;              // Byte where null_bit is
116
63
  /*
117
 
    Note that you can use table->in_use as replacement for current_session member 
 
64
    Note that you can use table->in_use as replacement for current_thd member 
118
65
    only inside of val_*() and store() members (e.g. you can't use it in cons)
119
66
  */
120
67
  Table *table;         // Pointer for table
142
89
  uint32_t      field_length;           // Length of field
143
90
  uint32_t      flags;
144
91
  uint16_t        field_index;            // field number in fields array
145
 
  unsigned char         null_bit;               // Bit used to test null bit
 
92
  uchar         null_bit;               // Bit used to test null bit
146
93
  /**
147
94
     If true, this field was created in create_tmp_field_from_item from a NULL
148
95
     value. This means that the type of the field is just a guess, and the type
154
101
   */
155
102
  bool is_created_from_null_item;
156
103
 
157
 
  /* Virtual column data */
158
 
  virtual_column_info *vcol_info;
159
 
  /*
160
 
    Indication that the field is phycically stored in tables 
161
 
    rather than just generated on SQL queries.
162
 
    As of now, false can only be set for generated-only virtual columns.
163
 
  */
164
 
  bool is_stored;
165
 
 
166
 
  Field(unsigned char *ptr_arg,uint32_t length_arg,unsigned char *null_ptr_arg,
167
 
        unsigned char null_bit_arg, utype unireg_check_arg,
 
104
  Field(uchar *ptr_arg,uint32_t length_arg,uchar *null_ptr_arg,
 
105
        uchar null_bit_arg, utype unireg_check_arg,
168
106
        const char *field_name_arg);
169
107
  virtual ~Field() {}
170
108
  /* Store functions returns 1 on overflow and -1 on fatal error */
171
 
  virtual int  store(const char *to, uint32_t length, const CHARSET_INFO * const cs)=0;
 
109
  virtual int  store(const char *to, uint length, const CHARSET_INFO * const cs)=0;
172
110
  virtual int  store(double nr)=0;
173
111
  virtual int  store(int64_t nr, bool unsigned_val)=0;
174
112
  virtual int  store_decimal(const my_decimal *d)=0;
175
 
  virtual int store_time(DRIZZLE_TIME *ltime, enum enum_drizzle_timestamp_type t_type);
176
 
  int store(const char *to, uint32_t length, const CHARSET_INFO * const cs,
 
113
  virtual int store_time(DRIZZLE_TIME *ltime, timestamp_type t_type);
 
114
  int store(const char *to, uint length, const CHARSET_INFO * const cs,
177
115
            enum_check_fields check_level);
178
116
  virtual double val_real(void)=0;
179
117
  virtual int64_t val_int(void)=0;
224
162
    table, which is located on disk).
225
163
  */
226
164
  virtual uint32_t pack_length_in_rec() const { return pack_length(); }
227
 
  virtual int compatible_field_size(uint32_t field_metadata);
228
 
  virtual uint32_t pack_length_from_metadata(uint32_t field_metadata)
 
165
  virtual int compatible_field_size(uint field_metadata);
 
166
  virtual uint pack_length_from_metadata(uint field_metadata)
229
167
  { return field_metadata; }
230
168
  /*
231
169
    This method is used to return the size of the data in a row-based
239
177
    the classes Field_varstring, and Field_blob return 
240
178
    field_length + 1, field_length, and pack_length_no_ptr() respectfully.
241
179
  */
242
 
  virtual uint32_t row_pack_length() { return 0; }
243
 
  virtual int save_field_metadata(unsigned char *first_byte)
 
180
  virtual uint row_pack_length() { return 0; }
 
181
  virtual int save_field_metadata(uchar *first_byte)
244
182
  { return do_save_field_metadata(first_byte); }
245
183
 
246
184
  /*
273
211
    my_ptrdiff_t l_offset= (my_ptrdiff_t) (table->getDefaultValues() - table->record[0]);
274
212
    memcpy(ptr, ptr + l_offset, pack_length());
275
213
    if (null_ptr)
276
 
      *null_ptr= ((*null_ptr & (unsigned char) ~null_bit) | (null_ptr[l_offset] & null_bit));
 
214
      *null_ptr= ((*null_ptr & (uchar) ~null_bit) | (null_ptr[l_offset] & null_bit));
277
215
  }
278
216
  virtual bool binary() const { return 1; }
279
217
  virtual bool zero_pack() const { return 1; }
281
219
  virtual uint32_t key_length() const { return pack_length(); }
282
220
  virtual enum_field_types type() const =0;
283
221
  virtual enum_field_types real_type() const { return type(); }
284
 
  inline  int cmp(const unsigned char *str) { return cmp(ptr,str); }
285
 
  virtual int cmp_max(const unsigned char *a, const unsigned char *b,
286
 
                      uint32_t max_len __attribute__((unused)))
 
222
  inline  int cmp(const uchar *str) { return cmp(ptr,str); }
 
223
  virtual int cmp_max(const uchar *a, const uchar *b,
 
224
                      uint max_len __attribute__((unused)))
287
225
    { return cmp(a, b); }
288
 
  virtual int cmp(const unsigned char *,const unsigned char *)=0;
289
 
  virtual int cmp_binary(const unsigned char *a,const unsigned char *b,
 
226
  virtual int cmp(const uchar *,const uchar *)=0;
 
227
  virtual int cmp_binary(const uchar *a,const uchar *b,
290
228
                         uint32_t  __attribute__((unused)) max_length=UINT32_MAX)
291
229
  { return memcmp(a,b,pack_length()); }
292
 
  virtual int cmp_offset(uint32_t row_offset)
 
230
  virtual int cmp_offset(uint row_offset)
293
231
  { return cmp(ptr,ptr+row_offset); }
294
 
  virtual int cmp_binary_offset(uint32_t row_offset)
 
232
  virtual int cmp_binary_offset(uint row_offset)
295
233
  { return cmp_binary(ptr, ptr+row_offset); };
296
 
  virtual int key_cmp(const unsigned char *a,const unsigned char *b)
 
234
  virtual int key_cmp(const uchar *a,const uchar *b)
297
235
  { return cmp(a, b); }
298
 
  virtual int key_cmp(const unsigned char *str, uint32_t length __attribute__((unused)))
 
236
  virtual int key_cmp(const uchar *str, uint length __attribute__((unused)))
299
237
  { return cmp(ptr,str); }
300
 
  virtual uint32_t decimals() const { return 0; }
 
238
  virtual uint decimals() const { return 0; }
301
239
  /*
302
240
    Caller beware: sql_type can change str.Ptr, so check
303
241
    ptr() to see if it changed if you are using your own buffer
304
242
    in str and restore it with set() if needed
305
243
  */
306
244
  virtual void sql_type(String &str) const =0;
307
 
  virtual uint32_t size_of() const =0;          // For new field
 
245
  virtual uint size_of() const =0;              // For new field
308
246
  inline bool is_null(my_ptrdiff_t row_offset= 0)
309
247
  { return null_ptr ? (null_ptr[row_offset] & null_bit ? 1 : 0) : table->null_row; }
310
248
  inline bool is_real_null(my_ptrdiff_t row_offset= 0)
311
249
    { return null_ptr ? (null_ptr[row_offset] & null_bit ? 1 : 0) : 0; }
312
 
  inline bool is_null_in_record(const unsigned char *record)
 
250
  inline bool is_null_in_record(const uchar *record)
313
251
  {
314
252
    if (!null_ptr)
315
253
      return 0;
316
 
    return test(record[(uint32_t) (null_ptr -table->record[0])] &
 
254
    return test(record[(uint) (null_ptr -table->record[0])] &
317
255
                null_bit);
318
256
  }
319
257
  inline bool is_null_in_record_with_offset(my_ptrdiff_t offset)
325
263
  inline void set_null(my_ptrdiff_t row_offset= 0)
326
264
    { if (null_ptr) null_ptr[row_offset]|= null_bit; }
327
265
  inline void set_notnull(my_ptrdiff_t row_offset= 0)
328
 
    { if (null_ptr) null_ptr[row_offset]&= (unsigned char) ~null_bit; }
 
266
    { if (null_ptr) null_ptr[row_offset]&= (uchar) ~null_bit; }
329
267
  inline bool maybe_null(void) { return null_ptr != 0 || table->maybe_null; }
330
268
  inline bool real_maybe_null(void) { return null_ptr != 0; }
331
269
 
355
293
  }
356
294
 
357
295
  virtual void make_field(Send_field *);
358
 
  virtual void sort_string(unsigned char *buff,uint32_t length)=0;
359
 
  virtual bool optimize_range(uint32_t idx, uint32_t part);
 
296
  virtual void sort_string(uchar *buff,uint length)=0;
 
297
  virtual bool optimize_range(uint idx, uint part);
360
298
  /*
361
299
    This should be true for fields which, when compared with constant
362
300
    items, can be casted to int64_t. In this case we will at 'fix_fields'
369
307
  virtual Field *new_field(MEM_ROOT *root, Table *new_table,
370
308
                           bool keep_type);
371
309
  virtual Field *new_key_field(MEM_ROOT *root, Table *new_table,
372
 
                               unsigned char *new_ptr, unsigned char *new_null_ptr,
373
 
                               uint32_t new_null_bit);
 
310
                               uchar *new_ptr, uchar *new_null_ptr,
 
311
                               uint new_null_bit);
374
312
  Field *clone(MEM_ROOT *mem_root, Table *new_table);
375
 
  inline void move_field(unsigned char *ptr_arg,unsigned char *null_ptr_arg,unsigned char null_bit_arg)
 
313
  inline void move_field(uchar *ptr_arg,uchar *null_ptr_arg,uchar null_bit_arg)
376
314
  {
377
315
    ptr=ptr_arg; null_ptr=null_ptr_arg; null_bit=null_bit_arg;
378
316
  }
379
 
  inline void move_field(unsigned char *ptr_arg) { ptr=ptr_arg; }
 
317
  inline void move_field(uchar *ptr_arg) { ptr=ptr_arg; }
380
318
  virtual void move_field_offset(my_ptrdiff_t ptr_diff)
381
319
  {
382
 
    ptr=ADD_TO_PTR(ptr,ptr_diff, unsigned char*);
 
320
    ptr=ADD_TO_PTR(ptr,ptr_diff, uchar*);
383
321
    if (null_ptr)
384
 
      null_ptr=ADD_TO_PTR(null_ptr,ptr_diff,unsigned char*);
 
322
      null_ptr=ADD_TO_PTR(null_ptr,ptr_diff,uchar*);
385
323
  }
386
 
  virtual void get_image(unsigned char *buff, uint32_t length,
 
324
  virtual void get_image(uchar *buff, uint length,
387
325
                         const CHARSET_INFO * const cs __attribute__((unused)))
388
326
    { memcpy(buff,ptr,length); }
389
 
  virtual void set_image(const unsigned char *buff,uint32_t length,
 
327
  virtual void set_image(const uchar *buff,uint length,
390
328
                         const CHARSET_INFO * const cs __attribute__((unused)))
391
329
    { memcpy(ptr,buff,length); }
392
330
 
417
355
      Number of copied bytes (excluding padded zero bytes -- see above).
418
356
  */
419
357
 
420
 
  virtual uint32_t get_key_image(unsigned char *buff, uint32_t length,
 
358
  virtual uint get_key_image(uchar *buff, uint length,
421
359
                             imagetype type __attribute__((unused)))
422
360
  {
423
361
    get_image(buff, length, &my_charset_bin);
424
362
    return length;
425
363
  }
426
 
  virtual void set_key_image(const unsigned char *buff,uint32_t length)
 
364
  virtual void set_key_image(const uchar *buff,uint length)
427
365
    { set_image(buff,length, &my_charset_bin); }
428
 
  inline int64_t val_int_offset(uint32_t row_offset)
 
366
  inline int64_t val_int_offset(uint row_offset)
429
367
    {
430
368
      ptr+=row_offset;
431
369
      int64_t tmp=val_int();
432
370
      ptr-=row_offset;
433
371
      return tmp;
434
372
    }
435
 
  inline int64_t val_int(const unsigned char *new_ptr)
 
373
  inline int64_t val_int(const uchar *new_ptr)
436
374
  {
437
 
    unsigned char *old_ptr= ptr;
 
375
    uchar *old_ptr= ptr;
438
376
    int64_t return_value;
439
 
    ptr= (unsigned char*) new_ptr;
 
377
    ptr= (uchar*) new_ptr;
440
378
    return_value= val_int();
441
379
    ptr= old_ptr;
442
380
    return return_value;
443
381
  }
444
 
  inline String *val_str(String *str, const unsigned char *new_ptr)
 
382
  inline String *val_str(String *str, const uchar *new_ptr)
445
383
  {
446
 
    unsigned char *old_ptr= ptr;
447
 
    ptr= (unsigned char*) new_ptr;
 
384
    uchar *old_ptr= ptr;
 
385
    ptr= (uchar*) new_ptr;
448
386
    val_str(str);
449
387
    ptr= old_ptr;
450
388
    return str;
451
389
  }
452
390
  virtual bool send_binary(Protocol *protocol);
453
391
 
454
 
  virtual unsigned char *pack(unsigned char *to, const unsigned char *from,
455
 
                      uint32_t max_length, bool low_byte_first);
456
 
  /**
457
 
     @overload Field::pack(unsigned char*, const unsigned char*, uint32_t, bool)
458
 
  */
459
 
  unsigned char *pack(unsigned char *to, const unsigned char *from)
460
 
  {
461
 
    unsigned char *result= this->pack(to, from, UINT_MAX, table->s->db_low_byte_first);
462
 
    return(result);
463
 
  }
464
 
 
465
 
  virtual const unsigned char *unpack(unsigned char* to, const unsigned char *from,
466
 
                              uint32_t param_data, bool low_byte_first);
467
 
  /**
468
 
     @overload Field::unpack(unsigned char*, const unsigned char*, uint32_t, bool)
469
 
  */
470
 
  const unsigned char *unpack(unsigned char* to, const unsigned char *from)
471
 
  {
472
 
    const unsigned char *result= unpack(to, from, 0U, table->s->db_low_byte_first);
473
 
    return(result);
474
 
  }
475
 
 
476
 
  virtual unsigned char *pack_key(unsigned char* to, const unsigned char *from,
477
 
                          uint32_t max_length, bool low_byte_first)
478
 
  {
479
 
    return pack(to, from, max_length, low_byte_first);
480
 
  }
481
 
  virtual unsigned char *pack_key_from_key_image(unsigned char* to, const unsigned char *from,
482
 
                                        uint32_t max_length, bool low_byte_first)
483
 
  {
484
 
    return pack(to, from, max_length, low_byte_first);
485
 
  }
486
 
  virtual const unsigned char *unpack_key(unsigned char* to, const unsigned char *from,
487
 
                                  uint32_t max_length, bool low_byte_first)
 
392
  virtual uchar *pack(uchar *to, const uchar *from,
 
393
                      uint max_length, bool low_byte_first);
 
394
  /**
 
395
     @overload Field::pack(uchar*, const uchar*, uint, bool)
 
396
  */
 
397
  uchar *pack(uchar *to, const uchar *from)
 
398
  {
 
399
    uchar *result= this->pack(to, from, UINT_MAX, table->s->db_low_byte_first);
 
400
    return(result);
 
401
  }
 
402
 
 
403
  virtual const uchar *unpack(uchar* to, const uchar *from,
 
404
                              uint param_data, bool low_byte_first);
 
405
  /**
 
406
     @overload Field::unpack(uchar*, const uchar*, uint, bool)
 
407
  */
 
408
  const uchar *unpack(uchar* to, const uchar *from)
 
409
  {
 
410
    const uchar *result= unpack(to, from, 0U, table->s->db_low_byte_first);
 
411
    return(result);
 
412
  }
 
413
 
 
414
  virtual uchar *pack_key(uchar* to, const uchar *from,
 
415
                          uint max_length, bool low_byte_first)
 
416
  {
 
417
    return pack(to, from, max_length, low_byte_first);
 
418
  }
 
419
  virtual uchar *pack_key_from_key_image(uchar* to, const uchar *from,
 
420
                                        uint max_length, bool low_byte_first)
 
421
  {
 
422
    return pack(to, from, max_length, low_byte_first);
 
423
  }
 
424
  virtual const uchar *unpack_key(uchar* to, const uchar *from,
 
425
                                  uint max_length, bool low_byte_first)
488
426
  {
489
427
    return unpack(to, from, max_length, low_byte_first);
490
428
  }
491
 
  virtual uint32_t packed_col_length(const unsigned char *to __attribute__((unused)),
492
 
                                 uint32_t length)
 
429
  virtual uint packed_col_length(const uchar *to __attribute__((unused)),
 
430
                                 uint length)
493
431
  { return length;}
494
 
  virtual uint32_t max_packed_col_length(uint32_t max_length)
 
432
  virtual uint max_packed_col_length(uint max_length)
495
433
  { return max_length;}
496
434
 
497
 
  virtual int pack_cmp(const unsigned char *a,const unsigned char *b,
498
 
                       uint32_t key_length_arg __attribute__((unused)),
 
435
  virtual int pack_cmp(const uchar *a,const uchar *b,
 
436
                       uint key_length_arg __attribute__((unused)),
499
437
                       bool insert_or_update __attribute__((unused)))
500
438
  { return cmp(a,b); }
501
 
  virtual int pack_cmp(const unsigned char *b,
502
 
                       uint32_t key_length_arg __attribute__((unused)),
 
439
  virtual int pack_cmp(const uchar *b,
 
440
                       uint key_length_arg __attribute__((unused)),
503
441
                       bool insert_or_update __attribute__((unused)))
504
442
  { return cmp(ptr,b); }
505
 
  uint32_t offset(unsigned char *record)
 
443
  uint offset(uchar *record)
506
444
  {
507
 
    return (uint32_t) (ptr - record);
 
445
    return (uint) (ptr - record);
508
446
  }
509
447
  void copy_from_tmp(int offset);
510
 
  uint32_t fill_cache_field(struct st_cache_field *copy);
511
 
  virtual bool get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate);
 
448
  uint fill_cache_field(struct st_cache_field *copy);
 
449
  virtual bool get_date(DRIZZLE_TIME *ltime,uint fuzzydate);
512
450
  virtual bool get_time(DRIZZLE_TIME *ltime);
513
451
  virtual const CHARSET_INFO *charset(void) const { return &my_charset_bin; }
514
452
  virtual const CHARSET_INFO *sort_charset(void) const { return charset(); }
521
459
  { }
522
460
  bool set_warning(DRIZZLE_ERROR::enum_warning_level, unsigned int code,
523
461
                   int cuted_increment);
524
 
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level, uint32_t code, 
525
 
                            const char *str, uint32_t str_len,
526
 
                            enum enum_drizzle_timestamp_type ts_type, int cuted_increment);
527
 
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level, uint32_t code, 
528
 
                            int64_t nr, enum enum_drizzle_timestamp_type ts_type,
 
462
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level, uint code, 
 
463
                            const char *str, uint str_len,
 
464
                            timestamp_type ts_type, int cuted_increment);
 
465
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level, uint code, 
 
466
                            int64_t nr, timestamp_type ts_type,
529
467
                            int cuted_increment);
530
 
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level, const uint32_t code, 
531
 
                            double nr, enum enum_drizzle_timestamp_type ts_type);
 
468
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level, const uint code, 
 
469
                            double nr, timestamp_type ts_type);
532
470
  inline bool check_overflow(int op_result)
533
471
  {
534
472
    return (op_result == E_DEC_OVERFLOW);
543
481
  /* maximum possible display length */
544
482
  virtual uint32_t max_display_length()= 0;
545
483
 
546
 
  virtual uint32_t is_equal(Create_field *new_field);
 
484
  virtual uint is_equal(Create_field *new_field);
547
485
  /* convert decimal to int64_t with overflow check */
548
486
  int64_t convert_decimal2int64_t(const my_decimal *val, bool unsigned_flag,
549
487
                                    int *err);
561
499
 
562
500
  /* Hash value */
563
501
  virtual void hash(uint32_t *nr, uint32_t *nr2);
564
 
  friend bool reopen_table(Session *,Table *,bool);
565
 
  friend int cre_myisam(char * name, register Table *form, uint32_t options,
 
502
  friend bool reopen_table(THD *,Table *,bool);
 
503
  friend int cre_myisam(char * name, register Table *form, uint options,
566
504
                        uint64_t auto_increment_value);
567
505
  friend class Copy_field;
568
506
  friend class Item_avg_field;
601
539
 
602
540
   @returns 0 no bytes written.
603
541
*/
604
 
  virtual int do_save_field_metadata(unsigned char *metadata_ptr __attribute__((unused)))
605
 
  { return 0; }
 
542
  virtual int do_save_field_metadata(uchar *metadata_ptr __attribute__((unused)))
 
543
  { return 0; }
 
544
};
 
545
 
 
546
 
 
547
class Field_num :public Field {
 
548
public:
 
549
  const uint8_t dec;
 
550
  bool decimal_precision;       // Purify cannot handle bit fields & only for decimal type
 
551
  bool unsigned_flag;   // Purify cannot handle bit fields
 
552
  Field_num(uchar *ptr_arg,uint32_t len_arg, uchar *null_ptr_arg,
 
553
            uchar null_bit_arg, utype unireg_check_arg,
 
554
            const char *field_name_arg,
 
555
            uint8_t dec_arg, bool zero_arg, bool unsigned_arg);
 
556
  Item_result result_type () const { return REAL_RESULT; }
 
557
  void add_unsigned(String &res) const;
 
558
  friend class Create_field;
 
559
  void make_field(Send_field *);
 
560
  uint decimals() const { return (uint) dec; }
 
561
  uint size_of() const { return sizeof(*this); }
 
562
  bool eq_def(Field *field);
 
563
  int store_decimal(const my_decimal *);
 
564
  my_decimal *val_decimal(my_decimal *);
 
565
  uint is_equal(Create_field *new_field);
 
566
  int check_int(const CHARSET_INFO * const cs, const char *str, int length,
 
567
                const char *int_end, int error);
 
568
  bool get_int(const CHARSET_INFO * const cs, const char *from, uint len, 
 
569
               int64_t *rnd, uint64_t unsigned_max, 
 
570
               int64_t signed_min, int64_t signed_max);
 
571
};
 
572
 
 
573
/* base class for all string related classes */
 
574
 
 
575
class Field_str :public Field {
 
576
protected:
 
577
  const CHARSET_INFO *field_charset;
 
578
  enum Derivation field_derivation;
 
579
public:
 
580
  Field_str(uchar *ptr_arg,uint32_t len_arg, uchar *null_ptr_arg,
 
581
            uchar null_bit_arg, utype unireg_check_arg,
 
582
            const char *field_name_arg, const CHARSET_INFO * const charset);
 
583
  Item_result result_type () const { return STRING_RESULT; }
 
584
  uint decimals() const { return NOT_FIXED_DEC; }
 
585
  int  store(double nr);
 
586
  int  store(int64_t nr, bool unsigned_val)=0;
 
587
  int  store_decimal(const my_decimal *);
 
588
  int  store(const char *to,uint length, const CHARSET_INFO * const cs)=0;
 
589
  uint size_of() const { return sizeof(*this); }
 
590
  const CHARSET_INFO *charset(void) const { return field_charset; }
 
591
  void set_charset(const CHARSET_INFO * const charset_arg) { field_charset= charset_arg; }
 
592
  enum Derivation derivation(void) const { return field_derivation; }
 
593
  virtual void set_derivation(enum Derivation derivation_arg)
 
594
  { field_derivation= derivation_arg; }
 
595
  bool binary() const { return field_charset == &my_charset_bin; }
 
596
  uint32_t max_display_length() { return field_length; }
 
597
  friend class Create_field;
 
598
  my_decimal *val_decimal(my_decimal *);
 
599
  virtual bool str_needs_quotes() { return true; }
 
600
  bool compare_str_field_flags(Create_field *new_field, uint32_t flags);
 
601
  uint is_equal(Create_field *new_field);
 
602
};
 
603
 
 
604
 
 
605
/* base class for Field_varstring and Field_blob */
 
606
 
 
607
class Field_longstr :public Field_str
 
608
{
 
609
protected:
 
610
  int report_if_important_data(const char *ptr, const char *end);
 
611
public:
 
612
  Field_longstr(uchar *ptr_arg, uint32_t len_arg, uchar *null_ptr_arg,
 
613
                uchar null_bit_arg, utype unireg_check_arg,
 
614
                const char *field_name_arg, const CHARSET_INFO * const charset_arg)
 
615
    :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, unireg_check_arg,
 
616
               field_name_arg, charset_arg)
 
617
    {}
 
618
 
 
619
  int store_decimal(const my_decimal *d);
 
620
  uint32_t max_data_length() const;
 
621
};
 
622
 
 
623
/* base class for float and double and decimal (old one) */
 
624
class Field_real :public Field_num {
 
625
public:
 
626
  bool not_fixed;
 
627
 
 
628
  Field_real(uchar *ptr_arg, uint32_t len_arg, uchar *null_ptr_arg,
 
629
             uchar null_bit_arg, utype unireg_check_arg,
 
630
             const char *field_name_arg,
 
631
             uint8_t dec_arg, bool zero_arg, bool unsigned_arg)
 
632
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, unireg_check_arg,
 
633
               field_name_arg, dec_arg, zero_arg, unsigned_arg),
 
634
    not_fixed(dec_arg >= NOT_FIXED_DEC)
 
635
    {}
 
636
  int store_decimal(const my_decimal *);
 
637
  my_decimal *val_decimal(my_decimal *);
 
638
  int truncate(double *nr, double max_length);
 
639
  uint32_t max_display_length() { return field_length; }
 
640
  uint size_of() const { return sizeof(*this); }
 
641
  virtual const uchar *unpack(uchar* to, const uchar *from,
 
642
                              uint param_data, bool low_byte_first);
 
643
  virtual uchar *pack(uchar* to, const uchar *from,
 
644
                      uint max_length, bool low_byte_first);
 
645
};
 
646
 
 
647
 
 
648
class Field_tiny :public Field_num {
 
649
public:
 
650
  Field_tiny(uchar *ptr_arg, uint32_t len_arg, uchar *null_ptr_arg,
 
651
             uchar null_bit_arg,
 
652
             enum utype unireg_check_arg, const char *field_name_arg,
 
653
             bool zero_arg, bool unsigned_arg)
 
654
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 
655
               unireg_check_arg, field_name_arg,
 
656
               0, zero_arg,unsigned_arg)
 
657
    {}
 
658
  enum Item_result result_type () const { return INT_RESULT; }
 
659
  enum_field_types type() const { return DRIZZLE_TYPE_TINY;}
 
660
  enum ha_base_keytype key_type() const
 
661
    { return unsigned_flag ? HA_KEYTYPE_BINARY : HA_KEYTYPE_INT8; }
 
662
  int store(const char *to,uint length, const CHARSET_INFO * const charset);
 
663
  int store(double nr);
 
664
  int store(int64_t nr, bool unsigned_val);
 
665
  int reset(void) { ptr[0]=0; return 0; }
 
666
  double val_real(void);
 
667
  int64_t val_int(void);
 
668
  String *val_str(String*,String *);
 
669
  bool send_binary(Protocol *protocol);
 
670
  int cmp(const uchar *,const uchar *);
 
671
  void sort_string(uchar *buff,uint length);
 
672
  uint32_t pack_length() const { return 1; }
 
673
  void sql_type(String &str) const;
 
674
  uint32_t max_display_length() { return 4; }
 
675
 
 
676
  virtual uchar *pack(uchar* to, const uchar *from,
 
677
                      uint max_length __attribute__((unused)),
 
678
                      bool low_byte_first __attribute__((unused)))
 
679
  {
 
680
    *to= *from;
 
681
    return to + 1;
 
682
  }
 
683
 
 
684
  virtual const uchar *unpack(uchar* to, const uchar *from,
 
685
                              uint param_data __attribute__((unused)),
 
686
                              bool low_byte_first __attribute__((unused)))
 
687
  {
 
688
    *to= *from;
 
689
    return from + 1;
 
690
  }
 
691
};
 
692
 
 
693
 
 
694
class Field_enum :public Field_str {
 
695
protected:
 
696
  uint packlength;
 
697
public:
 
698
  TYPELIB *typelib;
 
699
  Field_enum(uchar *ptr_arg, uint32_t len_arg, uchar *null_ptr_arg,
 
700
             uchar null_bit_arg,
 
701
             enum utype unireg_check_arg, const char *field_name_arg,
 
702
             uint packlength_arg,
 
703
             TYPELIB *typelib_arg,
 
704
             const CHARSET_INFO * const charset_arg)
 
705
    :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 
706
               unireg_check_arg, field_name_arg, charset_arg),
 
707
    packlength(packlength_arg),typelib(typelib_arg)
 
708
  {
 
709
      flags|=ENUM_FLAG;
 
710
  }
 
711
  Field *new_field(MEM_ROOT *root, Table *new_table, bool keep_type);
 
712
  enum_field_types type() const { return DRIZZLE_TYPE_ENUM; }
 
713
  enum Item_result cmp_type () const { return INT_RESULT; }
 
714
  enum Item_result cast_to_int_type () const { return INT_RESULT; }
 
715
  enum ha_base_keytype key_type() const;
 
716
  int  store(const char *to,uint length, const CHARSET_INFO * const charset);
 
717
  int  store(double nr);
 
718
  int  store(int64_t nr, bool unsigned_val);
 
719
  double val_real(void);
 
720
  int64_t val_int(void);
 
721
  String *val_str(String*,String *);
 
722
  int cmp(const uchar *,const uchar *);
 
723
  void sort_string(uchar *buff,uint length);
 
724
  uint32_t pack_length() const { return (uint32_t) packlength; }
 
725
  void store_type(uint64_t value);
 
726
  void sql_type(String &str) const;
 
727
  uint size_of() const { return sizeof(*this); }
 
728
  enum_field_types real_type() const { return DRIZZLE_TYPE_ENUM; }
 
729
  uint pack_length_from_metadata(uint field_metadata)
 
730
  { return (field_metadata & 0x00ff); }
 
731
  uint row_pack_length() { return pack_length(); }
 
732
  virtual bool zero_pack() const { return 0; }
 
733
  bool optimize_range(uint idx __attribute__((unused)),
 
734
                      uint part __attribute__((unused)))
 
735
  { return 0; }
 
736
  bool eq_def(Field *field);
 
737
  bool has_charset(void) const { return true; }
 
738
  /* enum and set are sorted as integers */
 
739
  const CHARSET_INFO *sort_charset(void) const { return &my_charset_bin; }
 
740
private:
 
741
  int do_save_field_metadata(uchar *first_byte);
606
742
};
607
743
 
608
744
/*
628
764
    for most of the types, or of bytes for BLOBs or numeric types.
629
765
  */
630
766
  uint32_t char_length;
631
 
  uint32_t  decimals, flags, pack_length, key_length;
 
767
  uint  decimals, flags, pack_length, key_length;
632
768
  Field::utype unireg_check;
633
769
  TYPELIB *interval;                    // Which interval to use
634
770
  TYPELIB *save_interval;               // Temporary copy for the above
638
774
  Field *field;                         // For alter table
639
775
 
640
776
  uint8_t row,col,sc_length,interval_id;        // For rea_create_table
641
 
  uint32_t      offset,pack_flag;
642
 
 
643
 
  /* Virtual column expression statement */
644
 
  virtual_column_info *vcol_info;
645
 
  /*
646
 
    Indication that the field is phycically stored in tables 
647
 
    rather than just generated on SQL queries.
648
 
    As of now, FALSE can only be set for generated-only virtual columns.
649
 
  */
650
 
  bool is_stored;
651
 
 
 
777
  uint  offset,pack_flag;
652
778
  Create_field() :after(0) {}
653
779
  Create_field(Field *field, Field *orig_field);
654
780
  /* Used to make a clone of this object for ALTER/CREATE TABLE */
667
793
                          uint32_t max_length, uint32_t decimals,
668
794
                          bool maybe_null, bool is_unsigned);
669
795
 
670
 
  bool init(Session *session, char *field_name, enum_field_types type, char *length,
671
 
            char *decimals, uint32_t type_modifier, Item *default_value,
 
796
  bool init(THD *thd, char *field_name, enum_field_types type, char *length,
 
797
            char *decimals, uint type_modifier, Item *default_value,
672
798
            Item *on_update_value, LEX_STRING *comment, char *change,
673
799
            List<String> *interval_list, const CHARSET_INFO * const cs,
674
 
            uint32_t uint_geom_type,
675
 
            enum column_format_type column_format,
676
 
            virtual_column_info *vcol_info);
 
800
            uint uint_geom_type,
 
801
            enum column_format_type column_format);
677
802
};
678
803
 
679
804
 
687
812
  const char *table_name,*org_table_name;
688
813
  const char *col_name,*org_col_name;
689
814
  uint32_t length;
690
 
  uint32_t charsetnr, flags, decimals;
 
815
  uint charsetnr, flags, decimals;
691
816
  enum_field_types type;
692
817
  Send_field() {}
693
818
};
705
830
  typedef void Copy_func(Copy_field*);
706
831
  Copy_func *get_copy_func(Field *to, Field *from);
707
832
public:
708
 
  unsigned char *from_ptr,*to_ptr;
709
 
  unsigned char *from_null_ptr,*to_null_ptr;
 
833
  uchar *from_ptr,*to_ptr;
 
834
  uchar *from_null_ptr,*to_null_ptr;
710
835
  bool *null_row;
711
 
  uint32_t      from_bit,to_bit;
712
 
  uint32_t from_length,to_length;
 
836
  uint  from_bit,to_bit;
 
837
  uint from_length,to_length;
713
838
  Field *from_field,*to_field;
714
839
  String tmp;                                   // For items
715
840
 
716
841
  Copy_field() {}
717
842
  ~Copy_field() {}
718
843
  void set(Field *to,Field *from,bool save);    // Field to field 
719
 
  void set(unsigned char *to,Field *from);              // Field to string
 
844
  void set(uchar *to,Field *from);              // Field to string
720
845
  void (*do_copy)(Copy_field *);
721
846
  void (*do_copy2)(Copy_field *);               // Used to handle null values
722
847
};
723
848
 
724
849
 
725
 
Field *make_field(TABLE_SHARE *share, unsigned char *ptr, uint32_t field_length,
726
 
                  unsigned char *null_pos, unsigned char null_bit,
727
 
                  uint32_t pack_flag, enum_field_types field_type,
 
850
Field *make_field(TABLE_SHARE *share, uchar *ptr, uint32_t field_length,
 
851
                  uchar *null_pos, uchar null_bit,
 
852
                  uint pack_flag, enum_field_types field_type,
728
853
                  const CHARSET_INFO * cs,
729
854
                  Field::utype unireg_check,
730
855
                  TYPELIB *interval, const char *field_name);
731
 
uint32_t pack_length_to_packflag(uint32_t type);
 
856
uint pack_length_to_packflag(uint type);
732
857
enum_field_types get_blob_type_from_length(uint32_t length);
733
858
uint32_t calc_pack_length(enum_field_types type,uint32_t length);
734
859
int set_field_to_null(Field *field);
735
860
int set_field_to_null_with_conversions(Field *field, bool no_conversions);
736
861
 
737
 
 
738
862
bool
739
 
test_if_important_data(const CHARSET_INFO * const cs, 
740
 
                       const char *str,
741
 
                       const char *strend);
 
863
check_string_copy_error(Field_str *field,
 
864
                        const char *well_formed_error_pos,
 
865
                        const char *cannot_convert_error_pos,
 
866
                        const char *end,
 
867
                        const CHARSET_INFO * const cs);
742
868
 
743
869
/*
744
870
  Field subclasses
745
871
 */
746
 
#include <drizzled/field/str.h>
747
 
#include <drizzled/field/longstr.h>
748
 
#include <drizzled/field/num.h>
749
872
#include <drizzled/field/blob.h>
750
 
#include <drizzled/field/enum.h>
751
873
#include <drizzled/field/null.h>
752
874
#include <drizzled/field/date.h>
753
875
#include <drizzled/field/fdecimal.h>
754
 
#include <drizzled/field/real.h>
755
876
#include <drizzled/field/double.h>
 
877
#include <drizzled/field/short.h>
756
878
#include <drizzled/field/long.h>
757
879
#include <drizzled/field/int64_t.h>
758
 
#include <drizzled/field/num.h>
759
880
#include <drizzled/field/timetype.h>
760
881
#include <drizzled/field/timestamp.h>
761
882
#include <drizzled/field/datetime.h>
772
893
#define FIELDFLAG_DECIMAL_POSITION      4
773
894
#define FIELDFLAG_PACK                  120     // Bits used for packing
774
895
#define FIELDFLAG_INTERVAL              256     // mangled with decimals!
 
896
#define FIELDFLAG_BITFIELD              512     // mangled with decimals!
775
897
#define FIELDFLAG_BLOB                  1024    // mangled with decimals!
776
 
 
 
898
#define FIELDFLAG_GEOM                  2048    // mangled with decimals!
 
899
 
 
900
#define FIELDFLAG_TREAT_BIT_AS_CHAR     4096    /* use Field_bit_as_char */
 
901
 
 
902
#define FIELDFLAG_LEFT_FULLSCREEN       8192
 
903
#define FIELDFLAG_RIGHT_FULLSCREEN      16384
 
904
#define FIELDFLAG_FORMAT_NUMBER         16384   // predit: ###,,## in output
777
905
#define FIELDFLAG_NO_DEFAULT            16384   /* sql */
778
 
#define FIELDFLAG_SUM                   ((uint32_t) 32768)// predit: +#fieldflag
779
 
#define FIELDFLAG_MAYBE_NULL            ((uint32_t) 32768)// sql
780
 
#define FIELDFLAG_HEX_ESCAPE            ((uint32_t) 0x10000)
 
906
#define FIELDFLAG_SUM                   ((uint) 32768)// predit: +#fieldflag
 
907
#define FIELDFLAG_MAYBE_NULL            ((uint) 32768)// sql
 
908
#define FIELDFLAG_HEX_ESCAPE            ((uint) 0x10000)
781
909
#define FIELDFLAG_PACK_SHIFT            3
782
910
#define FIELDFLAG_DEC_SHIFT             8
783
911
#define FIELDFLAG_MAX_DEC               31
 
912
#define FIELDFLAG_NUM_SCREEN_TYPE       0x7F01
 
913
#define FIELDFLAG_ALFA_SCREEN_TYPE      0x7800
784
914
 
785
915
#define MTYP_TYPENR(type) (type & 127)  /* Remove bits from type */
786
916
 
793
923
#define f_is_alpha(x)           (!f_is_num(x))
794
924
#define f_is_binary(x)          ((x) & FIELDFLAG_BINARY) // 4.0- compatibility
795
925
#define f_is_enum(x)            (((x) & (FIELDFLAG_INTERVAL | FIELDFLAG_NUMBER)) == FIELDFLAG_INTERVAL)
 
926
#define f_is_bitfield(x)        (((x) & (FIELDFLAG_BITFIELD | FIELDFLAG_NUMBER)) == FIELDFLAG_BITFIELD)
796
927
#define f_is_blob(x)            (((x) & (FIELDFLAG_BLOB | FIELDFLAG_NUMBER)) == FIELDFLAG_BLOB)
797
928
#define f_is_equ(x)             ((x) & (1+2+FIELDFLAG_PACK+31*256))
798
 
#define f_settype(x)   (((int) x) << FIELDFLAG_PACK_SHIFT)
 
929
#define f_settype(x)            (((int) x) << FIELDFLAG_PACK_SHIFT)
799
930
#define f_maybe_null(x)         (x & FIELDFLAG_MAYBE_NULL)
800
931
#define f_no_default(x)         (x & FIELDFLAG_NO_DEFAULT)
 
932
#define f_bit_as_char(x)        ((x) & FIELDFLAG_TREAT_BIT_AS_CHAR)
801
933
#define f_is_hex_escape(x)      ((x) & FIELDFLAG_HEX_ESCAPE)
802
934
 
803
 
bool
804
 
check_string_copy_error(Field_str *field,
805
 
                        const char *well_formed_error_pos,
806
 
                        const char *cannot_convert_error_pos,
807
 
                        const char *end,
808
 
                        const CHARSET_INFO * const cs);
809
 
 
810
 
#endif /* DRIZZLED_FIELD_H */