← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.h

Merged build changes from Antony.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field.h
24
24
#endif
25
25
 
26
26
#define DATETIME_DEC                     6
27
 
const uint32 max_field_size= (uint32) 4294967295U;
 
27
#define DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE FLOATING_POINT_BUFFER
 
28
 
 
29
const uint32_t max_field_size= (uint32_t) 4294967295U;
28
30
 
29
31
class Send_field;
30
32
class Protocol;
49
51
  void operator=(Field &);
50
52
public:
51
53
  static void *operator new(size_t size) {return sql_alloc(size); }
52
 
  static void operator delete(void *ptr_arg __attribute__((__unused__)),
53
 
                              size_t size __attribute__((__unused__)))
 
54
  static void operator delete(void *ptr_arg __attribute__((unused)),
 
55
                              size_t size __attribute__((unused)))
54
56
  { TRASH(ptr_arg, size); }
55
57
 
56
58
  uchar         *ptr;                   // Position to field in record
81
83
  enum imagetype { itRAW, itMBR};
82
84
 
83
85
  utype         unireg_check;
84
 
  uint32        field_length;           // Length of field
85
 
  uint32        flags;
86
 
  uint16        field_index;            // field number in fields array
 
86
  uint32_t      field_length;           // Length of field
 
87
  uint32_t      flags;
 
88
  uint16_t        field_index;            // field number in fields array
87
89
  uchar         null_bit;               // Bit used to test null bit
88
90
  /**
89
91
     If true, this field was created in create_tmp_field_from_item from a NULL
96
98
   */
97
99
  bool is_created_from_null_item;
98
100
 
99
 
  Field(uchar *ptr_arg,uint32 length_arg,uchar *null_ptr_arg,
 
101
  Field(uchar *ptr_arg,uint32_t length_arg,uchar *null_ptr_arg,
100
102
        uchar null_bit_arg, utype unireg_check_arg,
101
103
        const char *field_name_arg);
102
104
  virtual ~Field() {}
149
151
    (i.e. it returns the maximum size of the field in a row of the table,
150
152
    which is located in RAM).
151
153
  */
152
 
  virtual uint32 pack_length() const { return (uint32) field_length; }
 
154
  virtual uint32_t pack_length() const { return (uint32_t) field_length; }
153
155
 
154
156
  /*
155
157
    pack_length_in_rec() returns size (in bytes) used to store field data on
156
158
    storage (i.e. it returns the maximal size of the field in a row of the
157
159
    table, which is located on disk).
158
160
  */
159
 
  virtual uint32 pack_length_in_rec() const { return pack_length(); }
 
161
  virtual uint32_t pack_length_in_rec() const { return pack_length(); }
160
162
  virtual int compatible_field_size(uint field_metadata);
161
163
  virtual uint pack_length_from_metadata(uint field_metadata)
162
164
  { return field_metadata; }
180
182
    data_length() return the "real size" of the data in memory.
181
183
    For varstrings, this does _not_ include the length bytes.
182
184
  */
183
 
  virtual uint32 data_length() { return pack_length(); }
 
185
  virtual uint32_t data_length() { return pack_length(); }
184
186
  /*
185
187
    used_length() returns the number of bytes actually used to store the data
186
188
    of the field. So for a varstring it includes both lenght byte(s) and
187
189
    string data, and anything after data_length() bytes are unused.
188
190
  */
189
 
  virtual uint32 used_length() { return pack_length(); }
190
 
  virtual uint32 sort_length() const { return pack_length(); }
 
191
  virtual uint32_t used_length() { return pack_length(); }
 
192
  virtual uint32_t sort_length() const { return pack_length(); }
191
193
 
192
194
  /**
193
195
     Get the maximum size of the data in packed format.
195
197
     @return Maximum data length of the field when packed using the
196
198
     Field::pack() function.
197
199
   */
198
 
  virtual uint32 max_data_length() const {
 
200
  virtual uint32_t max_data_length() const {
199
201
    return pack_length();
200
202
  };
201
203
 
202
 
  virtual int reset(void) { bzero(ptr,pack_length()); return 0; }
 
204
  virtual int reset(void) { memset(ptr, 0, pack_length()); return 0; }
203
205
  virtual void reset_fields() {}
204
206
  virtual void set_default()
205
207
  {
211
213
  virtual bool binary() const { return 1; }
212
214
  virtual bool zero_pack() const { return 1; }
213
215
  virtual enum ha_base_keytype key_type() const { return HA_KEYTYPE_BINARY; }
214
 
  virtual uint32 key_length() const { return pack_length(); }
 
216
  virtual uint32_t key_length() const { return pack_length(); }
215
217
  virtual enum_field_types type() const =0;
216
218
  virtual enum_field_types real_type() const { return type(); }
217
219
  inline  int cmp(const uchar *str) { return cmp(ptr,str); }
218
220
  virtual int cmp_max(const uchar *a, const uchar *b,
219
 
                      uint max_len __attribute__((__unused__)))
 
221
                      uint max_len __attribute__((unused)))
220
222
    { return cmp(a, b); }
221
223
  virtual int cmp(const uchar *,const uchar *)=0;
222
224
  virtual int cmp_binary(const uchar *a,const uchar *b,
223
 
                         uint32  __attribute__((__unused__)) max_length=~0)
 
225
                         uint32_t  __attribute__((unused)) max_length=~0)
224
226
  { return memcmp(a,b,pack_length()); }
225
227
  virtual int cmp_offset(uint row_offset)
226
228
  { return cmp(ptr,ptr+row_offset); }
228
230
  { return cmp_binary(ptr, ptr+row_offset); };
229
231
  virtual int key_cmp(const uchar *a,const uchar *b)
230
232
  { return cmp(a, b); }
231
 
  virtual int key_cmp(const uchar *str, uint length __attribute__((__unused__)))
 
233
  virtual int key_cmp(const uchar *str, uint length __attribute__((unused)))
232
234
  { return cmp(ptr,str); }
233
235
  virtual uint decimals() const { return 0; }
234
236
  /*
317
319
      null_ptr=ADD_TO_PTR(null_ptr,ptr_diff,uchar*);
318
320
  }
319
321
  virtual void get_image(uchar *buff, uint length,
320
 
                         CHARSET_INFO *cs __attribute__((__unused__)))
 
322
                         CHARSET_INFO *cs __attribute__((unused)))
321
323
    { memcpy(buff,ptr,length); }
322
324
  virtual void set_image(const uchar *buff,uint length,
323
 
                         CHARSET_INFO *cs __attribute__((__unused__)))
 
325
                         CHARSET_INFO *cs __attribute__((unused)))
324
326
    { memcpy(ptr,buff,length); }
325
327
 
326
328
 
351
353
  */
352
354
 
353
355
  virtual uint get_key_image(uchar *buff, uint length,
354
 
                             imagetype type __attribute__((__unused__)))
 
356
                             imagetype type __attribute__((unused)))
355
357
  {
356
358
    get_image(buff, length, &my_charset_bin);
357
359
    return length;
421
423
  {
422
424
    return unpack(to, from, max_length, low_byte_first);
423
425
  }
424
 
  virtual uint packed_col_length(const uchar *to __attribute__((__unused__)),
 
426
  virtual uint packed_col_length(const uchar *to __attribute__((unused)),
425
427
                                 uint length)
426
428
  { return length;}
427
429
  virtual uint max_packed_col_length(uint max_length)
428
430
  { return max_length;}
429
431
 
430
432
  virtual int pack_cmp(const uchar *a,const uchar *b,
431
 
                       uint key_length_arg __attribute__((__unused__)),
432
 
                       my_bool insert_or_update __attribute__((__unused__)))
 
433
                       uint key_length_arg __attribute__((unused)),
 
434
                       my_bool insert_or_update __attribute__((unused)))
433
435
  { return cmp(a,b); }
434
436
  virtual int pack_cmp(const uchar *b,
435
 
                       uint key_length_arg __attribute__((__unused__)),
436
 
                       my_bool insert_or_update __attribute__((__unused__)))
 
437
                       uint key_length_arg __attribute__((unused)),
 
438
                       my_bool insert_or_update __attribute__((unused)))
437
439
  { return cmp(ptr,b); }
438
440
  uint offset(uchar *record)
439
441
  {
446
448
  virtual CHARSET_INFO *charset(void) const { return &my_charset_bin; }
447
449
  virtual CHARSET_INFO *sort_charset(void) const { return charset(); }
448
450
  virtual bool has_charset(void) const { return false; }
449
 
  virtual void set_charset(CHARSET_INFO *charset_arg __attribute__((__unused__)))
 
451
  virtual void set_charset(CHARSET_INFO *charset_arg __attribute__((unused)))
450
452
  { }
451
453
  virtual enum Derivation derivation(void) const
452
454
  { return DERIVATION_IMPLICIT; }
453
 
  virtual void set_derivation(enum Derivation derivation_arg __attribute__((__unused__)))
 
455
  virtual void set_derivation(enum Derivation derivation_arg __attribute__((unused)))
454
456
  { }
455
457
  bool set_warning(MYSQL_ERROR::enum_warning_level, unsigned int code,
456
458
                   int cuted_increment);
474
476
  }
475
477
 
476
478
  /* maximum possible display length */
477
 
  virtual uint32 max_display_length()= 0;
 
479
  virtual uint32_t max_display_length()= 0;
478
480
 
479
481
  virtual uint is_equal(Create_field *new_field);
480
482
  /* convert decimal to int64_t with overflow check */
481
483
  int64_t convert_decimal2int64_t(const my_decimal *val, bool unsigned_flag,
482
484
                                    int *err);
483
485
  /* The max. number of characters */
484
 
  inline uint32 char_length() const
 
486
  inline uint32_t char_length() const
485
487
  {
486
488
    return field_length / charset()->mbmaxlen;
487
489
  }
534
536
 
535
537
   @returns 0 no bytes written.
536
538
*/
537
 
  virtual int do_save_field_metadata(uchar *metadata_ptr __attribute__((__unused__)))
 
539
  virtual int do_save_field_metadata(uchar *metadata_ptr __attribute__((unused)))
538
540
  { return 0; }
539
541
};
540
542
 
541
543
 
542
544
class Field_num :public Field {
543
545
public:
544
 
  const uint8 dec;
545
 
  bool zerofill,unsigned_flag;  // Purify cannot handle bit fields
546
 
  Field_num(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
 
546
  const uint8_t dec;
 
547
  bool decimal_precision;       // Purify cannot handle bit fields & only for decimal type
 
548
  bool unsigned_flag;   // Purify cannot handle bit fields
 
549
  Field_num(uchar *ptr_arg,uint32_t len_arg, uchar *null_ptr_arg,
547
550
            uchar null_bit_arg, utype unireg_check_arg,
548
551
            const char *field_name_arg,
549
 
            uint8 dec_arg, bool zero_arg, bool unsigned_arg);
 
552
            uint8_t dec_arg, bool zero_arg, bool unsigned_arg);
550
553
  Item_result result_type () const { return REAL_RESULT; }
551
 
  void prepend_zeros(String *value);
552
 
  void add_zerofill_and_unsigned(String &res) const;
 
554
  void add_unsigned(String &res) const;
553
555
  friend class Create_field;
554
556
  void make_field(Send_field *);
555
557
  uint decimals() const { return (uint) dec; }
565
567
               int64_t signed_min, int64_t signed_max);
566
568
};
567
569
 
 
570
/* base class for all string related classes */
568
571
 
569
572
class Field_str :public Field {
570
573
protected:
571
574
  CHARSET_INFO *field_charset;
572
575
  enum Derivation field_derivation;
573
576
public:
574
 
  Field_str(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
 
577
  Field_str(uchar *ptr_arg,uint32_t len_arg, uchar *null_ptr_arg,
575
578
            uchar null_bit_arg, utype unireg_check_arg,
576
579
            const char *field_name_arg, CHARSET_INFO *charset);
577
580
  Item_result result_type () const { return STRING_RESULT; }
587
590
  virtual void set_derivation(enum Derivation derivation_arg)
588
591
  { field_derivation= derivation_arg; }
589
592
  bool binary() const { return field_charset == &my_charset_bin; }
590
 
  uint32 max_display_length() { return field_length; }
 
593
  uint32_t max_display_length() { return field_length; }
591
594
  friend class Create_field;
592
595
  my_decimal *val_decimal(my_decimal *);
593
596
  virtual bool str_needs_quotes() { return true; }
594
 
  bool compare_str_field_flags(Create_field *new_field, uint32 flags);
 
597
  bool compare_str_field_flags(Create_field *new_field, uint32_t flags);
595
598
  uint is_equal(Create_field *new_field);
596
599
};
597
600
 
603
606
protected:
604
607
  int report_if_important_data(const char *ptr, const char *end);
605
608
public:
606
 
  Field_longstr(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 
609
  Field_longstr(uchar *ptr_arg, uint32_t len_arg, uchar *null_ptr_arg,
607
610
                uchar null_bit_arg, utype unireg_check_arg,
608
611
                const char *field_name_arg, CHARSET_INFO *charset_arg)
609
612
    :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, unireg_check_arg,
611
614
    {}
612
615
 
613
616
  int store_decimal(const my_decimal *d);
614
 
  uint32 max_data_length() const;
 
617
  uint32_t max_data_length() const;
615
618
};
616
619
 
617
620
/* base class for float and double and decimal (old one) */
619
622
public:
620
623
  my_bool not_fixed;
621
624
 
622
 
  Field_real(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 
625
  Field_real(uchar *ptr_arg, uint32_t len_arg, uchar *null_ptr_arg,
623
626
             uchar null_bit_arg, utype unireg_check_arg,
624
627
             const char *field_name_arg,
625
 
             uint8 dec_arg, bool zero_arg, bool unsigned_arg)
 
628
             uint8_t dec_arg, bool zero_arg, bool unsigned_arg)
626
629
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, unireg_check_arg,
627
630
               field_name_arg, dec_arg, zero_arg, unsigned_arg),
628
631
    not_fixed(dec_arg >= NOT_FIXED_DEC)
630
633
  int store_decimal(const my_decimal *);
631
634
  my_decimal *val_decimal(my_decimal *);
632
635
  int truncate(double *nr, double max_length);
633
 
  uint32 max_display_length() { return field_length; }
 
636
  uint32_t max_display_length() { return field_length; }
634
637
  uint size_of() const { return sizeof(*this); }
635
638
  virtual const uchar *unpack(uchar* to, const uchar *from,
636
639
                              uint param_data, bool low_byte_first);
639
642
};
640
643
 
641
644
 
642
 
/* New decimal/numeric field which use fixed point arithmetic */
643
 
class Field_new_decimal :public Field_num {
644
 
private:
645
 
  int do_save_field_metadata(uchar *first_byte);
646
 
public:
647
 
  /* The maximum number of decimal digits can be stored */
648
 
  uint precision;
649
 
  uint bin_size;
650
 
  /*
651
 
    Constructors take max_length of the field as a parameter - not the
652
 
    precision as the number of decimal digits allowed.
653
 
    So for example we need to count length from precision handling
654
 
    CREATE TABLE ( DECIMAL(x,y)) 
655
 
  */
656
 
  Field_new_decimal(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
657
 
                    uchar null_bit_arg,
658
 
                    enum utype unireg_check_arg, const char *field_name_arg,
659
 
                    uint8 dec_arg, bool zero_arg, bool unsigned_arg);
660
 
  Field_new_decimal(uint32 len_arg, bool maybe_null_arg,
661
 
                    const char *field_name_arg, uint8 dec_arg,
662
 
                    bool unsigned_arg);
663
 
  enum_field_types type() const { return MYSQL_TYPE_NEWDECIMAL;}
664
 
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_BINARY; }
665
 
  Item_result result_type () const { return DECIMAL_RESULT; }
666
 
  int  reset(void);
667
 
  bool store_value(const my_decimal *decimal_value);
668
 
  void set_value_on_overflow(my_decimal *decimal_value, bool sign);
669
 
  int  store(const char *to, uint length, CHARSET_INFO *charset);
670
 
  int  store(double nr);
671
 
  int  store(int64_t nr, bool unsigned_val);
672
 
  int store_time(MYSQL_TIME *ltime, timestamp_type t_type);
673
 
  int  store_decimal(const my_decimal *);
674
 
  double val_real(void);
675
 
  int64_t val_int(void);
676
 
  my_decimal *val_decimal(my_decimal *);
677
 
  String *val_str(String*, String *);
678
 
  int cmp(const uchar *, const uchar *);
679
 
  void sort_string(uchar *buff, uint length);
680
 
  bool zero_pack() const { return 0; }
681
 
  void sql_type(String &str) const;
682
 
  uint32 max_display_length() { return field_length; }
683
 
  uint size_of() const { return sizeof(*this); } 
684
 
  uint32 pack_length() const { return (uint32) bin_size; }
685
 
  uint pack_length_from_metadata(uint field_metadata);
686
 
  uint row_pack_length() { return pack_length(); }
687
 
  int compatible_field_size(uint field_metadata);
688
 
  uint is_equal(Create_field *new_field);
689
 
  virtual const uchar *unpack(uchar* to, const uchar *from,
690
 
                              uint param_data, bool low_byte_first);
691
 
};
692
 
 
693
 
 
694
645
class Field_tiny :public Field_num {
695
646
public:
696
 
  Field_tiny(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 
647
  Field_tiny(uchar *ptr_arg, uint32_t len_arg, uchar *null_ptr_arg,
697
648
             uchar null_bit_arg,
698
649
             enum utype unireg_check_arg, const char *field_name_arg,
699
650
             bool zero_arg, bool unsigned_arg)
702
653
               0, zero_arg,unsigned_arg)
703
654
    {}
704
655
  enum Item_result result_type () const { return INT_RESULT; }
705
 
  enum_field_types type() const { return MYSQL_TYPE_TINY;}
 
656
  enum_field_types type() const { return DRIZZLE_TYPE_TINY;}
706
657
  enum ha_base_keytype key_type() const
707
658
    { return unsigned_flag ? HA_KEYTYPE_BINARY : HA_KEYTYPE_INT8; }
708
659
  int store(const char *to,uint length,CHARSET_INFO *charset);
715
666
  bool send_binary(Protocol *protocol);
716
667
  int cmp(const uchar *,const uchar *);
717
668
  void sort_string(uchar *buff,uint length);
718
 
  uint32 pack_length() const { return 1; }
 
669
  uint32_t pack_length() const { return 1; }
719
670
  void sql_type(String &str) const;
720
 
  uint32 max_display_length() { return 4; }
 
671
  uint32_t max_display_length() { return 4; }
721
672
 
722
673
  virtual uchar *pack(uchar* to, const uchar *from,
723
 
                      uint max_length __attribute__((__unused__)),
724
 
                      bool low_byte_first __attribute__((__unused__)))
 
674
                      uint max_length __attribute__((unused)),
 
675
                      bool low_byte_first __attribute__((unused)))
725
676
  {
726
677
    *to= *from;
727
678
    return to + 1;
728
679
  }
729
680
 
730
681
  virtual const uchar *unpack(uchar* to, const uchar *from,
731
 
                              uint param_data __attribute__((__unused__)),
732
 
                              bool low_byte_first __attribute__((__unused__)))
 
682
                              uint param_data __attribute__((unused)),
 
683
                              bool low_byte_first __attribute__((unused)))
733
684
  {
734
685
    *to= *from;
735
686
    return from + 1;
737
688
};
738
689
 
739
690
 
740
 
class Field_short :public Field_num {
741
 
public:
742
 
  Field_short(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
743
 
              uchar null_bit_arg,
744
 
              enum utype unireg_check_arg, const char *field_name_arg,
745
 
              bool zero_arg, bool unsigned_arg)
746
 
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
747
 
               unireg_check_arg, field_name_arg,
748
 
               0, zero_arg,unsigned_arg)
749
 
    {}
750
 
  Field_short(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
751
 
              bool unsigned_arg)
752
 
    :Field_num((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0,0,
753
 
               NONE, field_name_arg, 0, 0, unsigned_arg)
754
 
    {}
755
 
  enum Item_result result_type () const { return INT_RESULT; }
756
 
  enum_field_types type() const { return MYSQL_TYPE_SHORT;}
757
 
  enum ha_base_keytype key_type() const
758
 
    { return unsigned_flag ? HA_KEYTYPE_USHORT_INT : HA_KEYTYPE_SHORT_INT;}
759
 
  int store(const char *to,uint length,CHARSET_INFO *charset);
760
 
  int store(double nr);
761
 
  int store(int64_t nr, bool unsigned_val);
762
 
  int reset(void) { ptr[0]=ptr[1]=0; return 0; }
763
 
  double val_real(void);
764
 
  int64_t val_int(void);
765
 
  String *val_str(String*,String *);
766
 
  bool send_binary(Protocol *protocol);
767
 
  int cmp(const uchar *,const uchar *);
768
 
  void sort_string(uchar *buff,uint length);
769
 
  uint32 pack_length() const { return 2; }
770
 
  void sql_type(String &str) const;
771
 
  uint32 max_display_length() { return 6; }
772
 
 
773
 
  virtual uchar *pack(uchar* to, const uchar *from,
774
 
                      uint max_length __attribute__((__unused__)),
775
 
                      bool low_byte_first __attribute__((__unused__)))
776
 
  {
777
 
    int16 val;
778
 
#ifdef WORDS_BIGENDIAN
779
 
    if (table->s->db_low_byte_first)
780
 
      val = sint2korr(from);
781
 
    else
782
 
#endif
783
 
      shortget(val, from);
784
 
 
785
 
#ifdef WORDS_BIGENDIAN
786
 
    if (low_byte_first)
787
 
      int2store(to, val);
788
 
    else
789
 
#endif
790
 
      shortstore(to, val);
791
 
    return to + sizeof(val);
792
 
  }
793
 
 
794
 
  virtual const uchar *unpack(uchar* to, const uchar *from,
795
 
                              uint param_data __attribute__((__unused__)),
796
 
                              bool low_byte_first __attribute__((__unused__)))
797
 
  {
798
 
    int16 val;
799
 
#ifdef WORDS_BIGENDIAN
800
 
    if (low_byte_first)
801
 
      val = sint2korr(from);
802
 
    else
803
 
#endif
804
 
      shortget(val, from);
805
 
 
806
 
#ifdef WORDS_BIGENDIAN
807
 
    if (table->s->db_low_byte_first)
808
 
      int2store(to, val);
809
 
    else
810
 
#endif
811
 
      shortstore(to, val);
812
 
    return from + sizeof(val);
813
 
  }
814
 
};
815
 
 
816
 
class Field_long :public Field_num {
817
 
public:
818
 
  Field_long(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
819
 
             uchar null_bit_arg,
820
 
             enum utype unireg_check_arg, const char *field_name_arg,
821
 
             bool zero_arg, bool unsigned_arg)
822
 
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
823
 
               unireg_check_arg, field_name_arg,
824
 
               0, zero_arg,unsigned_arg)
825
 
    {}
826
 
  Field_long(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
827
 
             bool unsigned_arg)
828
 
    :Field_num((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0,0,
829
 
               NONE, field_name_arg,0,0,unsigned_arg)
830
 
    {}
831
 
  enum Item_result result_type () const { return INT_RESULT; }
832
 
  enum_field_types type() const { return MYSQL_TYPE_LONG;}
833
 
  enum ha_base_keytype key_type() const
834
 
    { return unsigned_flag ? HA_KEYTYPE_ULONG_INT : HA_KEYTYPE_LONG_INT; }
835
 
  int store(const char *to,uint length,CHARSET_INFO *charset);
836
 
  int store(double nr);
837
 
  int store(int64_t nr, bool unsigned_val);
838
 
  int reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=0; return 0; }
839
 
  double val_real(void);
840
 
  int64_t val_int(void);
841
 
  bool send_binary(Protocol *protocol);
842
 
  String *val_str(String*,String *);
843
 
  int cmp(const uchar *,const uchar *);
844
 
  void sort_string(uchar *buff,uint length);
845
 
  uint32 pack_length() const { return 4; }
846
 
  void sql_type(String &str) const;
847
 
  uint32 max_display_length() { return MY_INT32_NUM_DECIMAL_DIGITS; }
848
 
  virtual uchar *pack(uchar* to, const uchar *from,
849
 
                      uint max_length __attribute__((__unused__)),
850
 
                      bool low_byte_first __attribute__((__unused__)))
851
 
  {
852
 
    int32 val;
853
 
#ifdef WORDS_BIGENDIAN
854
 
    if (table->s->db_low_byte_first)
855
 
      val = sint4korr(from);
856
 
    else
857
 
#endif
858
 
      longget(val, from);
859
 
 
860
 
#ifdef WORDS_BIGENDIAN
861
 
    if (low_byte_first)
862
 
      int4store(to, val);
863
 
    else
864
 
#endif
865
 
      longstore(to, val);
866
 
    return to + sizeof(val);
867
 
  }
868
 
 
869
 
  virtual const uchar *unpack(uchar* to, const uchar *from,
870
 
                              uint param_data __attribute__((__unused__)),
871
 
                              bool low_byte_first __attribute__((__unused__)))
872
 
  {
873
 
    int32 val;
874
 
#ifdef WORDS_BIGENDIAN
875
 
    if (low_byte_first)
876
 
      val = sint4korr(from);
877
 
    else
878
 
#endif
879
 
      longget(val, from);
880
 
 
881
 
#ifdef WORDS_BIGENDIAN
882
 
    if (table->s->db_low_byte_first)
883
 
      int4store(to, val);
884
 
    else
885
 
#endif
886
 
      longstore(to, val);
887
 
    return from + sizeof(val);
888
 
  }
889
 
};
890
 
 
891
 
 
892
 
class Field_int64_t :public Field_num {
893
 
public:
894
 
  Field_int64_t(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
895
 
              uchar null_bit_arg,
896
 
              enum utype unireg_check_arg, const char *field_name_arg,
897
 
              bool zero_arg, bool unsigned_arg)
898
 
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
899
 
               unireg_check_arg, field_name_arg,
900
 
               0, zero_arg,unsigned_arg)
901
 
    {}
902
 
  Field_int64_t(uint32 len_arg,bool maybe_null_arg,
903
 
                 const char *field_name_arg,
904
 
                  bool unsigned_arg)
905
 
    :Field_num((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0,0,
906
 
               NONE, field_name_arg,0,0,unsigned_arg)
907
 
    {}
908
 
  enum Item_result result_type () const { return INT_RESULT; }
909
 
  enum_field_types type() const { return MYSQL_TYPE_LONGLONG;}
910
 
  enum ha_base_keytype key_type() const
911
 
    { return unsigned_flag ? HA_KEYTYPE_ULONGLONG : HA_KEYTYPE_LONGLONG; }
912
 
  int store(const char *to,uint length,CHARSET_INFO *charset);
913
 
  int store(double nr);
914
 
  int store(int64_t nr, bool unsigned_val);
915
 
  int reset(void)
916
 
  {
917
 
    ptr[0]=ptr[1]=ptr[2]=ptr[3]=ptr[4]=ptr[5]=ptr[6]=ptr[7]=0;
918
 
    return 0;
919
 
  }
920
 
  double val_real(void);
921
 
  int64_t val_int(void);
922
 
  String *val_str(String*,String *);
923
 
  bool send_binary(Protocol *protocol);
924
 
  int cmp(const uchar *,const uchar *);
925
 
  void sort_string(uchar *buff,uint length);
926
 
  uint32 pack_length() const { return 8; }
927
 
  void sql_type(String &str) const;
928
 
  bool can_be_compared_as_int64_t() const { return true; }
929
 
  uint32 max_display_length() { return 20; }
930
 
  virtual uchar *pack(uchar* to, const uchar *from,
931
 
                      uint max_length __attribute__((__unused__)),
932
 
                      bool low_byte_first __attribute__((__unused__)))
933
 
  {
934
 
    int64_t val;
935
 
#ifdef WORDS_BIGENDIAN
936
 
    if (table->s->db_low_byte_first)
937
 
      val = sint8korr(from);
938
 
    else
939
 
#endif
940
 
      int64_tget(val, from);
941
 
 
942
 
#ifdef WORDS_BIGENDIAN
943
 
    if (low_byte_first)
944
 
      int8store(to, val);
945
 
    else
946
 
#endif
947
 
      int64_tstore(to, val);
948
 
    return to + sizeof(val);
949
 
  }
950
 
 
951
 
  virtual const uchar *unpack(uchar* to, const uchar *from,
952
 
                              uint param_data __attribute__((__unused__)),
953
 
                              bool low_byte_first __attribute__((__unused__)))
954
 
  {
955
 
    int64_t val;
956
 
#ifdef WORDS_BIGENDIAN
957
 
    if (low_byte_first)
958
 
      val = sint8korr(from);
959
 
    else
960
 
#endif
961
 
      int64_tget(val, from);
962
 
 
963
 
#ifdef WORDS_BIGENDIAN
964
 
    if (table->s->db_low_byte_first)
965
 
      int8store(to, val);
966
 
    else
967
 
#endif
968
 
      int64_tstore(to, val);
969
 
    return from + sizeof(val);
970
 
  }
971
 
};
972
 
 
973
 
class Field_double :public Field_real {
974
 
public:
975
 
  Field_double(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
976
 
               uchar null_bit_arg,
977
 
               enum utype unireg_check_arg, const char *field_name_arg,
978
 
               uint8 dec_arg,bool zero_arg,bool unsigned_arg)
979
 
    :Field_real(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
980
 
                unireg_check_arg, field_name_arg,
981
 
                dec_arg, zero_arg, unsigned_arg)
982
 
    {}
983
 
  Field_double(uint32 len_arg, bool maybe_null_arg, const char *field_name_arg,
984
 
               uint8 dec_arg)
985
 
    :Field_real((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "" : 0, (uint) 0,
986
 
                NONE, field_name_arg, dec_arg, 0, 0)
987
 
    {}
988
 
  Field_double(uint32 len_arg, bool maybe_null_arg, const char *field_name_arg,
989
 
               uint8 dec_arg, my_bool not_fixed_arg)
990
 
    :Field_real((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "" : 0, (uint) 0,
991
 
                NONE, field_name_arg, dec_arg, 0, 0)
992
 
    {not_fixed= not_fixed_arg; }
993
 
  enum_field_types type() const { return MYSQL_TYPE_DOUBLE;}
994
 
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_DOUBLE; }
995
 
  int  store(const char *to,uint length,CHARSET_INFO *charset);
996
 
  int  store(double nr);
997
 
  int  store(int64_t nr, bool unsigned_val);
998
 
  int reset(void) { bzero(ptr,sizeof(double)); return 0; }
999
 
  double val_real(void);
1000
 
  int64_t val_int(void);
1001
 
  String *val_str(String*,String *);
1002
 
  bool send_binary(Protocol *protocol);
1003
 
  int cmp(const uchar *,const uchar *);
1004
 
  void sort_string(uchar *buff,uint length);
1005
 
  uint32 pack_length() const { return sizeof(double); }
1006
 
  uint row_pack_length() { return pack_length(); }
1007
 
  void sql_type(String &str) const;
1008
 
private:
1009
 
  int do_save_field_metadata(uchar *first_byte);
1010
 
};
1011
 
 
1012
 
 
1013
 
/* Everything saved in this will disappear. It will always return NULL */
1014
 
 
1015
 
class Field_null :public Field_str {
1016
 
  static uchar null[1];
1017
 
public:
1018
 
  Field_null(uchar *ptr_arg, uint32 len_arg,
1019
 
             enum utype unireg_check_arg, const char *field_name_arg,
1020
 
             CHARSET_INFO *cs)
1021
 
    :Field_str(ptr_arg, len_arg, null, 1,
1022
 
               unireg_check_arg, field_name_arg, cs)
1023
 
    {}
1024
 
  enum_field_types type() const { return MYSQL_TYPE_NULL;}
1025
 
  int  store(const char *to __attribute__((__unused__)),
1026
 
             uint length __attribute__((__unused__)),
1027
 
             CHARSET_INFO *cs __attribute__((__unused__)))
1028
 
  { null[0]=1; return 0; }
1029
 
  int store(double nr __attribute__((__unused__)))
1030
 
  { null[0]=1; return 0; }
1031
 
  int store(int64_t nr __attribute__((__unused__)),
1032
 
            bool unsigned_val __attribute__((__unused__)))
1033
 
  { null[0]=1; return 0; }
1034
 
  int store_decimal(const my_decimal *d __attribute__((__unused__)))
1035
 
  { null[0]=1; return 0; }
1036
 
  int reset(void)
1037
 
  { return 0; }
1038
 
  double val_real(void)
1039
 
  { return 0.0;}
1040
 
  int64_t val_int(void)
1041
 
  { return 0;}
1042
 
  my_decimal *val_decimal(my_decimal *) { return 0; }
1043
 
  String *val_str(String *value __attribute__((__unused__)),
1044
 
                  String *value2)
1045
 
  { value2->length(0); return value2;}
1046
 
  int cmp(const uchar *a __attribute__((__unused__)),
1047
 
          const uchar *b __attribute__((__unused__))) { return 0;}
1048
 
  void sort_string(uchar *buff __attribute__((__unused__)),
1049
 
                   uint length __attribute__((__unused__)))  {}
1050
 
  uint32 pack_length() const { return 0; }
1051
 
  void sql_type(String &str) const;
1052
 
  uint size_of() const { return sizeof(*this); }
1053
 
  uint32 max_display_length() { return 4; }
1054
 
};
1055
 
 
1056
 
 
1057
 
class Field_timestamp :public Field_str {
1058
 
public:
1059
 
  Field_timestamp(uchar *ptr_arg, uint32 len_arg,
1060
 
                  uchar *null_ptr_arg, uchar null_bit_arg,
1061
 
                  enum utype unireg_check_arg, const char *field_name_arg,
1062
 
                  TABLE_SHARE *share, CHARSET_INFO *cs);
1063
 
  Field_timestamp(bool maybe_null_arg, const char *field_name_arg,
1064
 
                  CHARSET_INFO *cs);
1065
 
  enum_field_types type() const { return MYSQL_TYPE_TIMESTAMP;}
1066
 
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONG_INT; }
1067
 
  enum Item_result cmp_type () const { return INT_RESULT; }
1068
 
  int  store(const char *to,uint length,CHARSET_INFO *charset);
1069
 
  int  store(double nr);
1070
 
  int  store(int64_t nr, bool unsigned_val);
1071
 
  int  reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=0; return 0; }
1072
 
  double val_real(void);
1073
 
  int64_t val_int(void);
1074
 
  String *val_str(String*,String *);
1075
 
  bool send_binary(Protocol *protocol);
1076
 
  int cmp(const uchar *,const uchar *);
1077
 
  void sort_string(uchar *buff,uint length);
1078
 
  uint32 pack_length() const { return 4; }
1079
 
  void sql_type(String &str) const;
1080
 
  bool can_be_compared_as_int64_t() const { return true; }
1081
 
  bool zero_pack() const { return 0; }
1082
 
  void set_time();
1083
 
  virtual void set_default()
1084
 
  {
1085
 
    if (table->timestamp_field == this &&
1086
 
        unireg_check != TIMESTAMP_UN_FIELD)
1087
 
      set_time();
1088
 
    else
1089
 
      Field::set_default();
1090
 
  }
1091
 
  /* Get TIMESTAMP field value as seconds since begging of Unix Epoch */
1092
 
  inline long get_timestamp(my_bool *null_value)
1093
 
  {
1094
 
    if ((*null_value= is_null()))
1095
 
      return 0;
1096
 
#ifdef WORDS_BIGENDIAN
1097
 
    if (table && table->s->db_low_byte_first)
1098
 
      return sint4korr(ptr);
1099
 
#endif
1100
 
    long tmp;
1101
 
    longget(tmp,ptr);
1102
 
    return tmp;
1103
 
  }
1104
 
  inline void store_timestamp(my_time_t timestamp)
1105
 
  {
1106
 
#ifdef WORDS_BIGENDIAN
1107
 
    if (table && table->s->db_low_byte_first)
1108
 
    {
1109
 
      int4store(ptr,timestamp);
1110
 
    }
1111
 
    else
1112
 
#endif
1113
 
      longstore(ptr,(uint32) timestamp);
1114
 
  }
1115
 
  bool get_date(MYSQL_TIME *ltime,uint fuzzydate);
1116
 
  bool get_time(MYSQL_TIME *ltime);
1117
 
  timestamp_auto_set_type get_auto_set_type() const;
1118
 
};
1119
 
 
1120
 
 
1121
 
class Field_year :public Field_tiny {
1122
 
public:
1123
 
  Field_year(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
1124
 
             uchar null_bit_arg,
1125
 
             enum utype unireg_check_arg, const char *field_name_arg)
1126
 
    :Field_tiny(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
1127
 
                unireg_check_arg, field_name_arg, 1, 1)
1128
 
    {}
1129
 
  enum_field_types type() const { return MYSQL_TYPE_YEAR;}
1130
 
  int  store(const char *to,uint length,CHARSET_INFO *charset);
1131
 
  int  store(double nr);
1132
 
  int  store(int64_t nr, bool unsigned_val);
1133
 
  double val_real(void);
1134
 
  int64_t val_int(void);
1135
 
  String *val_str(String*,String *);
1136
 
  bool send_binary(Protocol *protocol);
1137
 
  void sql_type(String &str) const;
1138
 
  bool can_be_compared_as_int64_t() const { return true; }
1139
 
};
1140
 
 
1141
 
 
1142
 
class Field_newdate :public Field_str {
1143
 
public:
1144
 
  Field_newdate(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
1145
 
                enum utype unireg_check_arg, const char *field_name_arg,
1146
 
                CHARSET_INFO *cs)
1147
 
    :Field_str(ptr_arg, 10, null_ptr_arg, null_bit_arg,
1148
 
               unireg_check_arg, field_name_arg, cs)
1149
 
    {}
1150
 
  Field_newdate(bool maybe_null_arg, const char *field_name_arg,
1151
 
                CHARSET_INFO *cs)
1152
 
    :Field_str((uchar*) 0,10, maybe_null_arg ? (uchar*) "": 0,0,
1153
 
               NONE, field_name_arg, cs) {}
1154
 
  enum_field_types type() const { return MYSQL_TYPE_NEWDATE;}
1155
 
  enum_field_types real_type() const { return MYSQL_TYPE_NEWDATE; }
1156
 
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_UINT24; }
1157
 
  enum Item_result cmp_type () const { return INT_RESULT; }
1158
 
  int  store(const char *to,uint length,CHARSET_INFO *charset);
1159
 
  int  store(double nr);
1160
 
  int  store(int64_t nr, bool unsigned_val);
1161
 
  int store_time(MYSQL_TIME *ltime, timestamp_type type);
1162
 
  int reset(void) { ptr[0]=ptr[1]=ptr[2]=0; return 0; }
1163
 
  double val_real(void);
1164
 
  int64_t val_int(void);
1165
 
  String *val_str(String*,String *);
1166
 
  bool send_binary(Protocol *protocol);
1167
 
  int cmp(const uchar *,const uchar *);
1168
 
  void sort_string(uchar *buff,uint length);
1169
 
  uint32 pack_length() const { return 3; }
1170
 
  void sql_type(String &str) const;
1171
 
  bool can_be_compared_as_int64_t() const { return true; }
1172
 
  bool zero_pack() const { return 1; }
1173
 
  bool get_date(MYSQL_TIME *ltime,uint fuzzydate);
1174
 
  bool get_time(MYSQL_TIME *ltime);
1175
 
};
1176
 
 
1177
 
 
1178
 
class Field_time :public Field_str {
1179
 
public:
1180
 
  Field_time(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
1181
 
             enum utype unireg_check_arg, const char *field_name_arg,
1182
 
             CHARSET_INFO *cs)
1183
 
    :Field_str(ptr_arg, 8, null_ptr_arg, null_bit_arg,
1184
 
               unireg_check_arg, field_name_arg, cs)
1185
 
    {}
1186
 
  Field_time(bool maybe_null_arg, const char *field_name_arg,
1187
 
             CHARSET_INFO *cs)
1188
 
    :Field_str((uchar*) 0,8, maybe_null_arg ? (uchar*) "": 0,0,
1189
 
               NONE, field_name_arg, cs) {}
1190
 
  enum_field_types type() const { return MYSQL_TYPE_TIME;}
1191
 
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_INT24; }
1192
 
  enum Item_result cmp_type () const { return INT_RESULT; }
1193
 
  int store_time(MYSQL_TIME *ltime, timestamp_type type);
1194
 
  int store(const char *to,uint length,CHARSET_INFO *charset);
1195
 
  int store(double nr);
1196
 
  int store(int64_t nr, bool unsigned_val);
1197
 
  int reset(void) { ptr[0]=ptr[1]=ptr[2]=0; return 0; }
1198
 
  double val_real(void);
1199
 
  int64_t val_int(void);
1200
 
  String *val_str(String*,String *);
1201
 
  bool get_date(MYSQL_TIME *ltime, uint fuzzydate);
1202
 
  bool send_binary(Protocol *protocol);
1203
 
  bool get_time(MYSQL_TIME *ltime);
1204
 
  int cmp(const uchar *,const uchar *);
1205
 
  void sort_string(uchar *buff,uint length);
1206
 
  uint32 pack_length() const { return 3; }
1207
 
  void sql_type(String &str) const;
1208
 
  bool can_be_compared_as_int64_t() const { return true; }
1209
 
  bool zero_pack() const { return 1; }
1210
 
};
1211
 
 
1212
 
 
1213
 
class Field_datetime :public Field_str {
1214
 
public:
1215
 
  Field_datetime(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
1216
 
                 enum utype unireg_check_arg, const char *field_name_arg,
1217
 
                 CHARSET_INFO *cs)
1218
 
    :Field_str(ptr_arg, 19, null_ptr_arg, null_bit_arg,
1219
 
               unireg_check_arg, field_name_arg, cs)
1220
 
    {}
1221
 
  Field_datetime(bool maybe_null_arg, const char *field_name_arg,
1222
 
                 CHARSET_INFO *cs)
1223
 
    :Field_str((uchar*) 0,19, maybe_null_arg ? (uchar*) "": 0,0,
1224
 
               NONE, field_name_arg, cs) {}
1225
 
  enum_field_types type() const { return MYSQL_TYPE_DATETIME;}
1226
 
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONGLONG; }
1227
 
  enum Item_result cmp_type () const { return INT_RESULT; }
1228
 
  uint decimals() const { return DATETIME_DEC; }
1229
 
  int  store(const char *to,uint length,CHARSET_INFO *charset);
1230
 
  int  store(double nr);
1231
 
  int  store(int64_t nr, bool unsigned_val);
1232
 
  int store_time(MYSQL_TIME *ltime, timestamp_type type);
1233
 
  int reset(void)
1234
 
  {
1235
 
    ptr[0]=ptr[1]=ptr[2]=ptr[3]=ptr[4]=ptr[5]=ptr[6]=ptr[7]=0;
1236
 
    return 0;
1237
 
  }
1238
 
  double val_real(void);
1239
 
  int64_t val_int(void);
1240
 
  String *val_str(String*,String *);
1241
 
  bool send_binary(Protocol *protocol);
1242
 
  int cmp(const uchar *,const uchar *);
1243
 
  void sort_string(uchar *buff,uint length);
1244
 
  uint32 pack_length() const { return 8; }
1245
 
  void sql_type(String &str) const;
1246
 
  bool can_be_compared_as_int64_t() const { return true; }
1247
 
  bool zero_pack() const { return 1; }
1248
 
  bool get_date(MYSQL_TIME *ltime,uint fuzzydate);
1249
 
  bool get_time(MYSQL_TIME *ltime);
1250
 
};
1251
 
 
1252
 
 
1253
 
class Field_string :public Field_longstr {
1254
 
public:
1255
 
  bool can_alter_field_type;
1256
 
  Field_string(uchar *ptr_arg, uint32 len_arg,uchar *null_ptr_arg,
1257
 
               uchar null_bit_arg,
1258
 
               enum utype unireg_check_arg, const char *field_name_arg,
1259
 
               CHARSET_INFO *cs)
1260
 
    :Field_longstr(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
1261
 
                   unireg_check_arg, field_name_arg, cs),
1262
 
     can_alter_field_type(1) {};
1263
 
  Field_string(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
1264
 
               CHARSET_INFO *cs)
1265
 
    :Field_longstr((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0, 0,
1266
 
                   NONE, field_name_arg, cs),
1267
 
     can_alter_field_type(1) {};
1268
 
 
1269
 
  enum_field_types type() const
1270
 
  {
1271
 
    return  MYSQL_TYPE_STRING;
1272
 
  }
1273
 
  enum ha_base_keytype key_type() const
1274
 
    { return binary() ? HA_KEYTYPE_BINARY : HA_KEYTYPE_TEXT; }
1275
 
  bool zero_pack() const { return 0; }
1276
 
  int reset(void)
1277
 
  {
1278
 
    charset()->cset->fill(charset(),(char*) ptr, field_length,
1279
 
                          (has_charset() ? ' ' : 0));
1280
 
    return 0;
1281
 
  }
1282
 
  int store(const char *to,uint length,CHARSET_INFO *charset);
1283
 
  int store(int64_t nr, bool unsigned_val);
1284
 
  int store(double nr) { return Field_str::store(nr); } /* QQ: To be deleted */
1285
 
  double val_real(void);
1286
 
  int64_t val_int(void);
1287
 
  String *val_str(String*,String *);
1288
 
  my_decimal *val_decimal(my_decimal *);
1289
 
  int cmp(const uchar *,const uchar *);
1290
 
  void sort_string(uchar *buff,uint length);
1291
 
  void sql_type(String &str) const;
1292
 
  virtual uchar *pack(uchar *to, const uchar *from,
1293
 
                      uint max_length, bool low_byte_first);
1294
 
  virtual const uchar *unpack(uchar* to, const uchar *from,
1295
 
                              uint param_data, bool low_byte_first);
1296
 
  uint pack_length_from_metadata(uint field_metadata)
1297
 
  { return (field_metadata & 0x00ff); }
1298
 
  uint row_pack_length() { return (field_length + 1); }
1299
 
  int pack_cmp(const uchar *a,const uchar *b,uint key_length,
1300
 
               my_bool insert_or_update);
1301
 
  int pack_cmp(const uchar *b,uint key_length,my_bool insert_or_update);
1302
 
  uint packed_col_length(const uchar *to, uint length);
1303
 
  uint max_packed_col_length(uint max_length);
1304
 
  uint size_of() const { return sizeof(*this); }
1305
 
  enum_field_types real_type() const { return MYSQL_TYPE_STRING; }
1306
 
  bool has_charset(void) const
1307
 
  { return charset() == &my_charset_bin ? false : true; }
1308
 
  Field *new_field(MEM_ROOT *root, struct st_table *new_table, bool keep_type);
1309
 
  virtual uint get_key_image(uchar *buff,uint length, imagetype type);
1310
 
private:
1311
 
  int do_save_field_metadata(uchar *first_byte);
1312
 
};
1313
 
 
1314
 
 
1315
 
class Field_varstring :public Field_longstr {
1316
 
public:
1317
 
  /*
1318
 
    The maximum space available in a Field_varstring, in bytes. See
1319
 
    length_bytes.
1320
 
  */
1321
 
  static const uint MAX_SIZE;
1322
 
  /* Store number of bytes used to store length (1 or 2) */
1323
 
  uint32 length_bytes;
1324
 
  Field_varstring(uchar *ptr_arg,
1325
 
                  uint32 len_arg, uint length_bytes_arg,
1326
 
                  uchar *null_ptr_arg, uchar null_bit_arg,
1327
 
                  enum utype unireg_check_arg, const char *field_name_arg,
1328
 
                  TABLE_SHARE *share, CHARSET_INFO *cs)
1329
 
    :Field_longstr(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
1330
 
                   unireg_check_arg, field_name_arg, cs),
1331
 
     length_bytes(length_bytes_arg)
1332
 
  {
1333
 
    share->varchar_fields++;
1334
 
  }
1335
 
  Field_varstring(uint32 len_arg,bool maybe_null_arg,
1336
 
                  const char *field_name_arg,
1337
 
                  TABLE_SHARE *share, CHARSET_INFO *cs)
1338
 
    :Field_longstr((uchar*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0, 0,
1339
 
                   NONE, field_name_arg, cs),
1340
 
     length_bytes(len_arg < 256 ? 1 :2)
1341
 
  {
1342
 
    share->varchar_fields++;
1343
 
  }
1344
 
 
1345
 
  enum_field_types type() const { return MYSQL_TYPE_VARCHAR; }
1346
 
  enum ha_base_keytype key_type() const;
1347
 
  uint row_pack_length() { return field_length; }
1348
 
  bool zero_pack() const { return 0; }
1349
 
  int  reset(void) { bzero(ptr,field_length+length_bytes); return 0; }
1350
 
  uint32 pack_length() const { return (uint32) field_length+length_bytes; }
1351
 
  uint32 key_length() const { return (uint32) field_length; }
1352
 
  uint32 sort_length() const
1353
 
  {
1354
 
    return (uint32) field_length + (field_charset == &my_charset_bin ?
1355
 
                                    length_bytes : 0);
1356
 
  }
1357
 
  int  store(const char *to,uint length,CHARSET_INFO *charset);
1358
 
  int  store(int64_t nr, bool unsigned_val);
1359
 
  int  store(double nr) { return Field_str::store(nr); } /* QQ: To be deleted */
1360
 
  double val_real(void);
1361
 
  int64_t val_int(void);
1362
 
  String *val_str(String*,String *);
1363
 
  my_decimal *val_decimal(my_decimal *);
1364
 
  int cmp_max(const uchar *, const uchar *, uint max_length);
1365
 
  int cmp(const uchar *a,const uchar *b)
1366
 
  {
1367
 
    return cmp_max(a, b, ~0L);
1368
 
  }
1369
 
  void sort_string(uchar *buff,uint length);
1370
 
  uint get_key_image(uchar *buff,uint length, imagetype type);
1371
 
  void set_key_image(const uchar *buff,uint length);
1372
 
  void sql_type(String &str) const;
1373
 
  virtual uchar *pack(uchar *to, const uchar *from,
1374
 
                      uint max_length, bool low_byte_first);
1375
 
  uchar *pack_key(uchar *to, const uchar *from, uint max_length, bool low_byte_first);
1376
 
  uchar *pack_key_from_key_image(uchar* to, const uchar *from,
1377
 
                                 uint max_length, bool low_byte_first);
1378
 
  virtual const uchar *unpack(uchar* to, const uchar *from,
1379
 
                              uint param_data, bool low_byte_first);
1380
 
  const uchar *unpack_key(uchar* to, const uchar *from,
1381
 
                          uint max_length, bool low_byte_first);
1382
 
  int pack_cmp(const uchar *a, const uchar *b, uint key_length,
1383
 
               my_bool insert_or_update);
1384
 
  int pack_cmp(const uchar *b, uint key_length,my_bool insert_or_update);
1385
 
  int cmp_binary(const uchar *a,const uchar *b, uint32 max_length=~0L);
1386
 
  int key_cmp(const uchar *,const uchar*);
1387
 
  int key_cmp(const uchar *str, uint length);
1388
 
  uint packed_col_length(const uchar *to, uint length);
1389
 
  uint max_packed_col_length(uint max_length);
1390
 
  uint32 data_length();
1391
 
  uint32 used_length();
1392
 
  uint size_of() const { return sizeof(*this); }
1393
 
  enum_field_types real_type() const { return MYSQL_TYPE_VARCHAR; }
1394
 
  bool has_charset(void) const
1395
 
  { return charset() == &my_charset_bin ? false : true; }
1396
 
  Field *new_field(MEM_ROOT *root, struct st_table *new_table, bool keep_type);
1397
 
  Field *new_key_field(MEM_ROOT *root, struct st_table *new_table,
1398
 
                       uchar *new_ptr, uchar *new_null_ptr,
1399
 
                       uint new_null_bit);
1400
 
  uint is_equal(Create_field *new_field);
1401
 
  void hash(ulong *nr, ulong *nr2);
1402
 
private:
1403
 
  int do_save_field_metadata(uchar *first_byte);
1404
 
};
1405
 
 
1406
 
 
1407
 
class Field_blob :public Field_longstr {
1408
 
protected:
1409
 
  uint packlength;
1410
 
  String value;                         // For temporaries
1411
 
public:
1412
 
  Field_blob(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
1413
 
             enum utype unireg_check_arg, const char *field_name_arg,
1414
 
             TABLE_SHARE *share, uint blob_pack_length, CHARSET_INFO *cs);
1415
 
  Field_blob(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
1416
 
             CHARSET_INFO *cs)
1417
 
    :Field_longstr((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0, 0,
1418
 
                   NONE, field_name_arg, cs),
1419
 
    packlength(4)
1420
 
  {
1421
 
    flags|= BLOB_FLAG;
1422
 
  }
1423
 
  Field_blob(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
1424
 
             CHARSET_INFO *cs, bool set_packlength)
1425
 
    :Field_longstr((uchar*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0, 0,
1426
 
                   NONE, field_name_arg, cs)
1427
 
  {
1428
 
    flags|= BLOB_FLAG;
1429
 
    packlength= 4;
1430
 
    if (set_packlength)
1431
 
    {
1432
 
      uint32 l_char_length= len_arg/cs->mbmaxlen;
1433
 
      packlength= l_char_length <= 255 ? 1 :
1434
 
                  l_char_length <= 65535 ? 2 :
1435
 
                  l_char_length <= 16777215 ? 3 : 4;
1436
 
    }
1437
 
  }
1438
 
  Field_blob(uint32 packlength_arg)
1439
 
    :Field_longstr((uchar*) 0, 0, (uchar*) "", 0, NONE, "temp", system_charset_info),
1440
 
    packlength(packlength_arg) {}
1441
 
  enum_field_types type() const { return MYSQL_TYPE_BLOB;}
1442
 
  enum ha_base_keytype key_type() const
1443
 
    { return binary() ? HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2; }
1444
 
  int  store(const char *to,uint length,CHARSET_INFO *charset);
1445
 
  int  store(double nr);
1446
 
  int  store(int64_t nr, bool unsigned_val);
1447
 
  double val_real(void);
1448
 
  int64_t val_int(void);
1449
 
  String *val_str(String*,String *);
1450
 
  my_decimal *val_decimal(my_decimal *);
1451
 
  int cmp_max(const uchar *, const uchar *, uint max_length);
1452
 
  int cmp(const uchar *a,const uchar *b)
1453
 
    { return cmp_max(a, b, ~0L); }
1454
 
  int cmp(const uchar *a, uint32 a_length, const uchar *b, uint32 b_length);
1455
 
  int cmp_binary(const uchar *a,const uchar *b, uint32 max_length=~0L);
1456
 
  int key_cmp(const uchar *,const uchar*);
1457
 
  int key_cmp(const uchar *str, uint length);
1458
 
  uint32 key_length() const { return 0; }
1459
 
  void sort_string(uchar *buff,uint length);
1460
 
  uint32 pack_length() const
1461
 
  { return (uint32) (packlength+table->s->blob_ptr_size); }
1462
 
 
1463
 
  /**
1464
 
     Return the packed length without the pointer size added. 
1465
 
 
1466
 
     This is used to determine the size of the actual data in the row
1467
 
     buffer.
1468
 
 
1469
 
     @returns The length of the raw data itself without the pointer.
1470
 
  */
1471
 
  uint32 pack_length_no_ptr() const
1472
 
  { return (uint32) (packlength); }
1473
 
  uint row_pack_length() { return pack_length_no_ptr(); }
1474
 
  uint32 sort_length() const;
1475
 
  virtual uint32 max_data_length() const
1476
 
  {
1477
 
    return (uint32) (((uint64_t) 1 << (packlength*8)) -1);
1478
 
  }
1479
 
  int reset(void) { bzero(ptr, packlength+sizeof(uchar*)); return 0; }
1480
 
  void reset_fields() { bzero((uchar*) &value,sizeof(value)); }
1481
 
#ifndef WORDS_BIGENDIAN
1482
 
  static
1483
 
#endif
1484
 
  void store_length(uchar *i_ptr, uint i_packlength, uint32 i_number, bool low_byte_first);
1485
 
  void store_length(uchar *i_ptr, uint i_packlength, uint32 i_number)
1486
 
  {
1487
 
    store_length(i_ptr, i_packlength, i_number, table->s->db_low_byte_first);
1488
 
  }
1489
 
  inline void store_length(uint32 number)
1490
 
  {
1491
 
    store_length(ptr, packlength, number);
1492
 
  }
1493
 
 
1494
 
  /**
1495
 
     Return the packed length plus the length of the data. 
1496
 
 
1497
 
     This is used to determine the size of the data plus the 
1498
 
     packed length portion in the row data.
1499
 
 
1500
 
     @returns The length in the row plus the size of the data.
1501
 
  */
1502
 
  uint32 get_packed_size(const uchar *ptr_arg, bool low_byte_first)
1503
 
    {return packlength + get_length(ptr_arg, packlength, low_byte_first);}
1504
 
 
1505
 
  inline uint32 get_length(uint row_offset= 0)
1506
 
  { return get_length(ptr+row_offset, this->packlength, table->s->db_low_byte_first); }
1507
 
  uint32 get_length(const uchar *ptr, uint packlength, bool low_byte_first);
1508
 
  uint32 get_length(const uchar *ptr_arg)
1509
 
  { return get_length(ptr_arg, this->packlength, table->s->db_low_byte_first); }
1510
 
  void put_length(uchar *pos, uint32 length);
1511
 
  inline void get_ptr(uchar **str)
1512
 
    {
1513
 
      memcpy_fixed((uchar*) str,ptr+packlength,sizeof(uchar*));
1514
 
    }
1515
 
  inline void get_ptr(uchar **str, uint row_offset)
1516
 
    {
1517
 
      memcpy_fixed((uchar*) str,ptr+packlength+row_offset,sizeof(char*));
1518
 
    }
1519
 
  inline void set_ptr(uchar *length, uchar *data)
1520
 
    {
1521
 
      memcpy(ptr,length,packlength);
1522
 
      memcpy_fixed(ptr+packlength,&data,sizeof(char*));
1523
 
    }
1524
 
  void set_ptr_offset(my_ptrdiff_t ptr_diff, uint32 length, uchar *data)
1525
 
    {
1526
 
      uchar *ptr_ofs= ADD_TO_PTR(ptr,ptr_diff,uchar*);
1527
 
      store_length(ptr_ofs, packlength, length);
1528
 
      memcpy_fixed(ptr_ofs+packlength,&data,sizeof(char*));
1529
 
    }
1530
 
  inline void set_ptr(uint32 length, uchar *data)
1531
 
    {
1532
 
      set_ptr_offset(0, length, data);
1533
 
    }
1534
 
  uint get_key_image(uchar *buff,uint length, imagetype type);
1535
 
  void set_key_image(const uchar *buff,uint length);
1536
 
  void sql_type(String &str) const;
1537
 
  inline bool copy()
1538
 
  {
1539
 
    uchar *tmp;
1540
 
    get_ptr(&tmp);
1541
 
    if (value.copy((char*) tmp, get_length(), charset()))
1542
 
    {
1543
 
      Field_blob::reset();
1544
 
      return 1;
1545
 
    }
1546
 
    tmp=(uchar*) value.ptr();
1547
 
    memcpy_fixed(ptr+packlength,&tmp,sizeof(char*));
1548
 
    return 0;
1549
 
  }
1550
 
  virtual uchar *pack(uchar *to, const uchar *from,
1551
 
                      uint max_length, bool low_byte_first);
1552
 
  uchar *pack_key(uchar *to, const uchar *from,
1553
 
                  uint max_length, bool low_byte_first);
1554
 
  uchar *pack_key_from_key_image(uchar* to, const uchar *from,
1555
 
                                 uint max_length, bool low_byte_first);
1556
 
  virtual const uchar *unpack(uchar *to, const uchar *from,
1557
 
                              uint param_data, bool low_byte_first);
1558
 
  const uchar *unpack_key(uchar* to, const uchar *from,
1559
 
                          uint max_length, bool low_byte_first);
1560
 
  int pack_cmp(const uchar *a, const uchar *b, uint key_length,
1561
 
               my_bool insert_or_update);
1562
 
  int pack_cmp(const uchar *b, uint key_length,my_bool insert_or_update);
1563
 
  uint packed_col_length(const uchar *col_ptr, uint length);
1564
 
  uint max_packed_col_length(uint max_length);
1565
 
  void free() { value.free(); }
1566
 
  inline void clear_temporary() { bzero((uchar*) &value,sizeof(value)); }
1567
 
  friend int field_conv(Field *to,Field *from);
1568
 
  uint size_of() const { return sizeof(*this); }
1569
 
  bool has_charset(void) const
1570
 
  { return charset() == &my_charset_bin ? false : true; }
1571
 
  uint32 max_display_length();
1572
 
  uint is_equal(Create_field *new_field);
1573
 
  inline bool in_read_set() { return bitmap_is_set(table->read_set, field_index); }
1574
 
  inline bool in_write_set() { return bitmap_is_set(table->write_set, field_index); }
1575
 
private:
1576
 
  int do_save_field_metadata(uchar *first_byte);
1577
 
};
1578
 
 
1579
 
 
1580
691
class Field_enum :public Field_str {
1581
692
protected:
1582
693
  uint packlength;
1583
694
public:
1584
695
  TYPELIB *typelib;
1585
 
  Field_enum(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 
696
  Field_enum(uchar *ptr_arg, uint32_t len_arg, uchar *null_ptr_arg,
1586
697
             uchar null_bit_arg,
1587
698
             enum utype unireg_check_arg, const char *field_name_arg,
1588
699
             uint packlength_arg,
1595
706
      flags|=ENUM_FLAG;
1596
707
  }
1597
708
  Field *new_field(MEM_ROOT *root, struct st_table *new_table, bool keep_type);
1598
 
  enum_field_types type() const { return MYSQL_TYPE_STRING; }
 
709
  enum_field_types type() const { return DRIZZLE_TYPE_STRING; }
1599
710
  enum Item_result cmp_type () const { return INT_RESULT; }
1600
711
  enum Item_result cast_to_int_type () const { return INT_RESULT; }
1601
712
  enum ha_base_keytype key_type() const;
1607
718
  String *val_str(String*,String *);
1608
719
  int cmp(const uchar *,const uchar *);
1609
720
  void sort_string(uchar *buff,uint length);
1610
 
  uint32 pack_length() const { return (uint32) packlength; }
 
721
  uint32_t pack_length() const { return (uint32_t) packlength; }
1611
722
  void store_type(uint64_t value);
1612
723
  void sql_type(String &str) const;
1613
724
  uint size_of() const { return sizeof(*this); }
1614
 
  enum_field_types real_type() const { return MYSQL_TYPE_ENUM; }
 
725
  enum_field_types real_type() const { return DRIZZLE_TYPE_ENUM; }
1615
726
  uint pack_length_from_metadata(uint field_metadata)
1616
727
  { return (field_metadata & 0x00ff); }
1617
728
  uint row_pack_length() { return pack_length(); }
1618
729
  virtual bool zero_pack() const { return 0; }
1619
 
  bool optimize_range(uint idx __attribute__((__unused__)),
1620
 
                      uint part __attribute__((__unused__)))
 
730
  bool optimize_range(uint idx __attribute__((unused)),
 
731
                      uint part __attribute__((unused)))
1621
732
  { return 0; }
1622
733
  bool eq_def(Field *field);
1623
734
  bool has_charset(void) const { return true; }
1627
738
  int do_save_field_metadata(uchar *first_byte);
1628
739
};
1629
740
 
1630
 
 
1631
 
class Field_set :public Field_enum {
1632
 
public:
1633
 
  Field_set(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
1634
 
            uchar null_bit_arg,
1635
 
            enum utype unireg_check_arg, const char *field_name_arg,
1636
 
            uint32 packlength_arg,
1637
 
            TYPELIB *typelib_arg, CHARSET_INFO *charset_arg)
1638
 
    :Field_enum(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
1639
 
                    unireg_check_arg, field_name_arg,
1640
 
                packlength_arg,
1641
 
                typelib_arg,charset_arg)
1642
 
    {
1643
 
      flags=(flags & ~ENUM_FLAG) | SET_FLAG;
1644
 
    }
1645
 
  int  store(const char *to,uint length,CHARSET_INFO *charset);
1646
 
  int  store(double nr) { return Field_set::store((int64_t) nr, false); }
1647
 
  int  store(int64_t nr, bool unsigned_val);
1648
 
 
1649
 
  virtual bool zero_pack() const { return 1; }
1650
 
  String *val_str(String*,String *);
1651
 
  void sql_type(String &str) const;
1652
 
  enum_field_types real_type() const { return MYSQL_TYPE_SET; }
1653
 
  bool has_charset(void) const { return true; }
1654
 
};
1655
 
 
1656
 
 
1657
741
/*
1658
742
  Create field class for CREATE TABLE
1659
743
*/
1676
760
    The value of `length' as set by parser: is the number of characters
1677
761
    for most of the types, or of bytes for BLOBs or numeric types.
1678
762
  */
1679
 
  uint32 char_length;
 
763
  uint32_t char_length;
1680
764
  uint  decimals, flags, pack_length, key_length;
1681
765
  Field::utype unireg_check;
1682
766
  TYPELIB *interval;                    // Which interval to use
1686
770
  CHARSET_INFO *charset;
1687
771
  Field *field;                         // For alter table
1688
772
 
1689
 
  uint8 row,col,sc_length,interval_id;  // For rea_create_table
 
773
  uint8_t row,col,sc_length,interval_id;        // For rea_create_table
1690
774
  uint  offset,pack_flag;
1691
775
  Create_field() :after(0) {}
1692
776
  Create_field(Field *field, Field *orig_field);
1703
787
 
1704
788
  /* Init for a tmp table field. To be extended if need be. */
1705
789
  void init_for_tmp_table(enum_field_types sql_type_arg,
1706
 
                          uint32 max_length, uint32 decimals,
 
790
                          uint32_t max_length, uint32_t decimals,
1707
791
                          bool maybe_null, bool is_unsigned);
1708
792
 
1709
793
  bool init(THD *thd, char *field_name, enum_field_types type, char *length,
1760
844
};
1761
845
 
1762
846
 
1763
 
Field *make_field(TABLE_SHARE *share, uchar *ptr, uint32 field_length,
 
847
Field *make_field(TABLE_SHARE *share, uchar *ptr, uint32_t field_length,
1764
848
                  uchar *null_pos, uchar null_bit,
1765
849
                  uint pack_flag, enum_field_types field_type,
1766
850
                  CHARSET_INFO *cs,
1768
852
                  TYPELIB *interval, const char *field_name);
1769
853
uint pack_length_to_packflag(uint type);
1770
854
enum_field_types get_blob_type_from_length(ulong length);
1771
 
uint32 calc_pack_length(enum_field_types type,uint32 length);
 
855
uint32_t calc_pack_length(enum_field_types type,uint32_t length);
1772
856
int set_field_to_null(Field *field);
1773
857
int set_field_to_null_with_conversions(Field *field, bool no_conversions);
1774
858
 
 
859
bool
 
860
check_string_copy_error(Field_str *field,
 
861
                        const char *well_formed_error_pos,
 
862
                        const char *cannot_convert_error_pos,
 
863
                        const char *end,
 
864
                        CHARSET_INFO *cs);
 
865
 
 
866
/*
 
867
  Field subclasses
 
868
 */
 
869
#include <drizzled/field/blob.h>
 
870
#include <drizzled/field/null.h>
 
871
#include <drizzled/field/date.h>
 
872
#include <drizzled/field/fdecimal.h>
 
873
#include <drizzled/field/double.h>
 
874
#include <drizzled/field/short.h>
 
875
#include <drizzled/field/long.h>
 
876
#include <drizzled/field/int64_t.h>
 
877
#include <drizzled/field/timetype.h>
 
878
#include <drizzled/field/timestamp.h>
 
879
#include <drizzled/field/datetime.h>
 
880
#include <drizzled/field/fstring.h>
 
881
#include <drizzled/field/varstring.h>
 
882
#include <drizzled/field/set.h>
 
883
 
1775
884
/*
1776
885
  The following are for the interface with the .frm file
1777
886
*/
1779
888
#define FIELDFLAG_DECIMAL               1
1780
889
#define FIELDFLAG_BINARY                1       // Shares same flag
1781
890
#define FIELDFLAG_NUMBER                2
1782
 
#define FIELDFLAG_ZEROFILL              4
 
891
#define FIELDFLAG_DECIMAL_POSITION      4
1783
892
#define FIELDFLAG_PACK                  120     // Bits used for packing
1784
893
#define FIELDFLAG_INTERVAL              256     // mangled with decimals!
1785
894
#define FIELDFLAG_BITFIELD              512     // mangled with decimals!
1805
914
 
1806
915
#define f_is_dec(x)             ((x) & FIELDFLAG_DECIMAL)
1807
916
#define f_is_num(x)             ((x) & FIELDFLAG_NUMBER)
1808
 
#define f_is_zerofill(x)        ((x) & FIELDFLAG_ZEROFILL)
 
917
#define f_is_decimal_precision(x)       ((x) & FIELDFLAG_DECIMAL_POSITION)
1809
918
#define f_is_packed(x)          ((x) & FIELDFLAG_PACK)
1810
919
#define f_packtype(x)           (((x) >> FIELDFLAG_PACK_SHIFT) & 15)
1811
 
#define f_decimals(x)           ((uint8) (((x) >> FIELDFLAG_DEC_SHIFT) & FIELDFLAG_MAX_DEC))
 
920
#define f_decimals(x)           ((uint8_t) (((x) >> FIELDFLAG_DEC_SHIFT) & FIELDFLAG_MAX_DEC))
1812
921
#define f_is_alpha(x)           (!f_is_num(x))
1813
922
#define f_is_binary(x)          ((x) & FIELDFLAG_BINARY) // 4.0- compatibility
1814
923
#define f_is_enum(x)            (((x) & (FIELDFLAG_INTERVAL | FIELDFLAG_NUMBER)) == FIELDFLAG_INTERVAL)
1820
929
#define f_no_default(x)         (x & FIELDFLAG_NO_DEFAULT)
1821
930
#define f_bit_as_char(x)        ((x) & FIELDFLAG_TREAT_BIT_AS_CHAR)
1822
931
#define f_is_hex_escape(x)      ((x) & FIELDFLAG_HEX_ESCAPE)
 
932