开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
field.h
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：38k
源码类别：

MySQL数据库

开发平台：

Visual C++

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