← 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-10-16 06:32:30 UTC
  • mto: (511.1.5 codestyle)
  • mto: This revision was merged to the branch mainline in revision 521.
  • Revision ID: monty@inaugust.com-20081016063230-4brxsra0qsmsg84q
Added -Wunused-macros.

Show diffs side-by-side

added added

removed removed

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