1
by brian
clean slate |
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 |
||
16 |
||
17 |
/*
|
|
18 |
Because of the function new_field() all field classes that have static
|
|
19 |
variables must declare the size_of() member function.
|
|
20 |
*/
|
|
21 |
||
22 |
#ifdef USE_PRAGMA_INTERFACE
|
|
23 |
#pragma interface /* gcc class implementation */ |
|
24 |
#endif
|
|
25 |
||
26 |
#define DATETIME_DEC 6
|
|
173.1.9
by Toru Maesaka
ripped out DOUBLE and moved to field/ |
27 |
#define DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE FLOATING_POINT_BUFFER
|
28 |
||
1
by brian
clean slate |
29 |
const uint32 max_field_size= (uint32) 4294967295U; |
30 |
||
31 |
class Send_field; |
|
32 |
class Protocol; |
|
33 |
class Create_field; |
|
34 |
struct st_cache_field; |
|
35 |
int field_conv(Field *to,Field *from); |
|
36 |
||
37 |
inline uint get_enum_pack_length(int elements) |
|
38 |
{
|
|
39 |
return elements < 256 ? 1 : 2; |
|
40 |
}
|
|
41 |
||
42 |
inline uint get_set_pack_length(int elements) |
|
43 |
{
|
|
44 |
uint len= (elements + 7) / 8; |
|
45 |
return len > 4 ? 8 : len; |
|
46 |
}
|
|
47 |
||
48 |
class Field |
|
49 |
{
|
|
50 |
Field(const Item &); /* Prevent use of these */ |
|
51 |
void operator=(Field &); |
|
52 |
public: |
|
53 |
static void *operator new(size_t size) {return sql_alloc(size); } |
|
53.2.32
by Monty Taylor
First large swath at getting handler stuff clean. |
54 |
static void operator delete(void *ptr_arg __attribute__((__unused__)), |
55 |
size_t size __attribute__((__unused__))) |
|
56 |
{ TRASH(ptr_arg, size); } |
|
1
by brian
clean slate |
57 |
|
58 |
uchar *ptr; // Position to field in record |
|
59 |
uchar *null_ptr; // Byte where null_bit is |
|
60 |
/*
|
|
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
|
|
75 |
this info anywhere except unireg_check field. This issue will be resolved
|
|
76 |
in more clean way with transition to new text based .frm format.
|
|
77 |
See also comment for Field_timestamp::Field_timestamp().
|
|
78 |
*/
|
|
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}; |
|
84 |
||
85 |
utype unireg_check; |
|
86 |
uint32 field_length; // Length of field |
|
87 |
uint32 flags; |
|
88 |
uint16 field_index; // field number in fields array |
|
89 |
uchar null_bit; // Bit used to test null bit |
|
90 |
/**
|
|
91 |
If true, this field was created in create_tmp_field_from_item from a NULL
|
|
92 |
value. This means that the type of the field is just a guess, and the type
|
|
93 |
may be freely coerced to another type.
|
|
94 |
||
95 |
@see create_tmp_field_from_item
|
|
96 |
@see Item_type_holder::get_real_type
|
|
97 |
||
98 |
*/
|
|
99 |
bool is_created_from_null_item; |
|
100 |
||
101 |
Field(uchar *ptr_arg,uint32 length_arg,uchar *null_ptr_arg, |
|
102 |
uchar null_bit_arg, utype unireg_check_arg, |
|
103 |
const char *field_name_arg); |
|
104 |
virtual ~Field() {} |
|
105 |
/* Store functions returns 1 on overflow and -1 on fatal error */
|
|
106 |
virtual int store(const char *to, uint length,CHARSET_INFO *cs)=0; |
|
107 |
virtual int store(double nr)=0; |
|
152
by Brian Aker
longlong replacement |
108 |
virtual int store(int64_t nr, bool unsigned_val)=0; |
1
by brian
clean slate |
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, |
|
112 |
enum_check_fields check_level); |
|
113 |
virtual double val_real(void)=0; |
|
152
by Brian Aker
longlong replacement |
114 |
virtual int64_t val_int(void)=0; |
1
by brian
clean slate |
115 |
virtual my_decimal *val_decimal(my_decimal *); |
116 |
inline String *val_str(String *str) { return val_str(str, str); } |
|
117 |
/*
|
|
118 |
val_str(buf1, buf2) gets two buffers and should use them as follows:
|
|
119 |
if it needs a temp buffer to convert result to string - use buf1
|
|
120 |
example Field_tiny::val_str()
|
|
121 |
if the value exists as a string already - use buf2
|
|
122 |
example Field_string::val_str()
|
|
123 |
consequently, buf2 may be created as 'String buf;' - no memory
|
|
124 |
will be allocated for it. buf1 will be allocated to hold a
|
|
125 |
value if it's too small. Using allocated buffer for buf2 may result in
|
|
126 |
an unnecessary free (and later, may be an alloc).
|
|
127 |
This trickery is used to decrease a number of malloc calls.
|
|
128 |
*/
|
|
129 |
virtual String *val_str(String*,String *)=0; |
|
130 |
String *val_int_as_str(String *val_buffer, my_bool unsigned_flag); |
|
131 |
/*
|
|
51.1.58
by Jay Pipes
Replace/remove DBUG and standardize TRUE/FALSE. Remove ASSERT_COLUMN_XXX macros, that work will be done on another |
132 |
str_needs_quotes() returns true if the value returned by val_str() needs
|
1
by brian
clean slate |
133 |
to be quoted when used in constructing an SQL query.
|
134 |
*/
|
|
51.1.58
by Jay Pipes
Replace/remove DBUG and standardize TRUE/FALSE. Remove ASSERT_COLUMN_XXX macros, that work will be done on another |
135 |
virtual bool str_needs_quotes() { return false; } |
1
by brian
clean slate |
136 |
virtual Item_result result_type () const=0; |
137 |
virtual Item_result cmp_type () const { return result_type(); } |
|
138 |
virtual Item_result cast_to_int_type () const { return result_type(); } |
|
139 |
static bool type_can_have_key_part(enum_field_types); |
|
140 |
static enum_field_types field_type_merge(enum_field_types, enum_field_types); |
|
141 |
static Item_result result_merge_type(enum_field_types); |
|
142 |
virtual bool eq(Field *field) |
|
143 |
{
|
|
144 |
return (ptr == field->ptr && null_ptr == field->null_ptr && |
|
145 |
null_bit == field->null_bit); |
|
146 |
}
|
|
147 |
virtual bool eq_def(Field *field); |
|
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 pack_length() const { return (uint32) 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 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; } |
|
165 |
/*
|
|
166 |
This method is used to return the size of the data in a row-based
|
|
167 |
replication row record. The default implementation of returning 0 is
|
|
51.1.58
by Jay Pipes
Replace/remove DBUG and standardize TRUE/FALSE. Remove ASSERT_COLUMN_XXX macros, that work will be done on another |
168 |
designed to allow fields that do not use metadata to return true (1)
|
1
by brian
clean slate |
169 |
from compatible_field_size() which uses this function in the comparison.
|
170 |
The default value for field metadata for fields that do not have
|
|
171 |
metadata is 0. Thus, 0 == 0 means the fields are compatible in size.
|
|
172 |
||
173 |
Note: While most classes that override this method return pack_length(),
|
|
174 |
the classes Field_string, Field_varstring, and Field_blob return
|
|
175 |
field_length + 1, field_length, and pack_length_no_ptr() respectfully.
|
|
176 |
*/
|
|
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); } |
|
180 |
||
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 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 used_length() { return pack_length(); } |
|
192 |
virtual uint32 sort_length() const { return pack_length(); } |
|
193 |
||
194 |
/**
|
|
195 |
Get the maximum size of the data in packed format.
|
|
196 |
||
197 |
@return Maximum data length of the field when packed using the
|
|
198 |
Field::pack() function.
|
|
199 |
*/
|
|
200 |
virtual uint32 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 key_length() const { return pack_length(); } |
|
217 |
virtual enum_field_types type() const =0; |
|
218 |
virtual enum_field_types real_type() const { return type(); } |
|
219 |
inline int cmp(const uchar *str) { return cmp(ptr,str); } |
|
53.2.32
by Monty Taylor
First large swath at getting handler stuff clean. |
220 |
virtual int cmp_max(const uchar *a, const uchar *b, |
221 |
uint max_len __attribute__((__unused__))) |
|
1
by brian
clean slate |
222 |
{ return cmp(a, b); } |
223 |
virtual int cmp(const uchar *,const uchar *)=0; |
|
53.2.32
by Monty Taylor
First large swath at getting handler stuff clean. |
224 |
virtual int cmp_binary(const uchar *a,const uchar *b, |
225 |
uint32 __attribute__((__unused__)) max_length=~0) |
|
1
by brian
clean slate |
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); } |
|
53.2.32
by Monty Taylor
First large swath at getting handler stuff clean. |
233 |
virtual int key_cmp(const uchar *str, uint length __attribute__((__unused__))) |
1
by brian
clean slate |
234 |
{ return cmp(ptr,str); } |
235 |
virtual uint decimals() const { return 0; } |
|
236 |
/*
|
|
237 |
Caller beware: sql_type can change str.Ptr, so check
|
|
238 |
ptr() to see if it changed if you are using your own buffer
|
|
239 |
in str and restore it with set() if needed
|
|
240 |
*/
|
|
241 |
virtual void sql_type(String &str) const =0; |
|
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.
|
|
285 |
*/
|
|
286 |
size_t last_null_byte() const { |
|
287 |
size_t bytes= do_last_null_byte(); |
|
51.1.58
by Jay Pipes
Replace/remove DBUG and standardize TRUE/FALSE. Remove ASSERT_COLUMN_XXX macros, that work will be done on another |
288 |
assert(bytes <= table->s->null_bytes); |
1
by brian
clean slate |
289 |
return bytes; |
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
|
|
152
by Brian Aker
longlong replacement |
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
|
|
1
by brian
clean slate |
299 |
use field->val_int() for comparison. Used to optimize clauses like
|
300 |
'a_column BETWEEN date_const, date_const'.
|
|
301 |
*/
|
|
152
by Brian Aker
longlong replacement |
302 |
virtual bool can_be_compared_as_int64_t() const { return false; } |
1
by brian
clean slate |
303 |
virtual void free() {} |
304 |
virtual Field *new_field(MEM_ROOT *root, struct st_table *new_table, |
|
305 |
bool keep_type); |
|
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) |
|
311 |
{
|
|
312 |
ptr=ptr_arg; null_ptr=null_ptr_arg; null_bit=null_bit_arg; |
|
313 |
}
|
|
314 |
inline void move_field(uchar *ptr_arg) { ptr=ptr_arg; } |
|
315 |
virtual void move_field_offset(my_ptrdiff_t ptr_diff) |
|
316 |
{
|
|
317 |
ptr=ADD_TO_PTR(ptr,ptr_diff, uchar*); |
|
318 |
if (null_ptr) |
|
319 |
null_ptr=ADD_TO_PTR(null_ptr,ptr_diff,uchar*); |
|
320 |
}
|
|
53.2.32
by Monty Taylor
First large swath at getting handler stuff clean. |
321 |
virtual void get_image(uchar *buff, uint length, |
322 |
CHARSET_INFO *cs __attribute__((__unused__))) |
|
1
by brian
clean slate |
323 |
{ memcpy(buff,ptr,length); } |
53.2.32
by Monty Taylor
First large swath at getting handler stuff clean. |
324 |
virtual void set_image(const uchar *buff,uint length, |
325 |
CHARSET_INFO *cs __attribute__((__unused__))) |
|
1
by brian
clean slate |
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 |
||
53.2.32
by Monty Taylor
First large swath at getting handler stuff clean. |
355 |
virtual uint get_key_image(uchar *buff, uint length, |
356 |
imagetype type __attribute__((__unused__))) |
|
1
by brian
clean slate |
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); } |
|
152
by Brian Aker
longlong replacement |
363 |
inline int64_t val_int_offset(uint row_offset) |
1
by brian
clean slate |
364 |
{
|
365 |
ptr+=row_offset; |
|
152
by Brian Aker
longlong replacement |
366 |
int64_t tmp=val_int(); |
1
by brian
clean slate |
367 |
ptr-=row_offset; |
368 |
return tmp; |
|
369 |
}
|
|
152
by Brian Aker
longlong replacement |
370 |
inline int64_t val_int(const uchar *new_ptr) |
1
by brian
clean slate |
371 |
{
|
372 |
uchar *old_ptr= ptr; |
|
152
by Brian Aker
longlong replacement |
373 |
int64_t return_value; |
1
by brian
clean slate |
374 |
ptr= (uchar*) new_ptr; |
375 |
return_value= val_int(); |
|
376 |
ptr= old_ptr; |
|
377 |
return return_value; |
|
378 |
}
|
|
379 |
inline String *val_str(String *str, const uchar *new_ptr) |
|
380 |
{
|
|
381 |
uchar *old_ptr= ptr; |
|
382 |
ptr= (uchar*) new_ptr; |
|
383 |
val_str(str); |
|
384 |
ptr= old_ptr; |
|
385 |
return str; |
|
386 |
}
|
|
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); |
|
51.1.58
by Jay Pipes
Replace/remove DBUG and standardize TRUE/FALSE. Remove ASSERT_COLUMN_XXX macros, that work will be done on another |
397 |
return(result); |
1
by brian
clean slate |
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); |
|
51.1.58
by Jay Pipes
Replace/remove DBUG and standardize TRUE/FALSE. Remove ASSERT_COLUMN_XXX macros, that work will be done on another |
408 |
return(result); |
1
by brian
clean slate |
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) |
|
423 |
{
|
|
424 |
return unpack(to, from, max_length, low_byte_first); |
|
425 |
}
|
|
53.2.32
by Monty Taylor
First large swath at getting handler stuff clean. |
426 |
virtual uint packed_col_length(const uchar *to __attribute__((__unused__)), |
427 |
uint length) |
|
1
by brian
clean slate |
428 |
{ return length;} |
429 |
virtual uint max_packed_col_length(uint max_length) |
|
430 |
{ return max_length;} |
|
431 |
||
53.2.32
by Monty Taylor
First large swath at getting handler stuff clean. |
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__))) |
|
1
by brian
clean slate |
435 |
{ return cmp(a,b); } |
53.2.32
by Monty Taylor
First large swath at getting handler stuff clean. |
436 |
virtual int pack_cmp(const uchar *b, |
437 |
uint key_length_arg __attribute__((__unused__)), |
|
438 |
my_bool insert_or_update __attribute__((__unused__))) |
|
1
by brian
clean slate |
439 |
{ return cmp(ptr,b); } |
440 |
uint offset(uchar *record) |
|
441 |
{
|
|
442 |
return (uint) (ptr - record); |
|
443 |
}
|
|
444 |
void copy_from_tmp(int offset); |
|
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(); } |
|
51.1.58
by Jay Pipes
Replace/remove DBUG and standardize TRUE/FALSE. Remove ASSERT_COLUMN_XXX macros, that work will be done on another |
450 |
virtual bool has_charset(void) const { return false; } |
53.2.32
by Monty Taylor
First large swath at getting handler stuff clean. |
451 |
virtual void set_charset(CHARSET_INFO *charset_arg __attribute__((__unused__))) |
452 |
{ } |
|
1
by brian
clean slate |
453 |
virtual enum Derivation derivation(void) const |
454 |
{ return DERIVATION_IMPLICIT; } |
|
53.2.32
by Monty Taylor
First large swath at getting handler stuff clean. |
455 |
virtual void set_derivation(enum Derivation derivation_arg __attribute__((__unused__))) |
456 |
{ } |
|
1
by brian
clean slate |
457 |
bool set_warning(MYSQL_ERROR::enum_warning_level, unsigned int code, |
458 |
int cuted_increment); |
|
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, |
|
152
by Brian Aker
longlong replacement |
463 |
int64_t nr, timestamp_type ts_type, |
1
by brian
clean slate |
464 |
int cuted_increment); |
465 |
void set_datetime_warning(MYSQL_ERROR::enum_warning_level, const uint code, |
|
466 |
double nr, timestamp_type ts_type); |
|
467 |
inline bool check_overflow(int op_result) |
|
468 |
{
|
|
469 |
return (op_result == E_DEC_OVERFLOW); |
|
470 |
}
|
|
471 |
int warn_if_overflow(int op_result); |
|
472 |
void init(TABLE *table_arg) |
|
473 |
{
|
|
474 |
orig_table= table= table_arg; |
|
475 |
table_name= &table_arg->alias; |
|
476 |
}
|
|
477 |
||
478 |
/* maximum possible display length */
|
|
479 |
virtual uint32 max_display_length()= 0; |
|
480 |
||
481 |
virtual uint is_equal(Create_field *new_field); |
|
152
by Brian Aker
longlong replacement |
482 |
/* convert decimal to int64_t with overflow check */
|
483 |
int64_t convert_decimal2int64_t(const my_decimal *val, bool unsigned_flag, |
|
1
by brian
clean slate |
484 |
int *err); |
485 |
/* The max. number of characters */
|
|
486 |
inline uint32 char_length() const |
|
487 |
{
|
|
488 |
return field_length / charset()->mbmaxlen; |
|
489 |
}
|
|
490 |
||
491 |
inline enum column_format_type column_format() const |
|
492 |
{
|
|
493 |
return (enum column_format_type) |
|
494 |
((flags >> COLUMN_FORMAT_FLAGS) & COLUMN_FORMAT_MASK); |
|
495 |
}
|
|
496 |
||
497 |
/* Hash value */
|
|
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; |
|
503 |
friend class Item_avg_field; |
|
504 |
friend class Item_std_field; |
|
505 |
friend class Item_sum_num; |
|
506 |
friend class Item_sum_sum; |
|
507 |
friend class Item_sum_str; |
|
508 |
friend class Item_sum_count; |
|
509 |
friend class Item_sum_avg; |
|
510 |
friend class Item_sum_std; |
|
511 |
friend class Item_sum_min; |
|
512 |
friend class Item_sum_max; |
|
513 |
friend class Item_func_group_concat; |
|
514 |
||
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; |
|
528 |
||
529 |
/**
|
|
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 |
*/
|
|
53.2.32
by Monty Taylor
First large swath at getting handler stuff clean. |
539 |
virtual int do_save_field_metadata(uchar *metadata_ptr __attribute__((__unused__))) |
1
by brian
clean slate |
540 |
{ return 0; } |
541 |
};
|
|
542 |
||
543 |
||
544 |
class Field_num :public Field { |
|
545 |
public: |
|
546 |
const uint8 dec; |
|
547 |
bool zerofill,unsigned_flag; // Purify cannot handle bit fields |
|
548 |
Field_num(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg, |
|
549 |
uchar null_bit_arg, utype unireg_check_arg, |
|
550 |
const char *field_name_arg, |
|
551 |
uint8 dec_arg, bool zero_arg, bool unsigned_arg); |
|
552 |
Item_result result_type () const { return REAL_RESULT; } |
|
553 |
void prepend_zeros(String *value); |
|
554 |
void add_zerofill_and_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, |
|
152
by Brian Aker
longlong replacement |
566 |
int64_t *rnd, uint64_t unsigned_max, |
567 |
int64_t signed_min, int64_t signed_max); |
|
1
by brian
clean slate |
568 |
};
|
569 |
||
173.1.12
by Toru Maesaka
Moved out SHORT, LONG and INT64_T to field/ |
570 |
/* base class for all string related classes */
|
1
by brian
clean slate |
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 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); |
|
152
by Brian Aker
longlong replacement |
583 |
int store(int64_t nr, bool unsigned_val)=0; |
1
by brian
clean slate |
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 max_display_length() { return field_length; } |
|
594 |
friend class Create_field; |
|
595 |
my_decimal *val_decimal(my_decimal *); |
|
51.1.58
by Jay Pipes
Replace/remove DBUG and standardize TRUE/FALSE. Remove ASSERT_COLUMN_XXX macros, that work will be done on another |
596 |
virtual bool str_needs_quotes() { return true; } |
1
by brian
clean slate |
597 |
bool compare_str_field_flags(Create_field *new_field, uint32 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 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 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 len_arg, uchar *null_ptr_arg, |
|
626 |
uchar null_bit_arg, utype unireg_check_arg, |
|
627 |
const char *field_name_arg, |
|
628 |
uint8 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 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 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 MYSQL_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); |
|
152
by Brian Aker
longlong replacement |
661 |
int store(int64_t nr, bool unsigned_val); |
1
by brian
clean slate |
662 |
int reset(void) { ptr[0]=0; return 0; } |
663 |
double val_real(void); |
|
152
by Brian Aker
longlong replacement |
664 |
int64_t val_int(void); |
1
by brian
clean slate |
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 pack_length() const { return 1; } |
|
670 |
void sql_type(String &str) const; |
|
671 |
uint32 max_display_length() { return 4; } |
|
672 |
||
673 |
virtual uchar *pack(uchar* to, const uchar *from, |
|
53.2.32
by Monty Taylor
First large swath at getting handler stuff clean. |
674 |
uint max_length __attribute__((__unused__)), |
675 |
bool low_byte_first __attribute__((__unused__))) |
|
1
by brian
clean slate |
676 |
{
|
677 |
*to= *from; |
|
678 |
return to + 1; |
|
679 |
}
|
|
680 |
||
681 |
virtual const uchar *unpack(uchar* to, const uchar *from, |
|
53.2.32
by Monty Taylor
First large swath at getting handler stuff clean. |
682 |
uint param_data __attribute__((__unused__)), |
683 |
bool low_byte_first __attribute__((__unused__))) |
|
1
by brian
clean slate |
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 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 MYSQL_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); |
|
152
by Brian Aker
longlong replacement |
715 |
int store(int64_t nr, bool unsigned_val); |
1
by brian
clean slate |
716 |
double val_real(void); |
152
by Brian Aker
longlong replacement |
717 |
int64_t val_int(void); |
1
by brian
clean slate |
718 |
String *val_str(String*,String *); |
719 |
int cmp(const uchar *,const uchar *); |
|
720 |
void sort_string(uchar *buff,uint length); |
|
721 |
uint32 pack_length() const { return (uint32) 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 MYSQL_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; } |
|
53.2.32
by Monty Taylor
First large swath at getting handler stuff clean. |
730 |
bool optimize_range(uint idx __attribute__((__unused__)), |
731 |
uint part __attribute__((__unused__))) |
|
732 |
{ return 0; } |
|
1
by brian
clean slate |
733 |
bool eq_def(Field *field); |
51.1.58
by Jay Pipes
Replace/remove DBUG and standardize TRUE/FALSE. Remove ASSERT_COLUMN_XXX macros, that work will be done on another |
734 |
bool has_charset(void) const { return true; } |
1
by brian
clean slate |
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 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 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 max_length, uint32 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: |
|
808 |
const char *db_name; |
|
809 |
const char *table_name,*org_table_name; |
|
810 |
const char *col_name,*org_col_name; |
|
811 |
ulong length; |
|
812 |
uint charsetnr, flags, decimals; |
|
813 |
enum_field_types type; |
|
814 |
Send_field() {} |
|
815 |
};
|
|
816 |
||
817 |
||
818 |
/*
|
|
819 |
A class for quick copying data to fields
|
|
820 |
*/
|
|
821 |
||
822 |
class Copy_field :public Sql_alloc { |
|
823 |
/**
|
|
824 |
Convenience definition of a copy function returned by
|
|
825 |
get_copy_func.
|
|
826 |
*/
|
|
827 |
typedef void Copy_func(Copy_field*); |
|
828 |
Copy_func *get_copy_func(Field *to, Field *from); |
|
829 |
public: |
|
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; |
|
836 |
String tmp; // For items |
|
837 |
||
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 |
|
844 |
};
|
|
845 |
||
846 |
||
847 |
Field *make_field(TABLE_SHARE *share, uchar *ptr, uint32 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); |
|
855 |
uint32 calc_pack_length(enum_field_types type,uint32 length); |
|
856 |
int set_field_to_null(Field *field); |
|
857 |
int set_field_to_null_with_conversions(Field *field, bool no_conversions); |
|
858 |
||
173.1.1
by Toru Maesaka
ripped out blob from field.cc/.h and placed in field/ |
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); |
|
173.1.3
by Toru Maesaka
ripped out datetime and moved to field/ |
865 |
|
866 |
/*
|
|
867 |
Field subclasses
|
|
868 |
*/
|
|
869 |
#include "field/blob.h" |
|
173.1.4
by Toru Maesaka
ripped out NULL and YEAR and moved to field/ |
870 |
#include "field/null.h" |
871 |
#include "field/year.h" |
|
173.1.8
by Toru Maesaka
ripped out STRING and renamed new_decimal and new_date |
872 |
#include "field/date.h" |
873 |
#include "field/decimal.h" |
|
173.1.9
by Toru Maesaka
ripped out DOUBLE and moved to field/ |
874 |
#include "field/double.h" |
173.1.12
by Toru Maesaka
Moved out SHORT, LONG and INT64_T to field/ |
875 |
#include "field/short.h" |
173.1.11
by Toru Maesaka
moved out LONG to field/ |
876 |
#include "field/long.h" |
173.1.12
by Toru Maesaka
Moved out SHORT, LONG and INT64_T to field/ |
877 |
#include "field/int64_t.h" |
173.1.7
by Toru Maesaka
ripped out TIME and VARSTRING, moved to field/ |
878 |
#include "field/timetype.h" |
173.1.6
by Toru Maesaka
ripped out TIMESTAMP and move to field/ |
879 |
#include "field/timestamp.h" |
173.1.3
by Toru Maesaka
ripped out datetime and moved to field/ |
880 |
#include "field/datetime.h" |
173.1.8
by Toru Maesaka
ripped out STRING and renamed new_decimal and new_date |
881 |
#include "field/string.h" |
173.1.7
by Toru Maesaka
ripped out TIME and VARSTRING, moved to field/ |
882 |
#include "field/varstring.h" |
173.1.13
by Toru Maesaka
merge from trunk and SET moved out to field/ |
883 |
#include "field/set.h" |
173.1.3
by Toru Maesaka
ripped out datetime and moved to field/ |
884 |
|
1
by brian
clean slate |
885 |
/*
|
886 |
The following are for the interface with the .frm file
|
|
887 |
*/
|
|
888 |
||
889 |
#define FIELDFLAG_DECIMAL 1
|
|
890 |
#define FIELDFLAG_BINARY 1 // Shares same flag |
|
891 |
#define FIELDFLAG_NUMBER 2
|
|
892 |
#define FIELDFLAG_ZEROFILL 4
|
|
893 |
#define FIELDFLAG_PACK 120 // Bits used for packing |
|
894 |
#define FIELDFLAG_INTERVAL 256 // mangled with decimals! |
|
895 |
#define FIELDFLAG_BITFIELD 512 // mangled with decimals! |
|
896 |
#define FIELDFLAG_BLOB 1024 // mangled with decimals! |
|
897 |
#define FIELDFLAG_GEOM 2048 // mangled with decimals! |
|
898 |
||
899 |
#define FIELDFLAG_TREAT_BIT_AS_CHAR 4096 /* use Field_bit_as_char */ |
|
900 |
||
901 |
#define FIELDFLAG_LEFT_FULLSCREEN 8192
|
|
902 |
#define FIELDFLAG_RIGHT_FULLSCREEN 16384
|
|
903 |
#define FIELDFLAG_FORMAT_NUMBER 16384 // predit: ###,,## in output |
|
904 |
#define FIELDFLAG_NO_DEFAULT 16384 /* sql */ |
|
905 |
#define FIELDFLAG_SUM ((uint) 32768)// predit: +#fieldflag |
|
906 |
#define FIELDFLAG_MAYBE_NULL ((uint) 32768)// sql |
|
907 |
#define FIELDFLAG_HEX_ESCAPE ((uint) 0x10000)
|
|
908 |
#define FIELDFLAG_PACK_SHIFT 3
|
|
909 |
#define FIELDFLAG_DEC_SHIFT 8
|
|
910 |
#define FIELDFLAG_MAX_DEC 31
|
|
911 |
#define FIELDFLAG_NUM_SCREEN_TYPE 0x7F01
|
|
912 |
#define FIELDFLAG_ALFA_SCREEN_TYPE 0x7800
|
|
913 |
||
914 |
#define MTYP_TYPENR(type) (type & 127) /* Remove bits from type */ |
|
915 |
||
916 |
#define f_is_dec(x) ((x) & FIELDFLAG_DECIMAL)
|
|
917 |
#define f_is_num(x) ((x) & FIELDFLAG_NUMBER)
|
|
918 |
#define f_is_zerofill(x) ((x) & FIELDFLAG_ZEROFILL)
|
|
919 |
#define f_is_packed(x) ((x) & FIELDFLAG_PACK)
|
|
920 |
#define f_packtype(x) (((x) >> FIELDFLAG_PACK_SHIFT) & 15)
|
|
921 |
#define f_decimals(x) ((uint8) (((x) >> FIELDFLAG_DEC_SHIFT) & FIELDFLAG_MAX_DEC))
|
|
922 |
#define f_is_alpha(x) (!f_is_num(x))
|
|
923 |
#define f_is_binary(x) ((x) & FIELDFLAG_BINARY) // 4.0- compatibility |
|
924 |
#define f_is_enum(x) (((x) & (FIELDFLAG_INTERVAL | FIELDFLAG_NUMBER)) == FIELDFLAG_INTERVAL)
|
|
925 |
#define f_is_bitfield(x) (((x) & (FIELDFLAG_BITFIELD | FIELDFLAG_NUMBER)) == FIELDFLAG_BITFIELD)
|
|
926 |
#define f_is_blob(x) (((x) & (FIELDFLAG_BLOB | FIELDFLAG_NUMBER)) == FIELDFLAG_BLOB)
|
|
927 |
#define f_is_equ(x) ((x) & (1+2+FIELDFLAG_PACK+31*256))
|
|
928 |
#define f_settype(x) (((int) x) << FIELDFLAG_PACK_SHIFT)
|
|
929 |
#define f_maybe_null(x) (x & FIELDFLAG_MAYBE_NULL)
|
|
930 |
#define f_no_default(x) (x & FIELDFLAG_NO_DEFAULT)
|
|
931 |
#define f_bit_as_char(x) ((x) & FIELDFLAG_TREAT_BIT_AS_CHAR)
|
|
932 |
#define f_is_hex_escape(x) ((x) & FIELDFLAG_HEX_ESCAPE)
|
|
173.1.3
by Toru Maesaka
ripped out datetime and moved to field/ |
933 |