← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.h

  • Committer: Lee Bieber
  • Date: 2009-10-20 20:39:01 UTC
  • mto: This revision was merged to the branch mainline in revision 1191.
  • Revision ID: lbieber@dhcp-umpk18-111-94.sfbay.sun.com-20091020203901-wmeq850fgv7iiqff
Add test case for MySQL BUG #42742: crash in setup_sj_materialization, Copy_field::set
If a semi-join strategy covers certain [first_table; last_table] range in join order, do reset the sj_strategy member for all tables within the range, except the first one.  Failure to do so caused EXPLAIN/execution code to try applying two strategies at once which would cause all kinds of undesired effects. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field.h
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008 Sun Microsystems
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
22
22
  variables must declare the size_of() member function.
23
23
*/
24
24
 
25
 
 
26
 
 
27
25
#ifndef DRIZZLED_FIELD_H
28
26
#define DRIZZLED_FIELD_H
29
27
 
30
28
#include "drizzled/sql_error.h"
31
 
#include "drizzled/type/decimal.h"
 
29
#include "drizzled/my_decimal.h"
32
30
#include "drizzled/key_map.h"
 
31
#include "drizzled/sql_bitmap.h"
33
32
#include "drizzled/sql_list.h"
34
33
#include "drizzled/structs.h"
35
 
#include "drizzled/charset_info.h"
36
 
#include "drizzled/item_result.h"
37
 
#include "drizzled/charset_info.h"
38
34
 
39
35
#include <string>
40
36
#include <vector>
41
37
 
42
 
#include "drizzled/visibility.h"
43
 
 
44
 
namespace drizzled
45
 
{
46
 
 
47
38
#define DATETIME_DEC                     6
48
39
#define DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE FLOATING_POINT_BUFFER
49
40
 
50
41
#ifdef DEBUG
51
 
#define ASSERT_COLUMN_MARKED_FOR_READ assert(!getTable() || (getTable()->read_set == NULL || isReadSet()))
52
 
#define ASSERT_COLUMN_MARKED_FOR_WRITE assert(!getTable() || (getTable()->write_set == NULL || isWriteSet()))
 
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()))
53
44
#else
54
 
#define ASSERT_COLUMN_MARKED_FOR_READ assert(getTable())
55
 
#define ASSERT_COLUMN_MARKED_FOR_WRITE assert(getTable())
 
45
#define ASSERT_COLUMN_MARKED_FOR_READ
 
46
#define ASSERT_COLUMN_MARKED_FOR_WRITE
56
47
#endif
57
48
 
58
 
typedef struct st_typelib TYPELIB;
59
 
 
60
49
const uint32_t max_field_size= (uint32_t) 4294967295U;
61
50
 
62
51
class SendField;
63
52
class CreateField;
64
53
class TableShare;
65
54
class Field;
66
 
struct CacheField;
 
55
struct st_cache_field;
67
56
 
68
57
int field_conv(Field *to,Field *from);
69
58
 
 
59
inline uint32_t get_enum_pack_length(int elements)
 
60
{
 
61
  return elements < 256 ? 1 : 2;
 
62
}
 
63
 
70
64
/**
71
65
 * Class representing a Field in a Table
72
66
 *
73
67
 * @details
74
68
 *
75
 
 * The value stored in the Field object is stored in the
 
69
 * The value stored in the Field object is stored in the 
76
70
 * unsigned char pointer member variable called ptr.  The
77
 
 * val_xxx() methods retrieve this raw byte value and
 
71
 * val_xxx() methods retrieve this raw byte value and 
78
72
 * convert the byte into the appropriate output (int, decimal, etc).
79
73
 *
80
74
 * The store_xxx() methods take various input and convert
81
75
 * the input into the raw bytes stored in the ptr member variable.
82
76
 */
83
 
class DRIZZLED_API Field
 
77
class Field
84
78
{
85
79
  /* Prevent use of these */
86
 
  Field(const Field&);
 
80
  Field(const Field&); 
87
81
  void operator=(Field &);
88
 
 
89
82
public:
90
83
  unsigned char *ptr; /**< Position to field in record. Stores raw field value */
91
84
  unsigned char *null_ptr; /**< Byte where null_bit is */
92
85
 
93
86
  /**
94
 
   * Pointer to the Table object containing this Field
 
87
   * Pointer to the Table object containing this Field 
95
88
   *
96
89
   * @note You can use table->in_use as replacement for current_session member
97
90
   * only inside of val_*() and store() members (e.g. you can't use it in cons)
98
91
   */
99
 
private:
100
 
  Table *table;
101
 
 
102
 
public:
103
 
  Table *getTable()
104
 
  {
105
 
    assert(table);
106
 
    return table;
107
 
  }
108
 
 
109
 
  Table *getTable() const
110
 
  {
111
 
    assert(table);
112
 
    return table;
113
 
  }
114
 
 
115
 
  void setTable(Table *table_arg)
116
 
  {
117
 
    table= table_arg;
118
 
  }
119
 
 
 
92
  Table *table; 
120
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. */
121
95
  const char *field_name; /**< Name of the field */
122
96
  LEX_STRING comment; /**< A comment about the field */
123
97
 
128
102
  key_map part_of_sortkey;
129
103
 
130
104
  /*
131
 
    We use three additional unireg types for TIMESTAMP for hysterical
132
 
    raisins and limitations in the MySQL FRM file format.
133
 
 
134
 
    A good TODO is to clean this up as we can support just about
135
 
    anything in the table proto message now.
 
105
    We use three additional unireg types for TIMESTAMP to overcome limitation
 
106
    of current binary format of .frm file. We'd like to be able to support
 
107
    NOW() as default and on update value for such fields but unable to hold
 
108
    this info anywhere except unireg_check field. This issue will be resolved
 
109
    in more clean way with transition to new text based .frm format.
 
110
    See also comment for Field_timestamp::Field_timestamp().
136
111
  */
137
112
  enum utype
138
 
  {
 
113
  { 
139
114
    NONE,
140
115
    NEXT_NUMBER,
141
116
    TIMESTAMP_OLD_FIELD,
147
122
  utype unireg_check;
148
123
  uint32_t field_length; /**< Length of this field in bytes */
149
124
  uint32_t flags;
150
 
 
151
 
  bool isUnsigned() const
152
 
  {
153
 
    return flags & UNSIGNED_FLAG;
154
 
  }
155
 
 
156
 
private:
157
125
  uint16_t field_index; /**< Index of this Field in Table::fields array */
158
 
 
159
 
public:
160
 
 
161
 
  uint16_t position() const
162
 
  {
163
 
    return field_index;
164
 
  }
165
 
 
166
 
  void setPosition(uint32_t arg)
167
 
  {
168
 
    field_index= arg;
169
 
  }
170
 
 
171
126
  unsigned char null_bit; /**< Bit used to test null bit */
172
127
  /**
173
128
     If true, this field was created in create_tmp_field_from_item from a NULL
179
134
   */
180
135
  bool is_created_from_null_item;
181
136
 
182
 
  static void *operator new(size_t size);
183
 
  static void *operator new(size_t size, memory::Root *mem_root);
 
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); }
184
140
  static void operator delete(void *, size_t)
185
 
  { }
186
 
  static void operator delete(void *, memory::Root *)
187
 
  { }
 
141
  { TRASH(ptr_arg, size); }
188
142
 
189
143
  Field(unsigned char *ptr_arg,
190
144
        uint32_t length_arg,
193
147
        utype unireg_check_arg,
194
148
        const char *field_name_arg);
195
149
  virtual ~Field() {}
196
 
 
197
 
  bool hasDefault() const
198
 
  {
199
 
    return not (flags & NO_DEFAULT_VALUE_FLAG);
200
 
  }
201
 
 
202
150
  /* Store functions returns 1 on overflow and -1 on fatal error */
203
 
  virtual int store(const char *to,
204
 
                    uint32_t length,
 
151
  virtual int store(const char *to, 
 
152
                    uint32_t length, 
205
153
                    const CHARSET_INFO * const cs)=0;
206
154
  virtual int store(double nr)=0;
207
155
  virtual int store(int64_t nr, bool unsigned_val)=0;
208
 
  virtual int store_decimal(const type::Decimal *d)=0;
209
 
  int store_and_check(enum_check_fields check_level,
210
 
                      const char *to,
211
 
                      uint32_t length,
212
 
                      const CHARSET_INFO * const cs);
 
156
  virtual int store_decimal(const my_decimal *d)=0;
 
157
  int store(const char *to, 
 
158
            uint32_t length,
 
159
            const CHARSET_INFO * const cs,
 
160
            enum_check_fields check_level);
213
161
  /**
214
162
    This is called when storing a date in a string.
215
163
 
216
164
    @note
217
165
      Needs to be changed if/when we want to support different time formats.
218
166
  */
219
 
  virtual int store_time(type::Time &ltime, type::timestamp_t t_type);
220
 
  virtual double val_real()=0;
221
 
  virtual int64_t val_int()=0;
222
 
  virtual type::Decimal *val_decimal(type::Decimal *);
223
 
  String *val_str_internal(String *str)
 
167
  virtual int store_time(DRIZZLE_TIME *ltime, enum enum_drizzle_timestamp_type t_type);
 
168
  virtual double val_real(void)=0;
 
169
  virtual int64_t val_int(void)=0;
 
170
  virtual my_decimal *val_decimal(my_decimal *);
 
171
  inline String *val_str(String *str) 
224
172
  {
225
173
    return val_str(str, str);
226
174
  }
227
 
 
228
175
  /*
229
176
     val_str(buf1, buf2) gets two buffers and should use them as follows:
230
177
     if it needs a temp buffer to convert result to string - use buf1
238
185
     This trickery is used to decrease a number of malloc calls.
239
186
  */
240
187
  virtual String *val_str(String*, String *)=0;
241
 
 
 
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
   */
 
193
  String *val_int_as_str(String *val_buffer, bool unsigned_flag);
242
194
  /*
243
195
   str_needs_quotes() returns true if the value returned by val_str() needs
244
196
   to be quoted when used in constructing an SQL query.
247
199
  virtual Item_result result_type () const=0;
248
200
  virtual Item_result cmp_type () const { return result_type(); }
249
201
  virtual Item_result cast_to_int_type () const { return result_type(); }
250
 
 
251
202
  /**
252
203
     Check whether a field type can be partially indexed by a key.
253
204
 
254
205
     This is a static method, rather than a virtual function, because we need
255
 
     to check the type of a non-Field in alter_table().
 
206
     to check the type of a non-Field in mysql_alter_table().
256
207
 
257
208
     @param type  field type
258
209
 
294
245
   */
295
246
  virtual bool eq_def(Field *field);
296
247
 
297
 
  virtual bool is_timestamp() const
298
 
  {
299
 
    return false;
300
 
  }
301
 
 
302
248
  /**
303
249
   * Returns size (in bytes) used to store field data in memory
304
250
   * (i.e. it returns the maximum size of the field in a row of the table,
312
258
   * table, which is located on disk).
313
259
   */
314
260
  virtual uint32_t pack_length_in_rec() const;
315
 
 
316
 
  /**
317
 
   * Return the "real size" of the data in memory.
 
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
  */
 
274
  virtual int compatible_field_size(uint32_t field_metadata);
 
275
  virtual uint32_t pack_length_from_metadata(uint32_t field_metadata);
 
276
 
 
277
  /*
 
278
    This method is used to return the size of the data in a row-based
 
279
    replication row record. The default implementation of returning 0 is
 
280
    designed to allow fields that do not use metadata to return true (1)
 
281
    from compatible_field_size() which uses this function in the comparison.
 
282
    The default value for field metadata for fields that do not have
 
283
    metadata is 0. Thus, 0 == 0 means the fields are compatible in size.
 
284
 
 
285
    Note: While most classes that override this method return pack_length(),
 
286
    the classes Field_varstring, and Field_blob return
 
287
    field_length + 1, field_length, and pack_length_no_ptr() respectfully.
 
288
  */
 
289
  virtual uint32_t row_pack_length();
 
290
  virtual int save_field_metadata(unsigned char *first_byte);
 
291
 
 
292
  /**
 
293
   * Return the "real size" of the data in memory. 
318
294
   * For varstrings, this does _not_ include the length bytes.
319
295
   */
320
296
  virtual uint32_t data_length();
342
318
  virtual uint32_t key_length() const;
343
319
  virtual enum_field_types type() const =0;
344
320
  virtual enum_field_types real_type() const;
345
 
  virtual int cmp_max(const unsigned char *a, const unsigned char *b, uint32_t max_len);
 
321
  inline  int cmp(const unsigned char *str) { return cmp(ptr,str); }
 
322
  virtual int cmp_max(const unsigned char *a, const unsigned char *b,
 
323
                      uint32_t max_len);
346
324
  virtual int cmp(const unsigned char *,const unsigned char *)=0;
347
 
  int cmp_internal(const unsigned char *str) { return cmp(ptr,str); }
348
325
  virtual int cmp_binary(const unsigned char *a,const unsigned char *b,
349
326
                         uint32_t max_length=UINT32_MAX);
350
327
  virtual int cmp_offset(uint32_t row_offset);
363
340
  // For new field
364
341
  virtual uint32_t size_of() const =0;
365
342
 
366
 
  bool is_null(ptrdiff_t row_offset= 0);
367
 
  bool is_real_null(ptrdiff_t row_offset= 0);
 
343
  bool is_null(my_ptrdiff_t row_offset= 0);
 
344
  bool is_real_null(my_ptrdiff_t row_offset= 0);
368
345
  bool is_null_in_record(const unsigned char *record);
369
346
  bool is_null_in_record_with_offset(ptrdiff_t offset);
370
347
  void set_null(ptrdiff_t row_offset= 0);
382
359
   * use field->val_int() for comparison.  Used to optimize clauses like
383
360
   * 'a_column BETWEEN date_const AND date_const'.
384
361
   */
385
 
  virtual bool can_be_compared_as_int64_t() const
 
362
  virtual bool can_be_compared_as_int64_t() const 
386
363
  {
387
364
    return false;
388
365
  }
389
366
  virtual void free() {}
390
 
  virtual Field *new_field(memory::Root *root,
 
367
  virtual Field *new_field(MEM_ROOT *root, 
391
368
                           Table *new_table,
392
369
                           bool keep_type);
393
 
  virtual Field *new_key_field(memory::Root *root, Table *new_table,
394
 
                               unsigned char *new_ptr,
 
370
  virtual Field *new_key_field(MEM_ROOT *root, Table *new_table,
 
371
                               unsigned char *new_ptr, 
395
372
                               unsigned char *new_null_ptr,
396
373
                               uint32_t new_null_bit);
397
374
  /** This is used to generate a field in Table from TableShare */
398
 
  Field *clone(memory::Root *mem_root, Table *new_table);
399
 
  void move_field(unsigned char *ptr_arg,unsigned char *null_ptr_arg,unsigned char null_bit_arg)
 
375
  Field *clone(MEM_ROOT *mem_root, Table *new_table);
 
376
  inline void move_field(unsigned char *ptr_arg,unsigned char *null_ptr_arg,unsigned char null_bit_arg)
400
377
  {
401
378
    ptr= ptr_arg;
402
379
    null_ptr= null_ptr_arg;
403
380
    null_bit= null_bit_arg;
404
381
  }
405
 
  void move_field(unsigned char *ptr_arg) { ptr=ptr_arg; }
 
382
  inline void move_field(unsigned char *ptr_arg) { ptr=ptr_arg; }
406
383
  virtual void move_field_offset(ptrdiff_t ptr_diff)
407
384
  {
408
385
    ptr= ADD_TO_PTR(ptr,ptr_diff, unsigned char*);
442
419
   * characters have maximal possible size (mbmaxlen). In the other words,
443
420
   * "length" parameter is a number of characters multiplied by
444
421
   * field_charset->mbmaxlen.
445
 
   *
 
422
   * 
446
423
   * @retval
447
424
   *   Number of copied bytes (excluding padded zero bytes -- see above).
448
425
   */
460
437
  {
461
438
    set_image(buff,length, &my_charset_bin);
462
439
  }
463
 
  int64_t val_int_offset(uint32_t row_offset)
 
440
  inline int64_t val_int_offset(uint32_t row_offset)
464
441
  {
465
442
    ptr+=row_offset;
466
443
    int64_t tmp=val_int();
468
445
    return tmp;
469
446
  }
470
447
 
471
 
  int64_t val_int_internal(const unsigned char *new_ptr)
 
448
  inline int64_t val_int(const unsigned char *new_ptr)
472
449
  {
473
450
    unsigned char *old_ptr= ptr;
474
451
    int64_t return_value;
475
 
    ptr= const_cast<unsigned char*>(new_ptr);
 
452
    ptr= (unsigned char*) new_ptr;
476
453
    return_value= val_int();
477
454
    ptr= old_ptr;
478
455
    return return_value;
479
456
  }
480
 
 
481
 
  String *val_str_internal(String *str, const unsigned char *new_ptr)
 
457
  inline String *val_str(String *str, const unsigned char *new_ptr)
482
458
  {
483
459
    unsigned char *old_ptr= ptr;
484
 
    ptr= const_cast<unsigned char*>(new_ptr);
485
 
    val_str_internal(str);
 
460
    ptr= (unsigned char*) new_ptr;
 
461
    val_str(str);
486
462
    ptr= old_ptr;
487
463
    return str;
488
464
  }
574
550
 
575
551
  virtual unsigned char *pack_key(unsigned char* to,
576
552
                                  const unsigned char *from,
577
 
                                  uint32_t max_length,
 
553
                                  uint32_t max_length, 
578
554
                                  bool low_byte_first)
579
555
  {
580
556
    return pack(to, from, max_length, low_byte_first);
581
557
  }
 
558
  virtual unsigned char *pack_key_from_key_image(unsigned char* to,
 
559
                                                 const unsigned char *from,
 
560
                                                 uint32_t max_length,
 
561
                                                 bool low_byte_first)
 
562
  {
 
563
    return pack(to, from, max_length, low_byte_first);
 
564
  }
582
565
  virtual const unsigned char *unpack_key(unsigned char* to,
583
566
                                          const unsigned char *from,
584
567
                                          uint32_t max_length,
586
569
  {
587
570
    return unpack(to, from, max_length, low_byte_first);
588
571
  }
 
572
  virtual uint32_t packed_col_length(const unsigned char *to, uint32_t length);
589
573
  virtual uint32_t max_packed_col_length(uint32_t max_length)
590
574
  {
591
575
    return max_length;
592
576
  }
593
577
 
594
 
  uint32_t offset(const unsigned char *record)
 
578
  virtual int pack_cmp(const unsigned char *a,
 
579
                       const unsigned char *b,
 
580
                       uint32_t key_length_arg,
 
581
                       bool insert_or_update);
 
582
  virtual int pack_cmp(const unsigned char *b,
 
583
                       uint32_t key_length_arg,
 
584
                       bool insert_or_update);
 
585
 
 
586
  inline uint32_t offset(unsigned char *record)
595
587
  {
596
588
    return (uint32_t) (ptr - record);
597
589
  }
598
590
  void copy_from_tmp(int offset);
599
 
  uint32_t fill_cache_field(CacheField *copy);
600
 
  virtual bool get_date(type::Time &ltime,uint32_t fuzzydate);
601
 
  virtual bool get_time(type::Time &ltime);
 
591
  uint32_t fill_cache_field(struct st_cache_field *copy);
 
592
  virtual bool get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate);
 
593
  virtual bool get_time(DRIZZLE_TIME *ltime);
602
594
  virtual const CHARSET_INFO *charset(void) const { return &my_charset_bin; }
603
595
  virtual const CHARSET_INFO *sort_charset(void) const { return charset(); }
604
596
  virtual bool has_charset(void) const { return false; }
629
621
    @retval
630
622
      0 otherwise
631
623
  */
632
 
  bool set_warning(DRIZZLE_ERROR::enum_warning_level,
633
 
                   drizzled::error_t code,
 
624
  bool set_warning(DRIZZLE_ERROR::enum_warning_level, 
 
625
                   unsigned int code,
634
626
                   int cuted_increment);
635
627
  /**
636
628
    Produce warning or note about datetime string data saved into field.
647
639
      fields counter if count_cuted_fields ==FIELD_CHECK_IGNORE for current
648
640
      thread.
649
641
  */
650
 
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level,
651
 
                            drizzled::error_t code,
652
 
                            const char *str,
 
642
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level, 
 
643
                            uint32_t code,
 
644
                            const char *str, 
653
645
                            uint32_t str_len,
654
 
                            type::timestamp_t ts_type,
 
646
                            enum enum_drizzle_timestamp_type ts_type, 
655
647
                            int cuted_increment);
656
648
  /**
657
649
    Produce warning or note about integer datetime value saved into field.
667
659
      fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current
668
660
      thread.
669
661
  */
670
 
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level,
671
 
                            drizzled::error_t code,
672
 
                            int64_t nr,
673
 
                            type::timestamp_t ts_type,
 
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,
674
666
                            int cuted_increment);
675
667
  /**
676
668
    Produce warning or note about double datetime data saved into field.
685
677
      fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current
686
678
      thread.
687
679
  */
688
 
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level,
689
 
                            const drizzled::error_t code,
690
 
                            double nr,
691
 
                            type::timestamp_t ts_type);
692
 
  bool check_overflow(int op_result)
 
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);
 
684
  inline bool check_overflow(int op_result)
693
685
  {
694
686
    return (op_result == E_DEC_OVERFLOW);
695
687
  }
723
715
    @return
724
716
      value converted from val
725
717
  */
726
 
  int64_t convert_decimal2int64_t(const type::Decimal *val,
 
718
  int64_t convert_decimal2int64_t(const my_decimal *val, 
727
719
                                  bool unsigned_flag,
728
720
                                  int *err);
729
721
  /* The max. number of characters */
730
 
  uint32_t char_length() const
 
722
  inline uint32_t char_length() const
731
723
  {
732
724
    return field_length / charset()->mbmaxlen;
733
725
  }
734
726
 
735
 
  enum column_format_type column_format() const
 
727
  inline enum column_format_type column_format() const
736
728
  {
737
729
    return (enum column_format_type)
738
730
      ((flags >> COLUMN_FORMAT_FLAGS) & COLUMN_FORMAT_MASK);
760
752
  void setReadSet(bool arg= true);
761
753
  void setWriteSet(bool arg= true);
762
754
 
763
 
protected:
764
 
 
765
 
  void pack_num(uint64_t arg, unsigned char *destination= NULL);
766
 
  void pack_num(uint32_t arg, unsigned char *destination= NULL);
767
 
  uint64_t unpack_num(uint64_t &destination, const unsigned char *arg= NULL) const;
768
 
  uint32_t unpack_num(uint32_t &destination, const unsigned char *arg= NULL) const;
 
755
private:
 
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
  */
 
767
  virtual int do_save_field_metadata(unsigned char *)
 
768
  {
 
769
    return 0;
 
770
  }
769
771
};
770
772
 
771
 
std::ostream& operator<<(std::ostream& output, const Field &field);
772
 
 
773
 
} /* namespace drizzled */
774
 
 
775
 
/** @TODO Why is this in the middle of the file???*/
776
773
#include "drizzled/create_field.h"
777
774
 
778
 
namespace drizzled
779
 
{
780
 
 
781
775
/**
782
776
 * A class for sending field information to a client.
783
777
 *
786
780
 * Send_field is basically a stripped-down POD class for
787
781
 * representing basic information about a field...
788
782
 */
789
 
class SendField
 
783
class SendField 
790
784
{
791
785
public:
792
786
  const char *db_name;
802
796
  SendField() {}
803
797
};
804
798
 
 
799
/**
 
800
 * A class for quick copying data to fields
 
801
 */
 
802
class CopyField :public Sql_alloc
 
803
{
 
804
  /**
 
805
    Convenience definition of a copy function returned by
 
806
    get_copy_func.
 
807
  */
 
808
  typedef void Copy_func(CopyField*);
 
809
  Copy_func *get_copy_func(Field *to, Field *from);
 
810
public:
 
811
  unsigned char *from_ptr;
 
812
  unsigned char *to_ptr;
 
813
  unsigned char *from_null_ptr;
 
814
  unsigned char *to_null_ptr;
 
815
  bool *null_row;
 
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;
 
822
  String tmp;                                   // For items
 
823
 
 
824
  CopyField() {}
 
825
  ~CopyField() {}
 
826
  void set(Field *to,Field *from,bool save);    // Field to field
 
827
  void set(unsigned char *to,Field *from);              // Field to string
 
828
  void (*do_copy)(CopyField *);
 
829
  void (*do_copy2)(CopyField *);                // Used to handle null values
 
830
};
 
831
 
 
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,
 
841
                  const CHARSET_INFO * cs,
 
842
                  Field::utype unireg_check,
 
843
                  TYPELIB *interval,
 
844
                  const char *field_name);
 
845
 
805
846
uint32_t pack_length_to_packflag(uint32_t type);
806
847
uint32_t calc_pack_length(enum_field_types type,uint32_t length);
807
848
int set_field_to_null(Field *field);
824
865
                            const char *str,
825
866
                            const char *strend);
826
867
 
827
 
} /* namespace drizzled */
828
 
 
829
868
#endif /* DRIZZLED_FIELD_H */