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