← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.h

  • Committer: Monty Taylor
  • Date: 2008-11-16 23:47:43 UTC
  • mto: (584.1.10 devel)
  • mto: This revision was merged to the branch mainline in revision 589.
  • Revision ID: monty@inaugust.com-20081116234743-c38gmv0pa2kdefaj
Broke out cached_item.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field.h
25
25
#ifndef DRIZZLED_FIELD_H
26
26
#define DRIZZLED_FIELD_H
27
27
 
28
 
#include "drizzled/sql_error.h"
29
 
#include "drizzled/decimal.h"
30
 
#include "drizzled/key_map.h"
31
 
#include "drizzled/sql_bitmap.h"
32
 
#include "drizzled/sql_list.h"
33
 
#include "drizzled/structs.h"
34
 
#include "drizzled/charset_info.h"
35
 
#include "drizzled/item_result.h"
36
 
 
37
 
#include <string>
38
 
#include <vector>
39
 
 
40
 
namespace drizzled
41
 
{
 
28
#include <drizzled/sql_error.h>
 
29
#include <drizzled/my_decimal.h>
42
30
 
43
31
#define DATETIME_DEC                     6
44
32
#define DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE FLOATING_POINT_BUFFER
45
33
 
46
 
#ifdef DEBUG
47
 
#define ASSERT_COLUMN_MARKED_FOR_READ assert(!table || (table->read_set == NULL || isReadSet()))
48
 
#define ASSERT_COLUMN_MARKED_FOR_WRITE assert(!table || (table->write_set == NULL || isWriteSet()))
49
 
#else
50
 
#define ASSERT_COLUMN_MARKED_FOR_READ
51
 
#define ASSERT_COLUMN_MARKED_FOR_WRITE
52
 
#endif
53
 
 
54
 
typedef struct st_typelib TYPELIB;
55
 
 
56
34
const uint32_t max_field_size= (uint32_t) 4294967295U;
57
35
 
58
 
class SendField;
59
 
class CreateField;
60
 
class TableShare;
61
 
class Field;
 
36
class Send_field;
 
37
class Protocol;
 
38
class Create_field;
62
39
struct st_cache_field;
63
 
 
64
40
int field_conv(Field *to,Field *from);
65
41
 
66
42
inline uint32_t get_enum_pack_length(int elements)
68
44
  return elements < 256 ? 1 : 2;
69
45
}
70
46
 
71
 
/**
72
 
 * Class representing a Field in a Table
73
 
 *
74
 
 * @details
75
 
 *
76
 
 * The value stored in the Field object is stored in the
77
 
 * unsigned char pointer member variable called ptr.  The
78
 
 * val_xxx() methods retrieve this raw byte value and
79
 
 * convert the byte into the appropriate output (int, decimal, etc).
80
 
 *
81
 
 * The store_xxx() methods take various input and convert
82
 
 * the input into the raw bytes stored in the ptr member variable.
83
 
 */
 
47
inline uint32_t get_set_pack_length(int elements)
 
48
{
 
49
  uint32_t len= (elements + 7) / 8;
 
50
  return len > 4 ? 8 : len;
 
51
}
 
52
 
 
53
class virtual_column_info: public Sql_alloc
 
54
{
 
55
public:
 
56
  Item *expr_item;
 
57
  LEX_STRING expr_str;
 
58
  Item *item_free_list;
 
59
  virtual_column_info() 
 
60
  : expr_item(0), item_free_list(0),
 
61
    field_type(DRIZZLE_TYPE_VIRTUAL),
 
62
    is_stored(false), data_inited(false)
 
63
  {
 
64
    expr_str.str= NULL;
 
65
    expr_str.length= 0;
 
66
  };
 
67
  ~virtual_column_info() {}
 
68
  enum_field_types get_real_type()
 
69
  {
 
70
    assert(data_inited);
 
71
    return data_inited ? field_type : DRIZZLE_TYPE_VIRTUAL;
 
72
  }
 
73
  void set_field_type(enum_field_types fld_type)
 
74
  {
 
75
    /* Calling this function can only be done once. */
 
76
    assert(not data_inited);
 
77
    data_inited= true;
 
78
    field_type= fld_type;
 
79
  }
 
80
  bool get_field_stored()
 
81
  {
 
82
    assert(data_inited);
 
83
    return data_inited ? is_stored : true;
 
84
  }
 
85
  void set_field_stored(bool stored)
 
86
  {
 
87
    is_stored= stored;
 
88
  }
 
89
private:
 
90
  /*
 
91
    The following data is only updated by the parser and read
 
92
    when a Create_field object is created/initialized.
 
93
  */
 
94
  enum_field_types field_type;   /* Real field type*/
 
95
  bool is_stored;             /* Indication that the field is 
 
96
                                    phisically stored in the database*/
 
97
  /*
 
98
    This flag is used to prevent other applications from
 
99
    reading and using incorrect data.
 
100
  */
 
101
  bool data_inited; 
 
102
};
 
103
 
84
104
class Field
85
105
{
86
 
  /* Prevent use of these */
87
 
  Field(const Field&);
 
106
  Field(const Item &);                          /* Prevent use of these */
88
107
  void operator=(Field &);
89
108
public:
90
 
  unsigned char *ptr; /**< Position to field in record. Stores raw field value */
91
 
  unsigned char *null_ptr; /**< Byte where null_bit is */
92
 
 
93
 
  /**
94
 
   * Pointer to the Table object containing this Field
95
 
   *
96
 
   * @note You can use table->in_use as replacement for current_session member
97
 
   * only inside of val_*() and store() members (e.g. you can't use it in cons)
98
 
   */
99
 
  Table *table;
100
 
  Table *orig_table; /**< Pointer to the original Table. @TODO What is "the original table"? */
101
 
  const char **table_name; /**< Pointer to the name of the table. @TODO This is redundant with Table::table_name. */
102
 
  const char *field_name; /**< Name of the field */
103
 
  LEX_STRING comment; /**< A comment about the field */
104
 
 
105
 
  /** The field is part of the following keys */
106
 
  key_map       key_start;
107
 
  key_map part_of_key;
108
 
  key_map part_of_key_not_clustered;
109
 
  key_map part_of_sortkey;
110
 
 
 
109
  static void *operator new(size_t size) {return sql_alloc(size); }
 
110
  static void operator delete(void *ptr_arg __attribute__((unused)),
 
111
                              size_t size __attribute__((unused)))
 
112
  { TRASH(ptr_arg, size); }
 
113
 
 
114
  unsigned char         *ptr;                   // Position to field in record
 
115
  unsigned char         *null_ptr;              // Byte where null_bit is
111
116
  /*
112
 
    We use three additional unireg types for TIMESTAMP for hysterical
113
 
    raisins and limitations in the MySQL FRM file format.
114
 
 
115
 
    A good TODO is to clean this up as we can support just about
116
 
    anything in the table proto message now.
117
 
  */
118
 
  enum utype
119
 
  {
120
 
    NONE,
121
 
    NEXT_NUMBER,
122
 
    TIMESTAMP_OLD_FIELD,
123
 
    TIMESTAMP_DN_FIELD,
124
 
    TIMESTAMP_UN_FIELD,
125
 
    TIMESTAMP_DNUN_FIELD
126
 
  };
127
 
 
128
 
  utype unireg_check;
129
 
  uint32_t field_length; /**< Length of this field in bytes */
130
 
  uint32_t flags;
131
 
  uint16_t field_index; /**< Index of this Field in Table::fields array */
132
 
  unsigned char null_bit; /**< Bit used to test null bit */
 
117
    Note that you can use table->in_use as replacement for current_session member 
 
118
    only inside of val_*() and store() members (e.g. you can't use it in cons)
 
119
  */
 
120
  Table *table;         // Pointer for table
 
121
  Table *orig_table;            // Pointer to original table
 
122
  const char    **table_name, *field_name;
 
123
  LEX_STRING    comment;
 
124
  /* Field is part of the following keys */
 
125
  key_map       key_start, part_of_key, part_of_key_not_clustered;
 
126
  key_map       part_of_sortkey;
 
127
  /* 
 
128
    We use three additional unireg types for TIMESTAMP to overcome limitation 
 
129
    of current binary format of .frm file. We'd like to be able to support 
 
130
    NOW() as default and on update value for such fields but unable to hold 
 
131
    this info anywhere except unireg_check field. This issue will be resolved
 
132
    in more clean way with transition to new text based .frm format.
 
133
    See also comment for Field_timestamp::Field_timestamp().
 
134
  */
 
135
  enum utype  { NONE,DATE,SHIELD,NOEMPTY,CASEUP,PNR,BGNR,PGNR,YES,NO,REL,
 
136
                CHECK,EMPTY,UNKNOWN_FIELD,CASEDN,NEXT_NUMBER,INTERVAL_FIELD,
 
137
                BIT_FIELD, TIMESTAMP_OLD_FIELD, CAPITALIZE, BLOB_FIELD,
 
138
                TIMESTAMP_DN_FIELD, TIMESTAMP_UN_FIELD, TIMESTAMP_DNUN_FIELD};
 
139
  enum imagetype { itRAW, itMBR};
 
140
 
 
141
  utype         unireg_check;
 
142
  uint32_t      field_length;           // Length of field
 
143
  uint32_t      flags;
 
144
  uint16_t        field_index;            // field number in fields array
 
145
  unsigned char         null_bit;               // Bit used to test null bit
133
146
  /**
134
147
     If true, this field was created in create_tmp_field_from_item from a NULL
135
148
     value. This means that the type of the field is just a guess, and the type
137
150
 
138
151
     @see create_tmp_field_from_item
139
152
     @see Item_type_holder::get_real_type
 
153
 
140
154
   */
141
155
  bool is_created_from_null_item;
142
156
 
143
 
  static void *operator new(size_t size);
144
 
  static void *operator new(size_t size, memory::Root *mem_root);
145
 
  static void operator delete(void *, size_t)
146
 
  { }
 
157
  /* Virtual column data */
 
158
  virtual_column_info *vcol_info;
 
159
  /*
 
160
    Indication that the field is phycically stored in tables 
 
161
    rather than just generated on SQL queries.
 
162
    As of now, false can only be set for generated-only virtual columns.
 
163
  */
 
164
  bool is_stored;
147
165
 
148
 
  Field(unsigned char *ptr_arg,
149
 
        uint32_t length_arg,
150
 
        unsigned char *null_ptr_arg,
151
 
        unsigned char null_bit_arg,
152
 
        utype unireg_check_arg,
 
166
  Field(unsigned char *ptr_arg,uint32_t length_arg,unsigned char *null_ptr_arg,
 
167
        unsigned char null_bit_arg, utype unireg_check_arg,
153
168
        const char *field_name_arg);
154
169
  virtual ~Field() {}
155
170
  /* Store functions returns 1 on overflow and -1 on fatal error */
156
 
  virtual int store(const char *to,
157
 
                    uint32_t length,
158
 
                    const CHARSET_INFO * const cs)=0;
159
 
  virtual int store(double nr)=0;
160
 
  virtual int store(int64_t nr, bool unsigned_val)=0;
161
 
  virtual int store_decimal(const my_decimal *d)=0;
162
 
  int store(const char *to,
163
 
            uint32_t length,
164
 
            const CHARSET_INFO * const cs,
 
171
  virtual int  store(const char *to, uint32_t length, const CHARSET_INFO * const cs)=0;
 
172
  virtual int  store(double nr)=0;
 
173
  virtual int  store(int64_t nr, bool unsigned_val)=0;
 
174
  virtual int  store_decimal(const my_decimal *d)=0;
 
175
  virtual int store_time(DRIZZLE_TIME *ltime, enum enum_drizzle_timestamp_type t_type);
 
176
  int store(const char *to, uint32_t length, const CHARSET_INFO * const cs,
165
177
            enum_check_fields check_level);
166
 
  /**
167
 
    This is called when storing a date in a string.
168
 
 
169
 
    @note
170
 
      Needs to be changed if/when we want to support different time formats.
171
 
  */
172
 
  virtual int store_time(DRIZZLE_TIME *ltime, enum enum_drizzle_timestamp_type t_type);
173
178
  virtual double val_real(void)=0;
174
179
  virtual int64_t val_int(void)=0;
175
180
  virtual my_decimal *val_decimal(my_decimal *);
176
 
  inline String *val_str(String *str)
177
 
  {
178
 
    return val_str(str, str);
179
 
  }
 
181
  inline String *val_str(String *str) { return val_str(str, str); }
180
182
  /*
181
183
     val_str(buf1, buf2) gets two buffers and should use them as follows:
182
184
     if it needs a temp buffer to convert result to string - use buf1
189
191
     an unnecessary free (and later, may be an alloc).
190
192
     This trickery is used to decrease a number of malloc calls.
191
193
  */
192
 
  virtual String *val_str(String*, String *)=0;
 
194
  virtual String *val_str(String*,String *)=0;
 
195
  String *val_int_as_str(String *val_buffer, bool unsigned_flag);
193
196
  /*
194
197
   str_needs_quotes() returns true if the value returned by val_str() needs
195
198
   to be quoted when used in constructing an SQL query.
198
201
  virtual Item_result result_type () const=0;
199
202
  virtual Item_result cmp_type () const { return result_type(); }
200
203
  virtual Item_result cast_to_int_type () const { return result_type(); }
201
 
  /**
202
 
     Check whether a field type can be partially indexed by a key.
203
 
 
204
 
     This is a static method, rather than a virtual function, because we need
205
 
     to check the type of a non-Field in alter_table().
206
 
 
207
 
     @param type  field type
208
 
 
209
 
     @retval
210
 
       true  Type can have a prefixed key
211
 
     @retval
212
 
       false Type can not have a prefixed key
213
 
  */
214
204
  static bool type_can_have_key_part(enum_field_types);
215
 
  /**
216
 
    Return type of which can carry value of both given types in UNION result.
217
 
 
218
 
    @param a  type for merging
219
 
    @param b  type for merging
220
 
 
221
 
    @retval
222
 
      type of field
223
 
  */
224
205
  static enum_field_types field_type_merge(enum_field_types, enum_field_types);
225
 
 
226
 
  /**
227
 
     Detect Item_result by given field type of UNION merge result.
228
 
 
229
 
     @param field_type  given field type
230
 
 
231
 
     @return
232
 
       Item_result (type of internal MySQL expression result)
233
 
  */
234
206
  static Item_result result_merge_type(enum_field_types);
235
 
 
236
 
  virtual bool eq(Field *field);
237
 
  /**
238
 
   * Returns true if the fields are equally defined
239
 
   *
240
 
   * @retval
241
 
   *  true  This Field is equally defined to supplied Field
242
 
   * @retval
243
 
   *  false This Field is NOT equally defined to supplied Field
244
 
   */
 
207
  virtual bool eq(Field *field)
 
208
  {
 
209
    return (ptr == field->ptr && null_ptr == field->null_ptr &&
 
210
            null_bit == field->null_bit);
 
211
  }
245
212
  virtual bool eq_def(Field *field);
246
 
 
247
 
  /**
248
 
   * Returns size (in bytes) used to store field data in memory
249
 
   * (i.e. it returns the maximum size of the field in a row of the table,
250
 
   * which is located in RAM).
251
 
   */
252
 
  virtual uint32_t pack_length() const;
253
 
 
254
 
  /**
255
 
   * Returns size (in bytes) used to store field data on
256
 
   * storage (i.e. it returns the maximal size of the field in a row of the
257
 
   * table, which is located on disk).
258
 
   */
259
 
  virtual uint32_t pack_length_in_rec() const;
260
 
 
261
 
  /**
262
 
   * Return the "real size" of the data in memory.
263
 
   * For varstrings, this does _not_ include the length bytes.
264
 
   */
265
 
  virtual uint32_t data_length();
266
 
  /**
267
 
   * Returns the number of bytes actually used to store the data
268
 
   * of the field. So for a varstring it includes both lenght byte(s) and
269
 
   * string data, and anything after data_length() bytes are unused.
270
 
   */
271
 
  virtual uint32_t used_length();
272
 
  virtual uint32_t sort_length() const;
 
213
  
 
214
  /*
 
215
    pack_length() returns size (in bytes) used to store field data in memory
 
216
    (i.e. it returns the maximum size of the field in a row of the table,
 
217
    which is located in RAM).
 
218
  */
 
219
  virtual uint32_t pack_length() const { return (uint32_t) field_length; }
 
220
 
 
221
  /*
 
222
    pack_length_in_rec() returns size (in bytes) used to store field data on
 
223
    storage (i.e. it returns the maximal size of the field in a row of the
 
224
    table, which is located on disk).
 
225
  */
 
226
  virtual uint32_t pack_length_in_rec() const { return pack_length(); }
 
227
  virtual int compatible_field_size(uint32_t field_metadata);
 
228
  virtual uint32_t pack_length_from_metadata(uint32_t field_metadata)
 
229
  { return field_metadata; }
 
230
  /*
 
231
    This method is used to return the size of the data in a row-based
 
232
    replication row record. The default implementation of returning 0 is
 
233
    designed to allow fields that do not use metadata to return true (1)
 
234
    from compatible_field_size() which uses this function in the comparison.
 
235
    The default value for field metadata for fields that do not have 
 
236
    metadata is 0. Thus, 0 == 0 means the fields are compatible in size.
 
237
 
 
238
    Note: While most classes that override this method return pack_length(),
 
239
    the classes Field_varstring, and Field_blob return 
 
240
    field_length + 1, field_length, and pack_length_no_ptr() respectfully.
 
241
  */
 
242
  virtual uint32_t row_pack_length() { return 0; }
 
243
  virtual int save_field_metadata(unsigned char *first_byte)
 
244
  { return do_save_field_metadata(first_byte); }
 
245
 
 
246
  /*
 
247
    data_length() return the "real size" of the data in memory.
 
248
    For varstrings, this does _not_ include the length bytes.
 
249
  */
 
250
  virtual uint32_t data_length() { return pack_length(); }
 
251
  /*
 
252
    used_length() returns the number of bytes actually used to store the data
 
253
    of the field. So for a varstring it includes both lenght byte(s) and
 
254
    string data, and anything after data_length() bytes are unused.
 
255
  */
 
256
  virtual uint32_t used_length() { return pack_length(); }
 
257
  virtual uint32_t sort_length() const { return pack_length(); }
273
258
 
274
259
  /**
275
260
     Get the maximum size of the data in packed format.
277
262
     @return Maximum data length of the field when packed using the
278
263
     Field::pack() function.
279
264
   */
280
 
  virtual uint32_t max_data_length() const;
281
 
  virtual int reset(void);
282
 
  virtual void reset_fields();
283
 
  virtual void set_default();
284
 
  virtual bool binary() const;
285
 
  virtual bool zero_pack() const;
286
 
  virtual enum ha_base_keytype key_type() const;
287
 
  virtual uint32_t key_length() const;
 
265
  virtual uint32_t max_data_length() const {
 
266
    return pack_length();
 
267
  };
 
268
 
 
269
  virtual int reset(void) { memset(ptr, 0, pack_length()); return 0; }
 
270
  virtual void reset_fields() {}
 
271
  virtual void set_default()
 
272
  {
 
273
    my_ptrdiff_t l_offset= (my_ptrdiff_t) (table->getDefaultValues() - table->record[0]);
 
274
    memcpy(ptr, ptr + l_offset, pack_length());
 
275
    if (null_ptr)
 
276
      *null_ptr= ((*null_ptr & (unsigned char) ~null_bit) | (null_ptr[l_offset] & null_bit));
 
277
  }
 
278
  virtual bool binary() const { return 1; }
 
279
  virtual bool zero_pack() const { return 1; }
 
280
  virtual enum ha_base_keytype key_type() const { return HA_KEYTYPE_BINARY; }
 
281
  virtual uint32_t key_length() const { return pack_length(); }
288
282
  virtual enum_field_types type() const =0;
289
 
  virtual enum_field_types real_type() const;
 
283
  virtual enum_field_types real_type() const { return type(); }
290
284
  inline  int cmp(const unsigned char *str) { return cmp(ptr,str); }
291
285
  virtual int cmp_max(const unsigned char *a, const unsigned char *b,
292
 
                      uint32_t max_len);
 
286
                      uint32_t max_len __attribute__((unused)))
 
287
    { return cmp(a, b); }
293
288
  virtual int cmp(const unsigned char *,const unsigned char *)=0;
294
289
  virtual int cmp_binary(const unsigned char *a,const unsigned char *b,
295
 
                         uint32_t max_length=UINT32_MAX);
296
 
  virtual int cmp_offset(uint32_t row_offset);
297
 
  virtual int cmp_binary_offset(uint32_t row_offset);
298
 
  virtual int key_cmp(const unsigned char *a,const unsigned char *b);
299
 
  virtual int key_cmp(const unsigned char *str, uint32_t length);
300
 
  virtual uint32_t decimals() const;
301
 
 
 
290
                         uint32_t  __attribute__((unused)) max_length=UINT32_MAX)
 
291
  { return memcmp(a,b,pack_length()); }
 
292
  virtual int cmp_offset(uint32_t row_offset)
 
293
  { return cmp(ptr,ptr+row_offset); }
 
294
  virtual int cmp_binary_offset(uint32_t row_offset)
 
295
  { return cmp_binary(ptr, ptr+row_offset); };
 
296
  virtual int key_cmp(const unsigned char *a,const unsigned char *b)
 
297
  { return cmp(a, b); }
 
298
  virtual int key_cmp(const unsigned char *str, uint32_t length __attribute__((unused)))
 
299
  { return cmp(ptr,str); }
 
300
  virtual uint32_t decimals() const { return 0; }
302
301
  /*
303
302
    Caller beware: sql_type can change str.Ptr, so check
304
303
    ptr() to see if it changed if you are using your own buffer
305
304
    in str and restore it with set() if needed
306
305
  */
307
306
  virtual void sql_type(String &str) const =0;
308
 
 
309
 
  // For new field
310
 
  virtual uint32_t size_of() const =0;
311
 
 
312
 
  bool is_null(ptrdiff_t row_offset= 0);
313
 
  bool is_real_null(ptrdiff_t row_offset= 0);
314
 
  bool is_null_in_record(const unsigned char *record);
315
 
  bool is_null_in_record_with_offset(ptrdiff_t offset);
316
 
  void set_null(ptrdiff_t row_offset= 0);
317
 
  void set_notnull(ptrdiff_t row_offset= 0);
318
 
  bool maybe_null(void);
319
 
  bool real_maybe_null(void);
320
 
 
321
 
  virtual void make_field(SendField *);
 
307
  virtual uint32_t size_of() const =0;          // For new field
 
308
  inline bool is_null(my_ptrdiff_t row_offset= 0)
 
309
  { return null_ptr ? (null_ptr[row_offset] & null_bit ? 1 : 0) : table->null_row; }
 
310
  inline bool is_real_null(my_ptrdiff_t row_offset= 0)
 
311
    { return null_ptr ? (null_ptr[row_offset] & null_bit ? 1 : 0) : 0; }
 
312
  inline bool is_null_in_record(const unsigned char *record)
 
313
  {
 
314
    if (!null_ptr)
 
315
      return 0;
 
316
    return test(record[(uint32_t) (null_ptr -table->record[0])] &
 
317
                null_bit);
 
318
  }
 
319
  inline bool is_null_in_record_with_offset(my_ptrdiff_t offset)
 
320
  {
 
321
    if (!null_ptr)
 
322
      return 0;
 
323
    return test(null_ptr[offset] & null_bit);
 
324
  }
 
325
  inline void set_null(my_ptrdiff_t row_offset= 0)
 
326
    { if (null_ptr) null_ptr[row_offset]|= null_bit; }
 
327
  inline void set_notnull(my_ptrdiff_t row_offset= 0)
 
328
    { if (null_ptr) null_ptr[row_offset]&= (unsigned char) ~null_bit; }
 
329
  inline bool maybe_null(void) { return null_ptr != 0 || table->maybe_null; }
 
330
  inline bool real_maybe_null(void) { return null_ptr != 0; }
 
331
 
 
332
  enum {
 
333
    LAST_NULL_BYTE_UNDEF= 0
 
334
  };
 
335
 
 
336
  /*
 
337
    Find the position of the last null byte for the field.
 
338
 
 
339
    SYNOPSIS
 
340
      last_null_byte()
 
341
 
 
342
    DESCRIPTION
 
343
      Return a pointer to the last byte of the null bytes where the
 
344
      field conceptually is placed.
 
345
 
 
346
    RETURN VALUE
 
347
      The position of the last null byte relative to the beginning of
 
348
      the record. If the field does not use any bits of the null
 
349
      bytes, the value 0 (LAST_NULL_BYTE_UNDEF) is returned.
 
350
   */
 
351
  size_t last_null_byte() const {
 
352
    size_t bytes= do_last_null_byte();
 
353
    assert(bytes <= table->getNullBytes());
 
354
    return bytes;
 
355
  }
 
356
 
 
357
  virtual void make_field(Send_field *);
322
358
  virtual void sort_string(unsigned char *buff,uint32_t length)=0;
323
359
  virtual bool optimize_range(uint32_t idx, uint32_t part);
324
 
  /**
325
 
   * Returns true for fields which, when compared with constant
326
 
   * items, can be casted to int64_t. In this case we will at 'fix_fields'
327
 
   * stage cast the constant items to int64_ts and at the execution stage
328
 
   * use field->val_int() for comparison.  Used to optimize clauses like
329
 
   * 'a_column BETWEEN date_const AND date_const'.
330
 
   */
331
 
  virtual bool can_be_compared_as_int64_t() const
332
 
  {
333
 
    return false;
334
 
  }
 
360
  /*
 
361
    This should be true for fields which, when compared with constant
 
362
    items, can be casted to int64_t. In this case we will at 'fix_fields'
 
363
    stage cast the constant items to int64_ts and at the execution stage
 
364
    use field->val_int() for comparison.  Used to optimize clauses like
 
365
    'a_column BETWEEN date_const, date_const'.
 
366
  */
 
367
  virtual bool can_be_compared_as_int64_t() const { return false; }
335
368
  virtual void free() {}
336
 
  virtual Field *new_field(memory::Root *root,
337
 
                           Table *new_table,
 
369
  virtual Field *new_field(MEM_ROOT *root, Table *new_table,
338
370
                           bool keep_type);
339
 
  virtual Field *new_key_field(memory::Root *root, Table *new_table,
340
 
                               unsigned char *new_ptr,
341
 
                               unsigned char *new_null_ptr,
 
371
  virtual Field *new_key_field(MEM_ROOT *root, Table *new_table,
 
372
                               unsigned char *new_ptr, unsigned char *new_null_ptr,
342
373
                               uint32_t new_null_bit);
343
 
  /** This is used to generate a field in Table from TableShare */
344
 
  Field *clone(memory::Root *mem_root, Table *new_table);
 
374
  Field *clone(MEM_ROOT *mem_root, Table *new_table);
345
375
  inline void move_field(unsigned char *ptr_arg,unsigned char *null_ptr_arg,unsigned char null_bit_arg)
346
376
  {
347
 
    ptr= ptr_arg;
348
 
    null_ptr= null_ptr_arg;
349
 
    null_bit= null_bit_arg;
 
377
    ptr=ptr_arg; null_ptr=null_ptr_arg; null_bit=null_bit_arg;
350
378
  }
351
379
  inline void move_field(unsigned char *ptr_arg) { ptr=ptr_arg; }
352
 
  virtual void move_field_offset(ptrdiff_t ptr_diff)
 
380
  virtual void move_field_offset(my_ptrdiff_t ptr_diff)
353
381
  {
354
 
    ptr= ADD_TO_PTR(ptr,ptr_diff, unsigned char*);
 
382
    ptr=ADD_TO_PTR(ptr,ptr_diff, unsigned char*);
355
383
    if (null_ptr)
356
 
      null_ptr= ADD_TO_PTR(null_ptr,ptr_diff,unsigned char*);
357
 
  }
358
 
  virtual void get_image(unsigned char *buff, uint32_t length, const CHARSET_INFO * const)
359
 
  {
360
 
    memcpy(buff,ptr,length);
361
 
  }
362
 
  virtual void get_image(std::basic_string<unsigned char> &buff, uint32_t length, const CHARSET_INFO * const)
363
 
  {
364
 
    buff.append(ptr,length);
365
 
  }
366
 
  virtual void set_image(const unsigned char *buff,uint32_t length, const CHARSET_INFO * const)
367
 
  {
368
 
    memcpy(ptr,buff,length);
369
 
  }
370
 
 
371
 
  /**
372
 
   * Copy a field part into an output buffer.
373
 
   *
374
 
   * @details
375
 
   *
376
 
   * This function makes a copy of field part of size equal to or
377
 
   * less than "length" parameter value.
378
 
   * For fields of string types (VARCHAR, TEXT) the rest of buffer
379
 
   * is padded by zero byte.
380
 
   *
381
 
   * @param output buffer
382
 
   * @param output buffer size
383
 
   *
384
 
   * @note
385
 
   *
386
 
   * For variable length character fields (i.e. UTF-8) the "length"
387
 
   * parameter means a number of output buffer bytes as if all field
388
 
   * characters have maximal possible size (mbmaxlen). In the other words,
389
 
   * "length" parameter is a number of characters multiplied by
390
 
   * field_charset->mbmaxlen.
391
 
   *
392
 
   * @retval
393
 
   *   Number of copied bytes (excluding padded zero bytes -- see above).
394
 
   */
395
 
  virtual uint32_t get_key_image(unsigned char *buff, uint32_t length)
396
 
  {
397
 
    get_image(buff, length, &my_charset_bin);
398
 
    return length;
399
 
  }
400
 
  virtual uint32_t get_key_image(std::basic_string<unsigned char> &buff, uint32_t length)
 
384
      null_ptr=ADD_TO_PTR(null_ptr,ptr_diff,unsigned char*);
 
385
  }
 
386
  virtual void get_image(unsigned char *buff, uint32_t length,
 
387
                         const CHARSET_INFO * const cs __attribute__((unused)))
 
388
    { memcpy(buff,ptr,length); }
 
389
  virtual void set_image(const unsigned char *buff,uint32_t length,
 
390
                         const CHARSET_INFO * const cs __attribute__((unused)))
 
391
    { memcpy(ptr,buff,length); }
 
392
 
 
393
 
 
394
  /*
 
395
    Copy a field part into an output buffer.
 
396
 
 
397
    SYNOPSIS
 
398
      Field::get_key_image()
 
399
      buff   [out] output buffer
 
400
      length       output buffer size
 
401
      type         itMBR for geometry blobs, otherwise itRAW
 
402
 
 
403
    DESCRIPTION
 
404
      This function makes a copy of field part of size equal to or
 
405
      less than "length" parameter value.
 
406
      For fields of string types (CHAR, VARCHAR, TEXT) the rest of buffer
 
407
      is padded by zero byte.
 
408
 
 
409
    NOTES
 
410
      For variable length character fields (i.e. UTF-8) the "length"
 
411
      parameter means a number of output buffer bytes as if all field
 
412
      characters have maximal possible size (mbmaxlen). In the other words,
 
413
      "length" parameter is a number of characters multiplied by
 
414
      field_charset->mbmaxlen.
 
415
 
 
416
    RETURN
 
417
      Number of copied bytes (excluding padded zero bytes -- see above).
 
418
  */
 
419
 
 
420
  virtual uint32_t get_key_image(unsigned char *buff, uint32_t length,
 
421
                             imagetype type __attribute__((unused)))
401
422
  {
402
423
    get_image(buff, length, &my_charset_bin);
403
424
    return length;
404
425
  }
405
426
  virtual void set_key_image(const unsigned char *buff,uint32_t length)
406
 
  {
407
 
    set_image(buff,length, &my_charset_bin);
408
 
  }
 
427
    { set_image(buff,length, &my_charset_bin); }
409
428
  inline int64_t val_int_offset(uint32_t row_offset)
410
 
  {
411
 
    ptr+=row_offset;
412
 
    int64_t tmp=val_int();
413
 
    ptr-=row_offset;
414
 
    return tmp;
415
 
  }
416
 
 
 
429
    {
 
430
      ptr+=row_offset;
 
431
      int64_t tmp=val_int();
 
432
      ptr-=row_offset;
 
433
      return tmp;
 
434
    }
417
435
  inline int64_t val_int(const unsigned char *new_ptr)
418
436
  {
419
437
    unsigned char *old_ptr= ptr;
420
438
    int64_t return_value;
421
 
    ptr= const_cast<unsigned char*>(new_ptr);
 
439
    ptr= (unsigned char*) new_ptr;
422
440
    return_value= val_int();
423
441
    ptr= old_ptr;
424
442
    return return_value;
426
444
  inline String *val_str(String *str, const unsigned char *new_ptr)
427
445
  {
428
446
    unsigned char *old_ptr= ptr;
429
 
    ptr= const_cast<unsigned char*>(new_ptr);
 
447
    ptr= (unsigned char*) new_ptr;
430
448
    val_str(str);
431
449
    ptr= old_ptr;
432
450
    return str;
433
451
  }
434
 
 
435
 
  /**
436
 
    Pack the field into a format suitable for storage and transfer.
437
 
 
438
 
    To implement packing functionality, only the virtual function
439
 
    should be overridden. The other functions are just convenience
440
 
    functions and hence should not be overridden.
441
 
 
442
 
    The value of <code>low_byte_first</code> is dependent on how the
443
 
    packed data is going to be used: for local use, e.g., temporary
444
 
    store on disk or in memory, use the native format since that is
445
 
    faster. For data that is going to be transfered to other machines
446
 
    (e.g., when writing data to the binary log), data should always be
447
 
    stored in little-endian format.
448
 
 
449
 
    @note The default method for packing fields just copy the raw bytes
450
 
    of the record into the destination, but never more than
451
 
    <code>max_length</code> characters.
452
 
 
453
 
    @param to
454
 
    Pointer to memory area where representation of field should be put.
455
 
 
456
 
    @param from
457
 
    Pointer to memory area where record representation of field is
458
 
    stored.
459
 
 
460
 
    @param max_length
461
 
    Maximum length of the field, as given in the column definition. For
462
 
    example, for <code>CHAR(1000)</code>, the <code>max_length</code>
463
 
    is 1000. This information is sometimes needed to decide how to pack
464
 
    the data.
465
 
 
466
 
    @param low_byte_first
467
 
    @c true if integers should be stored little-endian, @c false if
468
 
    native format should be used. Note that for little-endian machines,
469
 
    the value of this flag is a moot point since the native format is
470
 
    little-endian.
471
 
  */
472
 
  virtual unsigned char *pack(unsigned char *to,
473
 
                              const unsigned char *from,
474
 
                              uint32_t max_length,
475
 
                              bool low_byte_first);
476
 
 
477
 
  unsigned char *pack(unsigned char *to, const unsigned char *from);
478
 
 
479
 
  /**
480
 
    Unpack a field from row data.
481
 
 
482
 
    This method is used to unpack a field from a master whose size of
483
 
    the field is less than that of the slave.
484
 
 
485
 
    The <code>param_data</code> parameter is a two-byte integer (stored
486
 
    in the least significant 16 bits of the unsigned integer) usually
487
 
    consisting of two parts: the real type in the most significant byte
488
 
    and a original pack length in the least significant byte.
489
 
 
490
 
    The exact layout of the <code>param_data</code> field is given by
491
 
    the <code>Table_map_log_event::save_field_metadata()</code>.
492
 
 
493
 
    This is the default method for unpacking a field. It just copies
494
 
    the memory block in byte order (of original pack length bytes or
495
 
    length of field, whichever is smaller).
496
 
 
497
 
    @param   to         Destination of the data
498
 
    @param   from       Source of the data
499
 
    @param   param_data Real type and original pack length of the field
500
 
                        data
501
 
 
502
 
    @param low_byte_first
503
 
    If this flag is @c true, all composite entities (e.g., lengths)
504
 
    should be unpacked in little-endian format; otherwise, the entities
505
 
    are unpacked in native order.
506
 
 
507
 
    @return  New pointer into memory based on from + length of the data
508
 
  */
509
 
  virtual const unsigned char *unpack(unsigned char* to,
510
 
                                      const unsigned char *from,
511
 
                                      uint32_t param_data,
512
 
                                      bool low_byte_first);
513
 
  /**
514
 
     @overload Field::unpack(unsigned char*, const unsigned char*,
515
 
                             uint32_t, bool)
516
 
  */
517
 
  const unsigned char *unpack(unsigned char* to,
518
 
                              const unsigned char *from);
519
 
 
520
 
  virtual unsigned char *pack_key(unsigned char* to,
521
 
                                  const unsigned char *from,
522
 
                                  uint32_t max_length,
523
 
                                  bool low_byte_first)
524
 
  {
525
 
    return pack(to, from, max_length, low_byte_first);
526
 
  }
527
 
  virtual const unsigned char *unpack_key(unsigned char* to,
528
 
                                          const unsigned char *from,
529
 
                                          uint32_t max_length,
530
 
                                          bool low_byte_first)
 
452
  virtual bool send_binary(Protocol *protocol);
 
453
 
 
454
  virtual unsigned char *pack(unsigned char *to, const unsigned char *from,
 
455
                      uint32_t max_length, bool low_byte_first);
 
456
  /**
 
457
     @overload Field::pack(unsigned char*, const unsigned char*, uint32_t, bool)
 
458
  */
 
459
  unsigned char *pack(unsigned char *to, const unsigned char *from)
 
460
  {
 
461
    unsigned char *result= this->pack(to, from, UINT_MAX, table->s->db_low_byte_first);
 
462
    return(result);
 
463
  }
 
464
 
 
465
  virtual const unsigned char *unpack(unsigned char* to, const unsigned char *from,
 
466
                              uint32_t param_data, bool low_byte_first);
 
467
  /**
 
468
     @overload Field::unpack(unsigned char*, const unsigned char*, uint32_t, bool)
 
469
  */
 
470
  const unsigned char *unpack(unsigned char* to, const unsigned char *from)
 
471
  {
 
472
    const unsigned char *result= unpack(to, from, 0U, table->s->db_low_byte_first);
 
473
    return(result);
 
474
  }
 
475
 
 
476
  virtual unsigned char *pack_key(unsigned char* to, const unsigned char *from,
 
477
                          uint32_t max_length, bool low_byte_first)
 
478
  {
 
479
    return pack(to, from, max_length, low_byte_first);
 
480
  }
 
481
  virtual unsigned char *pack_key_from_key_image(unsigned char* to, const unsigned char *from,
 
482
                                        uint32_t max_length, bool low_byte_first)
 
483
  {
 
484
    return pack(to, from, max_length, low_byte_first);
 
485
  }
 
486
  virtual const unsigned char *unpack_key(unsigned char* to, const unsigned char *from,
 
487
                                  uint32_t max_length, bool low_byte_first)
531
488
  {
532
489
    return unpack(to, from, max_length, low_byte_first);
533
490
  }
 
491
  virtual uint32_t packed_col_length(const unsigned char *to __attribute__((unused)),
 
492
                                 uint32_t length)
 
493
  { return length;}
534
494
  virtual uint32_t max_packed_col_length(uint32_t max_length)
535
 
  {
536
 
    return max_length;
537
 
  }
 
495
  { return max_length;}
538
496
 
539
 
  inline uint32_t offset(unsigned char *record)
 
497
  virtual int pack_cmp(const unsigned char *a,const unsigned char *b,
 
498
                       uint32_t key_length_arg __attribute__((unused)),
 
499
                       bool insert_or_update __attribute__((unused)))
 
500
  { return cmp(a,b); }
 
501
  virtual int pack_cmp(const unsigned char *b,
 
502
                       uint32_t key_length_arg __attribute__((unused)),
 
503
                       bool insert_or_update __attribute__((unused)))
 
504
  { return cmp(ptr,b); }
 
505
  uint32_t offset(unsigned char *record)
540
506
  {
541
507
    return (uint32_t) (ptr - record);
542
508
  }
547
513
  virtual const CHARSET_INFO *charset(void) const { return &my_charset_bin; }
548
514
  virtual const CHARSET_INFO *sort_charset(void) const { return charset(); }
549
515
  virtual bool has_charset(void) const { return false; }
550
 
  virtual void set_charset(const CHARSET_INFO * const)
551
 
  {}
 
516
  virtual void set_charset(const CHARSET_INFO * const charset_arg __attribute__((unused)))
 
517
  { }
552
518
  virtual enum Derivation derivation(void) const
553
 
  {
554
 
    return DERIVATION_IMPLICIT;
555
 
  }
556
 
  virtual void set_derivation(enum Derivation)
557
 
  {}
558
 
  /**
559
 
    Produce warning or note about data saved into field.
560
 
 
561
 
    @param level            - level of message (Note/Warning/Error)
562
 
    @param code             - error code of message to be produced
563
 
    @param cuted_increment  - whenever we should increase cut fields count or not
564
 
 
565
 
    @note
566
 
      This function won't produce warning and increase cut fields counter
567
 
      if count_cuted_fields == CHECK_FIELD_IGNORE for current thread.
568
 
 
569
 
      if count_cuted_fields == CHECK_FIELD_IGNORE then we ignore notes.
570
 
      This allows us to avoid notes in optimisation, like convert_constant_item().
571
 
 
572
 
    @retval
573
 
      1 if count_cuted_fields == CHECK_FIELD_IGNORE and error level is not NOTE
574
 
    @retval
575
 
      0 otherwise
576
 
  */
577
 
  bool set_warning(DRIZZLE_ERROR::enum_warning_level,
578
 
                   unsigned int code,
 
519
  { return DERIVATION_IMPLICIT; }
 
520
  virtual void set_derivation(enum Derivation derivation_arg __attribute__((unused)))
 
521
  { }
 
522
  bool set_warning(DRIZZLE_ERROR::enum_warning_level, unsigned int code,
579
523
                   int cuted_increment);
580
 
  /**
581
 
    Produce warning or note about datetime string data saved into field.
582
 
 
583
 
    @param level            level of message (Note/Warning/Error)
584
 
    @param code             error code of message to be produced
585
 
    @param str              string value which we tried to save
586
 
    @param str_length       length of string which we tried to save
587
 
    @param ts_type          type of datetime value (datetime/date/time)
588
 
    @param cuted_increment  whenever we should increase cut fields count or not
589
 
 
590
 
    @note
591
 
      This function will always produce some warning but won't increase cut
592
 
      fields counter if count_cuted_fields ==FIELD_CHECK_IGNORE for current
593
 
      thread.
594
 
  */
595
 
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level,
596
 
                            uint32_t code,
597
 
                            const char *str,
598
 
                            uint32_t str_len,
599
 
                            enum enum_drizzle_timestamp_type ts_type,
600
 
                            int cuted_increment);
601
 
  /**
602
 
    Produce warning or note about integer datetime value saved into field.
603
 
 
604
 
    @param level            level of message (Note/Warning/Error)
605
 
    @param code             error code of message to be produced
606
 
    @param nr               numeric value which we tried to save
607
 
    @param ts_type          type of datetime value (datetime/date/time)
608
 
    @param cuted_increment  whenever we should increase cut fields count or not
609
 
 
610
 
    @note
611
 
      This function will always produce some warning but won't increase cut
612
 
      fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current
613
 
      thread.
614
 
  */
615
 
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level,
616
 
                            uint32_t code,
617
 
                            int64_t nr,
618
 
                            enum enum_drizzle_timestamp_type ts_type,
619
 
                            int cuted_increment);
620
 
  /**
621
 
    Produce warning or note about double datetime data saved into field.
622
 
 
623
 
    @param level            level of message (Note/Warning/Error)
624
 
    @param code             error code of message to be produced
625
 
    @param nr               double value which we tried to save
626
 
    @param ts_type          type of datetime value (datetime/date/time)
627
 
 
628
 
    @note
629
 
      This function will always produce some warning but won't increase cut
630
 
      fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current
631
 
      thread.
632
 
  */
633
 
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level,
634
 
                            const uint32_t code,
635
 
                            double nr,
636
 
                            enum enum_drizzle_timestamp_type ts_type);
 
524
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level, uint32_t code, 
 
525
                            const char *str, uint32_t str_len,
 
526
                            enum enum_drizzle_timestamp_type ts_type, int cuted_increment);
 
527
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level, uint32_t code, 
 
528
                            int64_t nr, enum enum_drizzle_timestamp_type ts_type,
 
529
                            int cuted_increment);
 
530
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level, const uint32_t code, 
 
531
                            double nr, enum enum_drizzle_timestamp_type ts_type);
637
532
  inline bool check_overflow(int op_result)
638
533
  {
639
534
    return (op_result == E_DEC_OVERFLOW);
640
535
  }
641
 
  /**
642
 
    Process decimal library return codes and issue warnings for overflow and
643
 
    truncation.
644
 
 
645
 
    @param op_result  decimal library return code (E_DEC_* see include/decimal.h)
646
 
 
647
 
    @retval
648
 
      E_DEC_OVERFLOW   there was overflow
649
 
      E_DEC_TRUNCATED  there was truncation
650
 
    @retval
651
 
      0  no error or there was some other error except overflow or truncation
652
 
  */
653
536
  int warn_if_overflow(int op_result);
654
 
  void init(Table *table_arg);
 
537
  void init(Table *table_arg)
 
538
  {
 
539
    orig_table= table= table_arg;
 
540
    table_name= &table_arg->alias;
 
541
  }
655
542
 
656
543
  /* maximum possible display length */
657
544
  virtual uint32_t max_display_length()= 0;
658
545
 
659
 
  virtual uint32_t is_equal(CreateField *new_field);
660
 
  /**
661
 
    Conversion from decimal to int64_t with checking overflow and
662
 
    setting correct value (min/max) in case of overflow.
663
 
 
664
 
    @param val             value which have to be converted
665
 
    @param unsigned_flag   type of integer in which we convert val
666
 
    @param err             variable to pass error code
667
 
 
668
 
    @return
669
 
      value converted from val
670
 
  */
671
 
  int64_t convert_decimal2int64_t(const my_decimal *val,
672
 
                                  bool unsigned_flag,
673
 
                                  int *err);
 
546
  virtual uint32_t is_equal(Create_field *new_field);
 
547
  /* convert decimal to int64_t with overflow check */
 
548
  int64_t convert_decimal2int64_t(const my_decimal *val, bool unsigned_flag,
 
549
                                    int *err);
674
550
  /* The max. number of characters */
675
551
  inline uint32_t char_length() const
676
552
  {
686
562
  /* Hash value */
687
563
  virtual void hash(uint32_t *nr, uint32_t *nr2);
688
564
  friend bool reopen_table(Session *,Table *,bool);
689
 
 
690
 
  friend class CopyField;
 
565
  friend int cre_myisam(char * name, register Table *form, uint32_t options,
 
566
                        uint64_t auto_increment_value);
 
567
  friend class Copy_field;
691
568
  friend class Item_avg_field;
692
569
  friend class Item_std_field;
693
570
  friend class Item_sum_num;
700
577
  friend class Item_sum_max;
701
578
  friend class Item_func_group_concat;
702
579
 
703
 
  bool isReadSet();
704
 
  bool isWriteSet();
705
 
  void setReadSet(bool arg= true);
706
 
  void setWriteSet(bool arg= true);
707
 
};
708
 
 
709
 
} /* namespace drizzled */
710
 
 
711
 
/** @TODO Why is this in the middle of the file???*/
712
 
#include "drizzled/create_field.h"
713
 
 
714
 
namespace drizzled
715
 
{
 
580
private:
 
581
  /*
 
582
    Primitive for implementing last_null_byte().
 
583
 
 
584
    SYNOPSIS
 
585
      do_last_null_byte()
 
586
 
 
587
    DESCRIPTION
 
588
      Primitive for the implementation of the last_null_byte()
 
589
      function. This represents the inheritance interface and can be
 
590
      overridden by subclasses.
 
591
   */
 
592
  virtual size_t do_last_null_byte() const;
716
593
 
717
594
/**
718
 
 * A class for sending field information to a client.
719
 
 *
720
 
 * @details
721
 
 *
722
 
 * Send_field is basically a stripped-down POD class for
723
 
 * representing basic information about a field...
724
 
 */
725
 
class SendField
 
595
   Retrieve the field metadata for fields.
 
596
 
 
597
   This default implementation returns 0 and saves 0 in the metadata_ptr
 
598
   value.
 
599
 
 
600
   @param   metadata_ptr   First byte of field metadata
 
601
 
 
602
   @returns 0 no bytes written.
 
603
*/
 
604
  virtual int do_save_field_metadata(unsigned char *metadata_ptr __attribute__((unused)))
 
605
  { return 0; }
 
606
};
 
607
 
 
608
/*
 
609
  Create field class for CREATE TABLE
 
610
*/
 
611
 
 
612
class Create_field :public Sql_alloc
726
613
{
727
614
public:
 
615
  const char *field_name;
 
616
  const char *change;                   // If done with alter table
 
617
  const char *after;                    // Put column after this one
 
618
  LEX_STRING comment;                   // Comment for field
 
619
  Item  *def;                           // Default value
 
620
  enum  enum_field_types sql_type;
 
621
  /*
 
622
    At various stages in execution this can be length of field in bytes or
 
623
    max number of characters. 
 
624
  */
 
625
  uint32_t length;
 
626
  /*
 
627
    The value of `length' as set by parser: is the number of characters
 
628
    for most of the types, or of bytes for BLOBs or numeric types.
 
629
  */
 
630
  uint32_t char_length;
 
631
  uint32_t  decimals, flags, pack_length, key_length;
 
632
  Field::utype unireg_check;
 
633
  TYPELIB *interval;                    // Which interval to use
 
634
  TYPELIB *save_interval;               // Temporary copy for the above
 
635
                                        // Used only for UCS2 intervals
 
636
  List<String> interval_list;
 
637
  const CHARSET_INFO *charset;
 
638
  Field *field;                         // For alter table
 
639
 
 
640
  uint8_t row,col,sc_length,interval_id;        // For rea_create_table
 
641
  uint32_t      offset,pack_flag;
 
642
 
 
643
  /* Virtual column expression statement */
 
644
  virtual_column_info *vcol_info;
 
645
  /*
 
646
    Indication that the field is phycically stored in tables 
 
647
    rather than just generated on SQL queries.
 
648
    As of now, FALSE can only be set for generated-only virtual columns.
 
649
  */
 
650
  bool is_stored;
 
651
 
 
652
  Create_field() :after(0) {}
 
653
  Create_field(Field *field, Field *orig_field);
 
654
  /* Used to make a clone of this object for ALTER/CREATE TABLE */
 
655
  Create_field *clone(MEM_ROOT *mem_root) const
 
656
    { return new (mem_root) Create_field(*this); }
 
657
  void create_length_to_internal_length(void);
 
658
 
 
659
  inline enum column_format_type column_format() const
 
660
  {
 
661
    return (enum column_format_type)
 
662
      ((flags >> COLUMN_FORMAT_FLAGS) & COLUMN_FORMAT_MASK);
 
663
  }
 
664
 
 
665
  /* Init for a tmp table field. To be extended if need be. */
 
666
  void init_for_tmp_table(enum_field_types sql_type_arg,
 
667
                          uint32_t max_length, uint32_t decimals,
 
668
                          bool maybe_null, bool is_unsigned);
 
669
 
 
670
  bool init(Session *session, char *field_name, enum_field_types type, char *length,
 
671
            char *decimals, uint32_t type_modifier, Item *default_value,
 
672
            Item *on_update_value, LEX_STRING *comment, char *change,
 
673
            List<String> *interval_list, const CHARSET_INFO * const cs,
 
674
            uint32_t uint_geom_type,
 
675
            enum column_format_type column_format,
 
676
            virtual_column_info *vcol_info);
 
677
};
 
678
 
 
679
 
 
680
/*
 
681
  A class for sending info to the client
 
682
*/
 
683
 
 
684
class Send_field {
 
685
 public:
728
686
  const char *db_name;
729
 
  const char *table_name;
730
 
  const char *org_table_name;
731
 
  const char *col_name;
732
 
  const char *org_col_name;
 
687
  const char *table_name,*org_table_name;
 
688
  const char *col_name,*org_col_name;
733
689
  uint32_t length;
734
 
  uint32_t charsetnr;
735
 
  uint32_t flags;
736
 
  uint32_t decimals;
 
690
  uint32_t charsetnr, flags, decimals;
737
691
  enum_field_types type;
738
 
  SendField() {}
 
692
  Send_field() {}
739
693
};
740
694
 
741
 
/**
742
 
 * A class for quick copying data to fields
743
 
 */
744
 
class CopyField :public memory::SqlAlloc
745
 
{
 
695
 
 
696
/*
 
697
  A class for quick copying data to fields
 
698
*/
 
699
 
 
700
class Copy_field :public Sql_alloc {
746
701
  /**
747
702
    Convenience definition of a copy function returned by
748
703
    get_copy_func.
749
704
  */
750
 
  typedef void Copy_func(CopyField*);
 
705
  typedef void Copy_func(Copy_field*);
751
706
  Copy_func *get_copy_func(Field *to, Field *from);
752
707
public:
753
 
  unsigned char *from_ptr;
754
 
  unsigned char *to_ptr;
755
 
  unsigned char *from_null_ptr;
756
 
  unsigned char *to_null_ptr;
 
708
  unsigned char *from_ptr,*to_ptr;
 
709
  unsigned char *from_null_ptr,*to_null_ptr;
757
710
  bool *null_row;
758
 
  uint32_t from_bit;
759
 
  uint32_t to_bit;
760
 
  uint32_t from_length;
761
 
  uint32_t to_length;
762
 
  Field *from_field;
763
 
  Field *to_field;
 
711
  uint32_t      from_bit,to_bit;
 
712
  uint32_t from_length,to_length;
 
713
  Field *from_field,*to_field;
764
714
  String tmp;                                   // For items
765
715
 
766
 
  CopyField() {}
767
 
  ~CopyField() {}
768
 
  void set(Field *to,Field *from,bool save);    // Field to field
 
716
  Copy_field() {}
 
717
  ~Copy_field() {}
 
718
  void set(Field *to,Field *from,bool save);    // Field to field 
769
719
  void set(unsigned char *to,Field *from);              // Field to string
770
 
  void (*do_copy)(CopyField *);
771
 
  void (*do_copy2)(CopyField *);                // Used to handle null values
 
720
  void (*do_copy)(Copy_field *);
 
721
  void (*do_copy2)(Copy_field *);               // Used to handle null values
772
722
};
773
723
 
774
 
Field *make_field(TableShare *share,
775
 
                  memory::Root *root,
776
 
                  unsigned char *ptr,
777
 
                  uint32_t field_length,
778
 
                  bool is_nullable,
779
 
                  unsigned char *null_pos,
780
 
                  unsigned char null_bit,
781
 
                  uint8_t decimals,
782
 
                  enum_field_types field_type,
 
724
 
 
725
Field *make_field(TABLE_SHARE *share, unsigned char *ptr, uint32_t field_length,
 
726
                  unsigned char *null_pos, unsigned char null_bit,
 
727
                  uint32_t pack_flag, enum_field_types field_type,
783
728
                  const CHARSET_INFO * cs,
784
729
                  Field::utype unireg_check,
785
 
                  TYPELIB *interval,
786
 
                  const char *field_name);
 
730
                  TYPELIB *interval, const char *field_name);
787
731
 
788
732
uint32_t pack_length_to_packflag(uint32_t type);
 
733
enum_field_types get_blob_type_from_length(uint32_t length);
789
734
uint32_t calc_pack_length(enum_field_types type,uint32_t length);
790
735
int set_field_to_null(Field *field);
791
736
int set_field_to_null_with_conversions(Field *field, bool no_conversions);
792
737
 
793
 
/**
794
 
 * Tests if the given string contains important data:
795
 
 * not spaces for character string, or any data for binary string.
796
 
 *
797
 
 * @param pointer to the character set to use
798
 
 * @param String to test
799
 
 * @param String end
800
 
 *
801
 
 * @retval
802
 
 *  false - If string does not have important data
803
 
 * @retval
804
 
 *  true  - If string has some important data
 
738
 
 
739
bool
 
740
test_if_important_data(const CHARSET_INFO * const cs, 
 
741
                       const char *str,
 
742
                       const char *strend);
 
743
 
 
744
/*
 
745
  Field subclasses
805
746
 */
806
 
bool test_if_important_data(const CHARSET_INFO * const cs,
807
 
                            const char *str,
808
 
                            const char *strend);
809
 
 
810
 
} /* namespace drizzled */
 
747
#include <drizzled/field/str.h>
 
748
#include <drizzled/field/longstr.h>
 
749
#include <drizzled/field/num.h>
 
750
#include <drizzled/field/blob.h>
 
751
#include <drizzled/field/enum.h>
 
752
#include <drizzled/field/null.h>
 
753
#include <drizzled/field/date.h>
 
754
#include <drizzled/field/fdecimal.h>
 
755
#include <drizzled/field/real.h>
 
756
#include <drizzled/field/double.h>
 
757
#include <drizzled/field/long.h>
 
758
#include <drizzled/field/int64_t.h>
 
759
#include <drizzled/field/num.h>
 
760
#include <drizzled/field/timetype.h>
 
761
#include <drizzled/field/timestamp.h>
 
762
#include <drizzled/field/datetime.h>
 
763
#include <drizzled/field/fstring.h>
 
764
#include <drizzled/field/varstring.h>
 
765
 
 
766
/*
 
767
  The following are for the interface with the .frm file
 
768
*/
 
769
 
 
770
#define FIELDFLAG_DECIMAL               1
 
771
#define FIELDFLAG_BINARY                1       // Shares same flag
 
772
#define FIELDFLAG_NUMBER                2
 
773
#define FIELDFLAG_DECIMAL_POSITION      4
 
774
#define FIELDFLAG_PACK                  120     // Bits used for packing
 
775
#define FIELDFLAG_INTERVAL              256     // mangled with decimals!
 
776
#define FIELDFLAG_BLOB                  1024    // mangled with decimals!
 
777
 
 
778
#define FIELDFLAG_NO_DEFAULT            16384   /* sql */
 
779
#define FIELDFLAG_SUM                   ((uint32_t) 32768)// predit: +#fieldflag
 
780
#define FIELDFLAG_MAYBE_NULL            ((uint32_t) 32768)// sql
 
781
#define FIELDFLAG_HEX_ESCAPE            ((uint32_t) 0x10000)
 
782
#define FIELDFLAG_PACK_SHIFT            3
 
783
#define FIELDFLAG_DEC_SHIFT             8
 
784
#define FIELDFLAG_MAX_DEC               31
 
785
 
 
786
#define MTYP_TYPENR(type) (type & 127)  /* Remove bits from type */
 
787
 
 
788
#define f_is_dec(x)             ((x) & FIELDFLAG_DECIMAL)
 
789
#define f_is_num(x)             ((x) & FIELDFLAG_NUMBER)
 
790
#define f_is_decimal_precision(x)       ((x) & FIELDFLAG_DECIMAL_POSITION)
 
791
#define f_is_packed(x)          ((x) & FIELDFLAG_PACK)
 
792
#define f_packtype(x)           (((x) >> FIELDFLAG_PACK_SHIFT) & 15)
 
793
#define f_decimals(x)           ((uint8_t) (((x) >> FIELDFLAG_DEC_SHIFT) & FIELDFLAG_MAX_DEC))
 
794
#define f_is_alpha(x)           (!f_is_num(x))
 
795
#define f_is_binary(x)          ((x) & FIELDFLAG_BINARY) // 4.0- compatibility
 
796
#define f_is_enum(x)            (((x) & (FIELDFLAG_INTERVAL | FIELDFLAG_NUMBER)) == FIELDFLAG_INTERVAL)
 
797
#define f_is_blob(x)            (((x) & (FIELDFLAG_BLOB | FIELDFLAG_NUMBER)) == FIELDFLAG_BLOB)
 
798
#define f_is_equ(x)             ((x) & (1+2+FIELDFLAG_PACK+31*256))
 
799
#define f_settype(x)   (((int) x) << FIELDFLAG_PACK_SHIFT)
 
800
#define f_maybe_null(x)         (x & FIELDFLAG_MAYBE_NULL)
 
801
#define f_no_default(x)         (x & FIELDFLAG_NO_DEFAULT)
 
802
#define f_is_hex_escape(x)      ((x) & FIELDFLAG_HEX_ESCAPE)
 
803
 
 
804
bool
 
805
check_string_copy_error(Field_str *field,
 
806
                        const char *well_formed_error_pos,
 
807
                        const char *cannot_convert_error_pos,
 
808
                        const char *end,
 
809
                        const CHARSET_INFO * const cs);
811
810
 
812
811
#endif /* DRIZZLED_FIELD_H */