← Back to branch summary

~drizzle-pbxt/drizzle/drizzle-pbxt-2

« back to all changes in this revision

Viewing changes to drizzled/field.h

  • Committer: Paul McCullagh
  • Date: 2009-11-10 14:18:39 UTC
  • mfrom: (1038.1.7 drizzle-pbxt-pre-merge)
  • Revision ID: paul.mccullagh@primebase.org-20091110141839-2j3k43b17ag6f605
Merged Drizzle trunk and PBXT 1.0.09

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