← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.h

  • Committer: Brian Aker
  • Date: 2008-07-28 18:01:38 UTC
  • Revision ID: brian@tangent.org-20080728180138-q2pxlq0qiapvqsdn
Remove YEAR field type

Show diffs side-by-side

added added

removed removed

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