← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/field.h

  • Committer: Brian Aker
  • Date: 2008-07-22 17:32:05 UTC
  • mfrom: (202.1.3 toru)
  • Revision ID: brian@tangent.org-20080722173205-fbst5dw713h0gx3o
Merge of Toru + Brian

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/field.h
24
24
#endif
25
25
 
26
26
#define DATETIME_DEC                     6
 
27
#define DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE FLOATING_POINT_BUFFER
 
28
 
27
29
const uint32 max_field_size= (uint32) 4294967295U;
28
30
 
29
31
class Send_field;
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:
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
647
  Field_tiny(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
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;
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
*/
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 "field/blob.h"
 
870
#include "field/null.h"
 
871
#include "field/year.h"
 
872
#include "field/date.h"
 
873
#include "field/decimal.h"
 
874
#include "field/double.h"
 
875
#include "field/short.h"
 
876
#include "field/long.h"
 
877
#include "field/int64_t.h"
 
878
#include "field/timetype.h"
 
879
#include "field/timestamp.h"
 
880
#include "field/datetime.h"
 
881
#include "field/string.h"
 
882
#include "field/varstring.h"
 
883
#include "field/set.h"
 
884
 
1775
885
/*
1776
886
  The following are for the interface with the .frm file
1777
887
*/
1820
930
#define f_no_default(x)         (x & FIELDFLAG_NO_DEFAULT)
1821
931
#define f_bit_as_char(x)        ((x) & FIELDFLAG_TREAT_BIT_AS_CHAR)
1822
932
#define f_is_hex_escape(x)      ((x) & FIELDFLAG_HEX_ESCAPE)
 
933