1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
4
* Copyright (C) 2008 MySQL
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; either version 2 of the License, or
9
* (at your option) any later version.
11
* This program is distributed in the hope that it will be useful,
12
* but WITHOUT ANY WARRANTY; without even the implied warranty of
13
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14
* GNU General Public License for more details.
16
* You should have received a copy of the GNU General Public License
17
* along with this program; if not, write to the Free Software
18
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
1
/* Copyright (C) 2000-2006 MySQL AB
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.
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.
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 */
22
* @file This file implements the Field class and API
21
This file implements classes defined in field.h
24
#ifdef USE_PRAGMA_IMPLEMENTATION
25
#pragma implementation // gcc: Class implementation
28
#include "mysql_priv.h"
29
#include "sql_select.h"
29
#include "drizzled/sql_select.h"
30
#include "drizzled/error.h"
31
#include "drizzled/field/str.h"
32
#include "drizzled/field/num.h"
33
#include "drizzled/field/blob.h"
34
#include "drizzled/field/enum.h"
35
#include "drizzled/field/null.h"
36
#include "drizzled/field/date.h"
37
#include "drizzled/field/decimal.h"
38
#include "drizzled/field/real.h"
39
#include "drizzled/field/double.h"
40
#include "drizzled/field/long.h"
41
#include "drizzled/field/int64_t.h"
42
#include "drizzled/field/num.h"
43
#include "drizzled/field/timestamp.h"
44
#include "drizzled/field/datetime.h"
45
#include "drizzled/field/varstring.h"
46
#include "drizzled/time_functions.h"
47
#include "drizzled/internal/m_string.h"
33
// Maximum allowed exponent value for converting string to decimal
34
#define MAX_EXPONENT 1024
52
36
/*****************************************************************************
53
37
Instansiate templates and static variables
54
38
*****************************************************************************/
56
static enum_field_types
57
field_types_merge_rules [DRIZZLE_TYPE_MAX+1][DRIZZLE_TYPE_MAX+1]=
59
/* DRIZZLE_TYPE_LONG -> */
67
//DRIZZLE_TYPE_TIMESTAMP
69
//DRIZZLE_TYPE_LONGLONG
70
DRIZZLE_TYPE_LONGLONG,
71
//DRIZZLE_TYPE_DATETIME
75
//DRIZZLE_TYPE_VARCHAR
77
//DRIZZLE_TYPE_DECIMAL
84
/* DRIZZLE_TYPE_DOUBLE -> */
92
//DRIZZLE_TYPE_TIMESTAMP
94
//DRIZZLE_TYPE_LONGLONG
96
//DRIZZLE_TYPE_DATETIME
100
//DRIZZLE_TYPE_VARCHAR
101
DRIZZLE_TYPE_VARCHAR,
102
//DRIZZLE_TYPE_DECIMAL
105
DRIZZLE_TYPE_VARCHAR,
109
/* DRIZZLE_TYPE_NULL -> */
113
//DRIZZLE_TYPE_DOUBLE
117
//DRIZZLE_TYPE_TIMESTAMP
118
DRIZZLE_TYPE_TIMESTAMP,
119
//DRIZZLE_TYPE_LONGLONG
120
DRIZZLE_TYPE_LONGLONG,
121
//DRIZZLE_TYPE_DATETIME
122
DRIZZLE_TYPE_DATETIME,
125
//DRIZZLE_TYPE_VARCHAR
126
DRIZZLE_TYPE_VARCHAR,
127
//DRIZZLE_TYPE_DECIMAL
128
DRIZZLE_TYPE_DECIMAL,
134
/* DRIZZLE_TYPE_TIMESTAMP -> */
137
DRIZZLE_TYPE_VARCHAR,
138
//DRIZZLE_TYPE_DOUBLE
139
DRIZZLE_TYPE_VARCHAR,
141
DRIZZLE_TYPE_TIMESTAMP,
142
//DRIZZLE_TYPE_TIMESTAMP
143
DRIZZLE_TYPE_TIMESTAMP,
144
//DRIZZLE_TYPE_LONGLONG
145
DRIZZLE_TYPE_VARCHAR,
146
//DRIZZLE_TYPE_DATETIME
147
DRIZZLE_TYPE_DATETIME,
150
//DRIZZLE_TYPE_VARCHAR
151
DRIZZLE_TYPE_VARCHAR,
152
//DRIZZLE_TYPE_DECIMAL
153
DRIZZLE_TYPE_VARCHAR,
155
DRIZZLE_TYPE_VARCHAR,
159
/* DRIZZLE_TYPE_LONGLONG -> */
162
DRIZZLE_TYPE_LONGLONG,
163
//DRIZZLE_TYPE_DOUBLE
166
DRIZZLE_TYPE_LONGLONG,
167
//DRIZZLE_TYPE_TIMESTAMP
168
DRIZZLE_TYPE_VARCHAR,
169
//DRIZZLE_TYPE_LONGLONG
170
DRIZZLE_TYPE_LONGLONG,
171
//DRIZZLE_TYPE_DATETIME
172
DRIZZLE_TYPE_VARCHAR,
175
//DRIZZLE_TYPE_VARCHAR
176
DRIZZLE_TYPE_VARCHAR,
177
//DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_ENUM
178
DRIZZLE_TYPE_DECIMAL,
179
DRIZZLE_TYPE_VARCHAR,
183
/* DRIZZLE_TYPE_DATETIME -> */
186
DRIZZLE_TYPE_VARCHAR,
187
//DRIZZLE_TYPE_DOUBLE
188
DRIZZLE_TYPE_VARCHAR,
190
DRIZZLE_TYPE_DATETIME,
191
//DRIZZLE_TYPE_TIMESTAMP
192
DRIZZLE_TYPE_DATETIME,
193
//DRIZZLE_TYPE_LONGLONG
194
DRIZZLE_TYPE_VARCHAR,
195
//DRIZZLE_TYPE_DATETIME
196
DRIZZLE_TYPE_DATETIME,
199
//DRIZZLE_TYPE_VARCHAR
200
DRIZZLE_TYPE_VARCHAR,
201
//DRIZZLE_TYPE_DECIMAL
202
DRIZZLE_TYPE_VARCHAR,
204
DRIZZLE_TYPE_VARCHAR,
208
/* DRIZZLE_TYPE_DATE -> */
211
DRIZZLE_TYPE_VARCHAR,
212
//DRIZZLE_TYPE_DOUBLE
213
DRIZZLE_TYPE_VARCHAR,
216
//DRIZZLE_TYPE_TIMESTAMP
217
DRIZZLE_TYPE_DATETIME,
218
//DRIZZLE_TYPE_LONGLONG
219
DRIZZLE_TYPE_VARCHAR,
220
//DRIZZLE_TYPE_DATETIME
221
DRIZZLE_TYPE_DATETIME,
224
//DRIZZLE_TYPE_VARCHAR
225
DRIZZLE_TYPE_VARCHAR,
226
//DRIZZLE_TYPE_DECIMAL
227
DRIZZLE_TYPE_VARCHAR,
229
DRIZZLE_TYPE_VARCHAR,
233
/* DRIZZLE_TYPE_VARCHAR -> */
236
DRIZZLE_TYPE_VARCHAR,
237
//DRIZZLE_TYPE_DOUBLE
238
DRIZZLE_TYPE_VARCHAR,
240
DRIZZLE_TYPE_VARCHAR,
241
//DRIZZLE_TYPE_TIMESTAMP
242
DRIZZLE_TYPE_VARCHAR,
243
//DRIZZLE_TYPE_LONGLONG
244
DRIZZLE_TYPE_VARCHAR,
245
//DRIZZLE_TYPE_DATETIME
246
DRIZZLE_TYPE_VARCHAR,
248
DRIZZLE_TYPE_VARCHAR,
249
//DRIZZLE_TYPE_VARCHAR
250
DRIZZLE_TYPE_VARCHAR,
251
//DRIZZLE_TYPE_DECIMAL
252
DRIZZLE_TYPE_VARCHAR,
254
DRIZZLE_TYPE_VARCHAR,
258
/* DRIZZLE_TYPE_DECIMAL -> */
261
DRIZZLE_TYPE_DECIMAL,
262
//DRIZZLE_TYPE_DOUBLE
265
DRIZZLE_TYPE_DECIMAL,
266
//DRIZZLE_TYPE_TIMESTAMP
267
DRIZZLE_TYPE_VARCHAR,
268
//DRIZZLE_TYPE_LONGLONG
269
DRIZZLE_TYPE_DECIMAL,
270
//DRIZZLE_TYPE_DATETIME
271
DRIZZLE_TYPE_VARCHAR,
273
DRIZZLE_TYPE_VARCHAR,
274
//DRIZZLE_TYPE_VARCHAR
275
DRIZZLE_TYPE_VARCHAR,
276
//DRIZZLE_TYPE_DECIMAL
277
DRIZZLE_TYPE_DECIMAL,
279
DRIZZLE_TYPE_VARCHAR,
283
/* DRIZZLE_TYPE_ENUM -> */
286
DRIZZLE_TYPE_VARCHAR,
287
//DRIZZLE_TYPE_DOUBLE
288
DRIZZLE_TYPE_VARCHAR,
291
//DRIZZLE_TYPE_TIMESTAMP
292
DRIZZLE_TYPE_VARCHAR,
293
//DRIZZLE_TYPE_LONGLONG
294
DRIZZLE_TYPE_VARCHAR,
295
//DRIZZLE_TYPE_DATETIME
296
DRIZZLE_TYPE_VARCHAR,
298
DRIZZLE_TYPE_VARCHAR,
299
//DRIZZLE_TYPE_VARCHAR
300
DRIZZLE_TYPE_VARCHAR,
301
//DRIZZLE_TYPE_DECIMAL
302
DRIZZLE_TYPE_VARCHAR,
304
DRIZZLE_TYPE_VARCHAR,
308
/* DRIZZLE_TYPE_BLOB -> */
312
//DRIZZLE_TYPE_DOUBLE
316
//DRIZZLE_TYPE_TIMESTAMP
318
//DRIZZLE_TYPE_LONGLONG
320
//DRIZZLE_TYPE_DATETIME
324
//DRIZZLE_TYPE_VARCHAR
326
//DRIZZLE_TYPE_DECIMAL
335
static Item_result field_types_result_type [DRIZZLE_TYPE_MAX+1]=
339
//DRIZZLE_TYPE_DOUBLE
343
//DRIZZLE_TYPE_TIMESTAMP
345
//DRIZZLE_TYPE_LONGLONG
347
//DRIZZLE_TYPE_DATETIME
351
//DRIZZLE_TYPE_VARCHAR
353
//DRIZZLE_TYPE_DECIMAL
361
bool test_if_important_data(const CHARSET_INFO * const cs,
40
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
41
template class List<Create_field>;
42
template class List_iterator<Create_field>;
45
uchar Field_null::null[1]={1};
46
const char field_separator=',';
48
#define DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE FLOATING_POINT_BUFFER
49
#define LONGLONG_TO_STRING_CONVERSION_BUFFER_SIZE 128
50
#define DECIMAL_TO_STRING_CONVERSION_BUFFER_SIZE 128
51
#define BLOB_PACK_LENGTH_TO_MAX_LENGH(arg) \
52
((ulong) ((1LL << min(arg, 4) * 8) - 1LL))
54
#define ASSERT_COLUMN_MARKED_FOR_READ DBUG_ASSERT(!table || (!table->read_set || bitmap_is_set(table->read_set, field_index)))
55
#define ASSERT_COLUMN_MARKED_FOR_WRITE DBUG_ASSERT(!table || (!table->write_set || bitmap_is_set(table->write_set, field_index)))
58
Rules for merging different types of fields in UNION
60
NOTE: to avoid 256*256 table, gap in table types numeration is skiped
61
following #defines describe that gap and how to canculate number of fields
62
and index of field in thia array.
64
#define FIELDTYPE_TEAR_FROM (MYSQL_TYPE_VARCHAR + 1)
65
#define FIELDTYPE_TEAR_TO (MYSQL_TYPE_NEWDECIMAL - 1)
66
#define FIELDTYPE_NUM (FIELDTYPE_TEAR_FROM + (255 - FIELDTYPE_TEAR_TO))
67
inline int field_type2index (enum_field_types field_type)
69
return (field_type < FIELDTYPE_TEAR_FROM ?
71
((int)FIELDTYPE_TEAR_FROM) + (field_type - FIELDTYPE_TEAR_TO) - 1);
75
static enum_field_types field_types_merge_rules [FIELDTYPE_NUM][FIELDTYPE_NUM]=
77
/* MYSQL_TYPE_DECIMAL -> */
79
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
80
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_NEWDECIMAL,
81
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
82
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_NEWDECIMAL,
83
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
84
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_DOUBLE,
85
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
86
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
87
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
88
MYSQL_TYPE_DECIMAL, MYSQL_TYPE_DECIMAL,
89
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
90
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
91
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
92
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
93
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
94
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
95
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
96
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
97
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
98
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
99
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
100
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
101
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
102
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
106
/* MYSQL_TYPE_TINY -> */
108
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
109
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_TINY,
110
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
111
MYSQL_TYPE_SHORT, MYSQL_TYPE_LONG,
112
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
113
MYSQL_TYPE_FLOAT, MYSQL_TYPE_DOUBLE,
114
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
115
MYSQL_TYPE_TINY, MYSQL_TYPE_VARCHAR,
116
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
117
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_INT24,
118
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
119
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
120
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
121
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY,
122
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
123
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
124
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
125
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
126
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
127
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
128
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
129
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
130
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
131
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
135
/* MYSQL_TYPE_SHORT -> */
137
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
138
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_SHORT,
139
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
140
MYSQL_TYPE_SHORT, MYSQL_TYPE_LONG,
141
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
142
MYSQL_TYPE_FLOAT, MYSQL_TYPE_DOUBLE,
143
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
144
MYSQL_TYPE_SHORT, MYSQL_TYPE_VARCHAR,
145
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
146
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_INT24,
147
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
148
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
149
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
150
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_SHORT,
151
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
152
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
153
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
154
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
155
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
156
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
157
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
158
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
159
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
160
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
164
/* MYSQL_TYPE_LONG -> */
166
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
167
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_LONG,
168
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
169
MYSQL_TYPE_LONG, MYSQL_TYPE_LONG,
170
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
171
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_DOUBLE,
172
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
173
MYSQL_TYPE_LONG, MYSQL_TYPE_VARCHAR,
174
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
175
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_INT24,
176
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
177
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
178
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
179
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_LONG,
180
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
181
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
182
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
183
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
184
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
185
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
186
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
187
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
188
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
189
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
193
/* MYSQL_TYPE_FLOAT -> */
195
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
196
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_FLOAT,
197
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
198
MYSQL_TYPE_FLOAT, MYSQL_TYPE_DOUBLE,
199
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
200
MYSQL_TYPE_FLOAT, MYSQL_TYPE_DOUBLE,
201
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
202
MYSQL_TYPE_FLOAT, MYSQL_TYPE_VARCHAR,
203
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
204
MYSQL_TYPE_FLOAT, MYSQL_TYPE_INT24,
205
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
206
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
207
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
208
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_FLOAT,
209
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
210
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
211
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
212
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_VARCHAR,
213
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
214
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
215
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
216
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
217
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
218
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
222
/* MYSQL_TYPE_DOUBLE -> */
224
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
225
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_DOUBLE,
226
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
227
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_DOUBLE,
228
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
229
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_DOUBLE,
230
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
231
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_VARCHAR,
232
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
233
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_INT24,
234
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
235
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
236
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
237
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_DOUBLE,
238
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
239
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
240
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
241
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_VARCHAR,
242
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
243
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
244
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
245
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
246
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
247
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
251
/* MYSQL_TYPE_NULL -> */
253
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
254
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_TINY,
255
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
256
MYSQL_TYPE_SHORT, MYSQL_TYPE_LONG,
257
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
258
MYSQL_TYPE_FLOAT, MYSQL_TYPE_DOUBLE,
259
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
260
MYSQL_TYPE_NULL, MYSQL_TYPE_TIMESTAMP,
261
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
262
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_INT24,
263
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
264
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_TIME,
265
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
266
MYSQL_TYPE_DATETIME, MYSQL_TYPE_YEAR,
267
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
268
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
269
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
270
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_ENUM,
271
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
272
MYSQL_TYPE_SET, MYSQL_TYPE_TINY_BLOB,
273
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
274
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
275
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
276
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
280
/* MYSQL_TYPE_TIMESTAMP -> */
282
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
283
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
284
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
285
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
286
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
287
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
288
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
289
MYSQL_TYPE_TIMESTAMP, MYSQL_TYPE_TIMESTAMP,
290
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
291
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
292
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
293
MYSQL_TYPE_DATETIME, MYSQL_TYPE_DATETIME,
294
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
295
MYSQL_TYPE_DATETIME, MYSQL_TYPE_VARCHAR,
296
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
297
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
298
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
299
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
300
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
301
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
302
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
303
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
304
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
305
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
309
/* MYSQL_TYPE_LONGLONG -> */
311
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
312
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_LONGLONG,
313
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
314
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_LONGLONG,
315
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
316
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_DOUBLE,
317
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
318
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_VARCHAR,
319
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
320
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_LONG,
321
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
322
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
323
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
324
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_LONGLONG,
325
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
326
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
327
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
328
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
329
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
330
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
331
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
332
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
333
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
334
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
338
/* MYSQL_TYPE_INT24 -> */
340
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
341
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_INT24,
342
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
343
MYSQL_TYPE_INT24, MYSQL_TYPE_LONG,
344
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
345
MYSQL_TYPE_FLOAT, MYSQL_TYPE_DOUBLE,
346
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
347
MYSQL_TYPE_INT24, MYSQL_TYPE_VARCHAR,
348
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
349
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_INT24,
350
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
351
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
352
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
353
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_INT24,
354
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
355
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
356
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
357
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
358
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
359
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
360
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
361
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
362
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
363
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
367
/* MYSQL_TYPE_DATE -> */
369
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
370
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
371
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
372
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
373
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
374
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
375
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
376
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_DATETIME,
377
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
378
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
379
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
380
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_DATETIME,
381
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
382
MYSQL_TYPE_DATETIME, MYSQL_TYPE_VARCHAR,
383
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
384
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
385
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
386
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
387
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
388
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
389
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
390
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
391
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
392
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
396
/* MYSQL_TYPE_TIME -> */
398
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
399
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
400
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
401
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
402
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
403
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
404
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
405
MYSQL_TYPE_TIME, MYSQL_TYPE_DATETIME,
406
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
407
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
408
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
409
MYSQL_TYPE_DATETIME, MYSQL_TYPE_TIME,
410
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
411
MYSQL_TYPE_DATETIME, MYSQL_TYPE_VARCHAR,
412
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
413
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
414
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
415
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
416
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
417
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
418
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
419
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
420
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
421
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
425
/* MYSQL_TYPE_DATETIME -> */
427
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
428
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
429
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
430
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
431
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
432
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
433
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
434
MYSQL_TYPE_DATETIME, MYSQL_TYPE_DATETIME,
435
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
436
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
437
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
438
MYSQL_TYPE_DATETIME, MYSQL_TYPE_DATETIME,
439
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
440
MYSQL_TYPE_DATETIME, MYSQL_TYPE_VARCHAR,
441
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
442
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
443
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
444
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
445
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
446
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
447
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
448
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
449
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
450
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
454
/* MYSQL_TYPE_YEAR -> */
456
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
457
MYSQL_TYPE_DECIMAL, MYSQL_TYPE_TINY,
458
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
459
MYSQL_TYPE_SHORT, MYSQL_TYPE_LONG,
460
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
461
MYSQL_TYPE_FLOAT, MYSQL_TYPE_DOUBLE,
462
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
463
MYSQL_TYPE_YEAR, MYSQL_TYPE_VARCHAR,
464
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
465
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_INT24,
466
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
467
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
468
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
469
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_YEAR,
470
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
471
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
472
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
473
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
474
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
475
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
476
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
477
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
478
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
479
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
483
/* MYSQL_TYPE_NEWDATE -> */
485
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
486
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
487
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
488
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
489
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
490
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
491
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
492
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_DATETIME,
493
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
494
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
495
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
496
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_DATETIME,
497
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
498
MYSQL_TYPE_DATETIME, MYSQL_TYPE_VARCHAR,
499
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
500
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
501
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
502
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
503
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
504
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
505
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
506
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
507
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
508
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
512
/* MYSQL_TYPE_VARCHAR -> */
514
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
515
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
516
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
517
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
518
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
519
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
520
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
521
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
522
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
523
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
524
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
525
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
526
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
527
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
528
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
529
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
530
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
531
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
532
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
533
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
534
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
535
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
536
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
537
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
541
/* MYSQL_TYPE_NEWDECIMAL -> */
543
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
544
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_NEWDECIMAL,
545
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
546
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_NEWDECIMAL,
547
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
548
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_DOUBLE,
549
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
550
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
551
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
552
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_NEWDECIMAL,
553
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
554
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
555
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
556
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_NEWDECIMAL,
557
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
558
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
559
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
560
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
561
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
562
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
563
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
564
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
565
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
566
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
570
/* MYSQL_TYPE_ENUM -> */
572
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
573
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
574
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
575
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
576
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
577
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
578
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
579
MYSQL_TYPE_ENUM, MYSQL_TYPE_VARCHAR,
580
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
581
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
582
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
583
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
584
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
585
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
586
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
587
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
588
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
589
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
590
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
591
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
592
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
593
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
594
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
595
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
599
/* MYSQL_TYPE_SET -> */
601
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
602
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
603
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
604
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
605
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
606
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
607
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
608
MYSQL_TYPE_SET, MYSQL_TYPE_VARCHAR,
609
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
610
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
611
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
612
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
613
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
614
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
615
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
616
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
617
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
618
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
619
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
620
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
621
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
622
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
623
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
624
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
628
/* MYSQL_TYPE_TINY_BLOB -> */
630
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
631
MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_TINY_BLOB,
632
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
633
MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_TINY_BLOB,
634
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
635
MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_TINY_BLOB,
636
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
637
MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_TINY_BLOB,
638
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
639
MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_TINY_BLOB,
640
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
641
MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_TINY_BLOB,
642
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
643
MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_TINY_BLOB,
644
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
645
MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_TINY_BLOB,
646
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
647
MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_TINY_BLOB,
648
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
649
MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_TINY_BLOB,
650
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
651
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
652
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
653
MYSQL_TYPE_BLOB, MYSQL_TYPE_TINY_BLOB,
657
/* MYSQL_TYPE_MEDIUM_BLOB -> */
659
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
660
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
661
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
662
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
663
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
664
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
665
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
666
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
667
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
668
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
669
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
670
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
671
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
672
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
673
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
674
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
675
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
676
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
677
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
678
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
679
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
680
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
681
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
682
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
684
MYSQL_TYPE_MEDIUM_BLOB
686
/* MYSQL_TYPE_LONG_BLOB -> */
688
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
689
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
690
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
691
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
692
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
693
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
694
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
695
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
696
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
697
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
698
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
699
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
700
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
701
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
702
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
703
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
704
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
705
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
706
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
707
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
708
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
709
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
710
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
711
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
715
/* MYSQL_TYPE_BLOB -> */
717
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
718
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
719
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
720
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
721
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
722
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
723
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
724
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
725
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
726
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
727
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
728
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
729
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
730
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
731
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
732
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
733
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
734
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
735
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
736
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
737
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
738
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
739
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
740
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
744
/* MYSQL_TYPE_VAR_STRING -> */
746
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
747
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
748
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
749
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
750
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
751
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
752
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
753
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
754
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
755
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
756
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
757
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
758
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
759
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
760
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
761
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
762
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
763
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
764
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
765
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
766
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
767
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
768
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
769
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
773
/* MYSQL_TYPE_STRING -> */
775
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
776
MYSQL_TYPE_STRING, MYSQL_TYPE_STRING,
777
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
778
MYSQL_TYPE_STRING, MYSQL_TYPE_STRING,
779
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
780
MYSQL_TYPE_STRING, MYSQL_TYPE_STRING,
781
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
782
MYSQL_TYPE_STRING, MYSQL_TYPE_STRING,
783
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
784
MYSQL_TYPE_STRING, MYSQL_TYPE_STRING,
785
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
786
MYSQL_TYPE_STRING, MYSQL_TYPE_STRING,
787
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
788
MYSQL_TYPE_STRING, MYSQL_TYPE_STRING,
789
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
790
MYSQL_TYPE_STRING, MYSQL_TYPE_VARCHAR,
791
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
792
MYSQL_TYPE_STRING, MYSQL_TYPE_STRING,
793
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
794
MYSQL_TYPE_STRING, MYSQL_TYPE_TINY_BLOB,
795
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
796
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
797
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
798
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
805
Return type of which can carry value of both given types in UNION result.
807
@param a type for merging
808
@param b type for merging
814
enum_field_types Field::field_type_merge(enum_field_types a,
817
DBUG_ASSERT(a < FIELDTYPE_TEAR_FROM || a > FIELDTYPE_TEAR_TO);
818
DBUG_ASSERT(b < FIELDTYPE_TEAR_FROM || b > FIELDTYPE_TEAR_TO);
819
return field_types_merge_rules[field_type2index(a)]
820
[field_type2index(b)];
824
static Item_result field_types_result_type [FIELDTYPE_NUM]=
826
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
827
DECIMAL_RESULT, INT_RESULT,
828
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
829
INT_RESULT, INT_RESULT,
830
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
831
REAL_RESULT, REAL_RESULT,
832
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
833
STRING_RESULT, STRING_RESULT,
834
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
835
INT_RESULT, INT_RESULT,
836
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
837
STRING_RESULT, STRING_RESULT,
838
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
839
STRING_RESULT, INT_RESULT,
840
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
841
STRING_RESULT, STRING_RESULT,
842
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
843
DECIMAL_RESULT, STRING_RESULT,
844
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
845
STRING_RESULT, STRING_RESULT,
846
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
847
STRING_RESULT, STRING_RESULT,
848
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
849
STRING_RESULT, STRING_RESULT,
856
Test if the given string contains important data:
857
not spaces for character string,
858
or any data for binary string.
861
test_if_important_data()
867
FALSE - If string does not have important data
868
TRUE - If string has some important data
872
test_if_important_data(CHARSET_INFO *cs, const char *str, const char *strend)
365
874
if (cs != &my_charset_bin)
366
875
str+= cs->cset->scan(cs, str, strend, MY_SEQ_SPACES);
367
876
return (str < strend);
370
void *Field::operator new(size_t size)
372
return memory::sql_alloc(size);
375
void *Field::operator new(size_t size, memory::Root *mem_root)
377
return mem_root->alloc_root(static_cast<uint32_t>(size));
380
enum_field_types Field::field_type_merge(enum_field_types a,
383
assert(a <= DRIZZLE_TYPE_MAX);
384
assert(b <= DRIZZLE_TYPE_MAX);
385
return field_types_merge_rules[a][b];
881
Detect Item_result by given field type of UNION merge result.
883
@param field_type given field type
886
Item_result (type of internal MySQL expression result)
388
889
Item_result Field::result_merge_type(enum_field_types field_type)
390
assert(field_type <= DRIZZLE_TYPE_MAX);
391
return field_types_result_type[field_type];
394
bool Field::eq(Field *field)
396
return (ptr == field->ptr && null_ptr == field->null_ptr &&
397
null_bit == field->null_bit);
400
uint32_t Field::pack_length() const
405
uint32_t Field::pack_length_in_rec() const
407
return pack_length();
410
uint32_t Field::data_length()
412
return pack_length();
415
uint32_t Field::used_length()
417
return pack_length();
420
uint32_t Field::sort_length() const
422
return pack_length();
425
uint32_t Field::max_data_length() const
427
return pack_length();
430
int Field::reset(void)
432
memset(ptr, 0, pack_length());
436
void Field::reset_fields()
439
void Field::set_default()
441
ptrdiff_t l_offset= (ptrdiff_t) (table->getDefaultValues() - table->getInsertRecord());
442
memcpy(ptr, ptr + l_offset, pack_length());
444
*null_ptr= ((*null_ptr & (unsigned char) ~null_bit) | (null_ptr[l_offset] & null_bit));
446
if (this == table->next_number_field)
447
table->auto_increment_field_not_null= false;
450
bool Field::binary() const
455
bool Field::zero_pack() const
460
enum ha_base_keytype Field::key_type() const
462
return HA_KEYTYPE_BINARY;
465
uint32_t Field::key_length() const
467
return pack_length();
470
enum_field_types Field::real_type() const
475
int Field::cmp_max(const unsigned char *a, const unsigned char *b, uint32_t)
480
int Field::cmp_binary(const unsigned char *a,const unsigned char *b, uint32_t)
482
return memcmp(a,b,pack_length());
485
int Field::cmp_offset(uint32_t row_offset)
487
return cmp(ptr,ptr+row_offset);
490
int Field::cmp_binary_offset(uint32_t row_offset)
492
return cmp_binary(ptr, ptr+row_offset);
495
int Field::key_cmp(const unsigned char *a,const unsigned char *b)
500
int Field::key_cmp(const unsigned char *str, uint32_t)
505
uint32_t Field::decimals() const
510
bool Field::is_null(ptrdiff_t row_offset)
513
(null_ptr[row_offset] & null_bit ? true : false) :
517
bool Field::is_real_null(ptrdiff_t row_offset)
519
return null_ptr ? (null_ptr[row_offset] & null_bit ? true : false) : false;
522
bool Field::is_null_in_record(const unsigned char *record)
526
return test(record[(uint32_t) (null_ptr -table->getInsertRecord())] & null_bit);
529
bool Field::is_null_in_record_with_offset(ptrdiff_t with_offset)
533
return test(null_ptr[with_offset] & null_bit);
536
void Field::set_null(ptrdiff_t row_offset)
539
null_ptr[row_offset]|= null_bit;
542
void Field::set_notnull(ptrdiff_t row_offset)
545
null_ptr[row_offset]&= (unsigned char) ~null_bit;
548
bool Field::maybe_null(void)
550
return null_ptr != 0 || table->maybe_null;
553
bool Field::real_maybe_null(void)
555
return null_ptr != 0;
891
DBUG_ASSERT(field_type < FIELDTYPE_TEAR_FROM || field_type
892
> FIELDTYPE_TEAR_TO);
893
return field_types_result_type[field_type2index(field_type)];
896
/*****************************************************************************
897
Static help functions
898
*****************************************************************************/
902
Check whether a field type can be partially indexed by a key.
904
This is a static method, rather than a virtual function, because we need
905
to check the type of a non-Field in mysql_alter_table().
907
@param type field type
910
TRUE Type can have a prefixed key
912
FALSE Type can not have a prefixed key
558
915
bool Field::type_can_have_key_part(enum enum_field_types type)
561
case DRIZZLE_TYPE_VARCHAR:
562
case DRIZZLE_TYPE_BLOB:
918
case MYSQL_TYPE_VARCHAR:
919
case MYSQL_TYPE_TINY_BLOB:
920
case MYSQL_TYPE_MEDIUM_BLOB:
921
case MYSQL_TYPE_LONG_BLOB:
922
case MYSQL_TYPE_BLOB:
923
case MYSQL_TYPE_VAR_STRING:
924
case MYSQL_TYPE_STRING:
933
Numeric fields base class constructor.
935
Field_num::Field_num(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
936
uchar null_bit_arg, utype unireg_check_arg,
937
const char *field_name_arg,
938
uint8 dec_arg, bool zero_arg, bool unsigned_arg)
939
:Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
940
unireg_check_arg, field_name_arg),
941
dec(dec_arg),zerofill(zero_arg),unsigned_flag(unsigned_arg)
944
flags|=ZEROFILL_FLAG;
946
flags|=UNSIGNED_FLAG;
950
void Field_num::prepend_zeros(String *value)
953
if ((diff= (int) (field_length - value->length())) > 0)
955
bmove_upp((uchar*) value->ptr()+field_length,
956
(uchar*) value->ptr()+value->length(),
958
bfill((uchar*) value->ptr(),diff,'0');
959
value->length(field_length);
960
(void) value->c_ptr_quick(); // Avoid warnings in purify
965
Test if given number is a int.
968
Make this multi-byte-character safe
970
@param str String to test
971
@param length Length of 'str'
972
@param int_end Pointer to char after last used digit
973
@param cs Character set
976
This is called after one has called strntoull10rnd() function.
981
1 error: empty string or wrong integer.
983
2 error: garbage at the end of string.
986
int Field_num::check_int(CHARSET_INFO *cs, const char *str, int length,
987
const char *int_end, int error)
989
/* Test if we get an empty string or wrong integer */
990
if (str == int_end || error == MY_ERRNO_EDOM)
993
String tmp(buff, (uint32) sizeof(buff), system_charset_info);
994
tmp.copy(str, length, system_charset_info);
995
push_warning_printf(table->in_use, MYSQL_ERROR::WARN_LEVEL_WARN,
996
ER_TRUNCATED_WRONG_VALUE_FOR_FIELD,
997
ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
998
"integer", tmp.c_ptr(), field_name,
999
(ulong) table->in_use->row_count);
1002
/* Test if we have garbage at the end of the given string. */
1003
if (test_if_important_data(cs, int_end, str + length))
1005
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
1013
Conver a string to an integer then check bounds.
1018
from String to convert
1019
len Length of the string
1020
rnd OUT longlong value
1021
unsigned_max max unsigned value
1022
signed_min min signed value
1023
signed_max max signed value
1026
The function calls strntoull10rnd() to get an integer value then
1027
check bounds and errors returned. In case of any error a warning
1035
bool Field_num::get_int(CHARSET_INFO *cs, const char *from, uint len,
1036
longlong *rnd, uint64_t unsigned_max,
1037
longlong signed_min, longlong signed_max)
1042
*rnd= (longlong) cs->cset->strntoull10rnd(cs, from, len,
1043
unsigned_flag, &end,
1048
if ((((uint64_t) *rnd > unsigned_max) && (*rnd= (longlong) unsigned_max)) ||
1049
error == MY_ERRNO_ERANGE)
1056
if (*rnd < signed_min)
1061
else if (*rnd > signed_max)
1067
if (table->in_use->count_cuted_fields &&
1068
check_int(cs, from, len, end, error))
1073
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1078
Process decimal library return codes and issue warnings for overflow and
1081
@param op_result decimal library return code (E_DEC_* see include/decimal.h)
1084
1 there was overflow
1086
0 no error or some other errors except overflow
569
1089
int Field::warn_if_overflow(int op_result)
571
1091
if (op_result == E_DEC_OVERFLOW)
573
set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
574
return E_DEC_OVERFLOW;
1093
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
576
1096
if (op_result == E_DEC_TRUNCATED)
578
set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
579
return E_DEC_TRUNCATED;
1098
set_warning(MYSQL_ERROR::WARN_LEVEL_NOTE, WARN_DATA_TRUNCATED, 1);
1099
/* We return 0 here as this is not a critical issue */
584
void Field::init(Table *table_arg)
586
orig_table= table= table_arg;
1106
static bool test_if_real(const char *str,int length, CHARSET_INFO *cs)
1108
cs= system_charset_info; // QQ move test_if_real into CHARSET_INFO struct
1110
while (length && my_isspace(cs,*str))
1111
{ // Allow start space
1116
if (*str == '+' || *str == '-')
1119
if (!length || !(my_isdigit(cs,*str) || *str == '.'))
1122
while (length && my_isdigit(cs,*str))
1131
while (length && my_isdigit(cs,*str))
1138
if (*str == 'E' || *str == 'e')
1140
if (length < 3 || (str[1] != '+' && str[1] != '-') ||
1141
!my_isdigit(cs,str[2]))
1145
while (length && my_isdigit(cs,*str))
1150
for (; length ; length--, str++)
1151
{ // Allow end space
1152
if (!my_isspace(cs,*str))
1161
Interpret field value as an integer but return the result as a string.
1163
This is used for printing bit_fields as numbers while debugging.
1166
String *Field::val_int_as_str(String *val_buffer, my_bool unsigned_val)
1168
ASSERT_COLUMN_MARKED_FOR_READ;
1169
CHARSET_INFO *cs= &my_charset_bin;
1171
longlong value= val_int();
1173
if (val_buffer->alloc(MY_INT64_NUM_DECIMAL_DIGITS))
1175
length= (uint) (*cs->cset->longlong10_to_str)(cs, (char*) val_buffer->ptr(),
1176
MY_INT64_NUM_DECIMAL_DIGITS,
1177
unsigned_val ? 10 : -10,
1179
val_buffer->length(length);
589
1184
/// This is used as a table name when the table structure is not set up
590
Field::Field(unsigned char *ptr_arg,
592
unsigned char *null_ptr_arg,
593
unsigned char null_bit_arg,
594
utype unireg_check_arg,
595
const char *field_name_arg)
598
null_ptr(null_ptr_arg),
601
field_name(field_name_arg),
604
part_of_key_not_clustered(0),
606
unireg_check(unireg_check_arg),
607
field_length(length_arg),
608
null_bit(null_bit_arg),
609
is_created_from_null_item(false)
1185
Field::Field(uchar *ptr_arg,uint32 length_arg,uchar *null_ptr_arg,
1187
utype unireg_check_arg, const char *field_name_arg)
1188
:ptr(ptr_arg), null_ptr(null_ptr_arg),
1189
table(0), orig_table(0), table_name(0),
1190
field_name(field_name_arg),
1191
key_start(0), part_of_key(0), part_of_key_not_clustered(0),
1192
part_of_sortkey(0), unireg_check(unireg_check_arg),
1193
field_length(length_arg), null_bit(null_bit_arg),
1194
is_created_from_null_item(FALSE)
611
flags= null_ptr ? 0: NOT_NULL_FLAG;
1196
flags=null_ptr ? 0: NOT_NULL_FLAG;
612
1197
comment.str= (char*) "";
617
void Field::hash(uint32_t *nr, uint32_t *nr2)
1203
void Field::hash(ulong *nr, ulong *nr2)
798
int Field::store_time(DRIZZLE_TIME *ltime, enum enum_drizzle_timestamp_type)
1632
This is called when storing a date in a string.
1635
Needs to be changed if/when we want to support different time formats.
1638
int Field::store_time(MYSQL_TIME *ltime, timestamp_type type_arg)
1640
ASSERT_COLUMN_MARKED_FOR_WRITE;
800
1641
char buff[MAX_DATE_STRING_REP_LENGTH];
801
uint32_t length= (uint32_t) my_TIME_to_str(ltime, buff);
1642
uint length= (uint) my_TIME_to_str(ltime, buff);
802
1643
return store(buff, length, &my_charset_bin);
805
bool Field::optimize_range(uint32_t idx, uint32_t)
1647
bool Field::optimize_range(uint idx, uint part)
807
return test(table->index_flags(idx) & HA_READ_RANGE);
1649
return test(table->file->index_flags(idx, part, 1) & HA_READ_RANGE);
810
Field *Field::new_field(memory::Root *root, Table *new_table, bool)
1653
Field *Field::new_field(MEM_ROOT *root, struct st_table *new_table,
1654
bool keep_type __attribute__((unused)))
813
if (!(tmp= (Field*) root->memdup_root((char*) this,size_of())))
1657
if (!(tmp= (Field*) memdup_root(root,(char*) this,size_of())))
816
1660
if (tmp->table->maybe_null)
817
1661
tmp->flags&= ~NOT_NULL_FLAG;
818
1662
tmp->table= new_table;
819
tmp->key_start.reset();
820
tmp->part_of_key.reset();
821
tmp->part_of_sortkey.reset();
1663
tmp->key_start.init(0);
1664
tmp->part_of_key.init(0);
1665
tmp->part_of_sortkey.init(0);
822
1666
tmp->unireg_check= Field::NONE;
823
tmp->flags&= (NOT_NULL_FLAG | BLOB_FLAG | UNSIGNED_FLAG | BINARY_FLAG | ENUM_FLAG);
1667
tmp->flags&= (NOT_NULL_FLAG | BLOB_FLAG | UNSIGNED_FLAG |
1668
ZEROFILL_FLAG | BINARY_FLAG | ENUM_FLAG | SET_FLAG);
824
1669
tmp->reset_fields();
828
Field *Field::new_key_field(memory::Root *root, Table *new_table,
829
unsigned char *new_ptr,
830
unsigned char *new_null_ptr,
831
uint32_t new_null_bit)
1674
Field *Field::new_key_field(MEM_ROOT *root, struct st_table *new_table,
1675
uchar *new_ptr, uchar *new_null_ptr,
834
1679
if ((tmp= new_field(root, new_table, table == new_table)))
837
1682
tmp->null_ptr= new_null_ptr;
838
1683
tmp->null_bit= new_null_bit;
843
Field *Field::clone(memory::Root *root, Table *new_table)
1689
/* This is used to generate a field in TABLE from TABLE_SHARE */
1691
Field *Field::clone(MEM_ROOT *root, struct st_table *new_table)
846
if ((tmp= (Field*) root->memdup_root((char*) this,size_of())))
1694
if ((tmp= (Field*) memdup_root(root,(char*) this,size_of())))
848
1696
tmp->init(new_table);
849
tmp->move_field_offset((ptrdiff_t) (new_table->getInsertRecord() -
850
new_table->getDefaultValues()));
1697
tmp->move_field_offset((my_ptrdiff_t) (new_table->record[0] -
1698
new_table->s->default_values));
856
uint32_t Field::is_equal(CreateField *new_field_ptr)
858
return (new_field_ptr->sql_type == real_type());
1704
/****************************************************************************
1705
Field_null, a field that always return NULL
1706
****************************************************************************/
1708
void Field_null::sql_type(String &res) const
1710
res.set_ascii(STRING_WITH_LEN("null"));
1714
/****************************************************************************
1715
** Field_new_decimal
1716
****************************************************************************/
1718
Field_new_decimal::Field_new_decimal(uchar *ptr_arg,
1719
uint32 len_arg, uchar *null_ptr_arg,
1721
enum utype unireg_check_arg,
1722
const char *field_name_arg,
1723
uint8 dec_arg,bool zero_arg,
1725
:Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
1726
unireg_check_arg, field_name_arg, dec_arg, zero_arg, unsigned_arg)
1728
precision= my_decimal_length_to_precision(len_arg, dec_arg, unsigned_arg);
1729
set_if_smaller(precision, DECIMAL_MAX_PRECISION);
1730
DBUG_ASSERT((precision <= DECIMAL_MAX_PRECISION) &&
1731
(dec <= DECIMAL_MAX_SCALE));
1732
bin_size= my_decimal_get_binary_size(precision, dec);
1736
Field_new_decimal::Field_new_decimal(uint32 len_arg,
1737
bool maybe_null_arg,
1741
:Field_num((uchar*) 0, len_arg,
1742
maybe_null_arg ? (uchar*) "": 0, 0,
1743
NONE, name, dec_arg, 0, unsigned_arg)
1745
precision= my_decimal_length_to_precision(len_arg, dec_arg, unsigned_arg);
1746
set_if_smaller(precision, DECIMAL_MAX_PRECISION);
1747
DBUG_ASSERT((precision <= DECIMAL_MAX_PRECISION) &&
1748
(dec <= DECIMAL_MAX_SCALE));
1749
bin_size= my_decimal_get_binary_size(precision, dec);
1753
int Field_new_decimal::reset(void)
1755
store_value(&decimal_zero);
1761
Generate max/min decimal value in case of overflow.
1763
@param decimal_value buffer for value
1764
@param sign sign of value which caused overflow
1767
void Field_new_decimal::set_value_on_overflow(my_decimal *decimal_value,
1770
DBUG_ENTER("Field_new_decimal::set_value_on_overflow");
1771
max_my_decimal(decimal_value, precision, decimals());
1775
my_decimal_set_zero(decimal_value);
1777
decimal_value->sign(TRUE);
1784
Store decimal value in the binary buffer.
1786
Checks if decimal_value fits into field size.
1787
If it does, stores the decimal in the buffer using binary format.
1788
Otherwise sets maximal number that can be stored in the field.
1790
@param decimal_value my_decimal
1798
bool Field_new_decimal::store_value(const my_decimal *decimal_value)
1800
ASSERT_COLUMN_MARKED_FOR_WRITE;
1802
DBUG_ENTER("Field_new_decimal::store_value");
1805
char dbug_buff[DECIMAL_MAX_STR_LENGTH+1];
1806
DBUG_PRINT("enter", ("value: %s", dbug_decimal_as_string(dbug_buff, decimal_value)));
1810
/* check that we do not try to write negative value in unsigned field */
1811
if (unsigned_flag && decimal_value->sign())
1813
DBUG_PRINT("info", ("unsigned overflow"));
1814
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1816
decimal_value= &decimal_zero;
1820
char dbug_buff[DECIMAL_MAX_STR_LENGTH+1];
1821
DBUG_PRINT("info", ("saving with precision %d scale: %d value %s",
1822
(int)precision, (int)dec,
1823
dbug_decimal_as_string(dbug_buff, decimal_value)));
1827
if (warn_if_overflow(my_decimal2binary(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW,
1828
decimal_value, ptr, precision, dec)))
1831
DBUG_PRINT("info", ("overflow"));
1832
set_value_on_overflow(&buff, decimal_value->sign());
1833
my_decimal2binary(E_DEC_FATAL_ERROR, &buff, ptr, precision, dec);
1836
DBUG_EXECUTE("info", print_decimal_buff(decimal_value, (uchar *) ptr,
1842
int Field_new_decimal::store(const char *from, uint length,
1843
CHARSET_INFO *charset_arg)
1845
ASSERT_COLUMN_MARKED_FOR_WRITE;
1847
my_decimal decimal_value;
1848
DBUG_ENTER("Field_new_decimal::store(char*)");
1850
if ((err= str2my_decimal(E_DEC_FATAL_ERROR &
1851
~(E_DEC_OVERFLOW | E_DEC_BAD_NUM),
1852
from, length, charset_arg,
1854
table->in_use->abort_on_warning)
1856
/* Because "from" is not NUL-terminated and we use %s in the ER() */
1858
from_as_str.copy(from, length, &my_charset_bin);
1860
push_warning_printf(table->in_use, MYSQL_ERROR::WARN_LEVEL_ERROR,
1861
ER_TRUNCATED_WRONG_VALUE_FOR_FIELD,
1862
ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
1863
"decimal", from_as_str.c_ptr(), field_name,
1864
(ulong) table->in_use->row_count);
1870
case E_DEC_TRUNCATED:
1871
set_warning(MYSQL_ERROR::WARN_LEVEL_NOTE, WARN_DATA_TRUNCATED, 1);
1873
case E_DEC_OVERFLOW:
1874
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1875
set_value_on_overflow(&decimal_value, decimal_value.sign());
1879
/* Because "from" is not NUL-terminated and we use %s in the ER() */
1881
from_as_str.copy(from, length, &my_charset_bin);
1883
push_warning_printf(table->in_use, MYSQL_ERROR::WARN_LEVEL_WARN,
1884
ER_TRUNCATED_WRONG_VALUE_FOR_FIELD,
1885
ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
1886
"decimal", from_as_str.c_ptr(), field_name,
1887
(ulong) table->in_use->row_count);
1888
my_decimal_set_zero(&decimal_value);
1895
char dbug_buff[DECIMAL_MAX_STR_LENGTH+1];
1896
DBUG_PRINT("enter", ("value: %s",
1897
dbug_decimal_as_string(dbug_buff, &decimal_value)));
1899
store_value(&decimal_value);
1906
Fix following when double2my_decimal when double2decimal
1907
will return E_DEC_TRUNCATED always correctly
1910
int Field_new_decimal::store(double nr)
1912
ASSERT_COLUMN_MARKED_FOR_WRITE;
1913
my_decimal decimal_value;
1915
DBUG_ENTER("Field_new_decimal::store(double)");
1917
err= double2my_decimal(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW, nr,
1921
if (check_overflow(err))
1922
set_value_on_overflow(&decimal_value, decimal_value.sign());
1923
/* Only issue a warning if store_value doesn't issue an warning */
1924
table->in_use->got_warning= 0;
1926
if (store_value(&decimal_value))
1928
else if (err && !table->in_use->got_warning)
1929
err= warn_if_overflow(err);
1934
int Field_new_decimal::store(longlong nr, bool unsigned_val)
1936
ASSERT_COLUMN_MARKED_FOR_WRITE;
1937
my_decimal decimal_value;
1940
if ((err= int2my_decimal(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW,
1941
nr, unsigned_val, &decimal_value)))
1943
if (check_overflow(err))
1944
set_value_on_overflow(&decimal_value, decimal_value.sign());
1945
/* Only issue a warning if store_value doesn't issue an warning */
1946
table->in_use->got_warning= 0;
1948
if (store_value(&decimal_value))
1950
else if (err && !table->in_use->got_warning)
1951
err= warn_if_overflow(err);
1956
int Field_new_decimal::store_decimal(const my_decimal *decimal_value)
1958
ASSERT_COLUMN_MARKED_FOR_WRITE;
1959
return store_value(decimal_value);
1963
int Field_new_decimal::store_time(MYSQL_TIME *ltime, timestamp_type t_type)
1965
my_decimal decimal_value;
1966
return store_value(date2my_decimal(ltime, &decimal_value));
1970
double Field_new_decimal::val_real(void)
1972
ASSERT_COLUMN_MARKED_FOR_READ;
1974
my_decimal decimal_value;
1975
my_decimal2double(E_DEC_FATAL_ERROR, val_decimal(&decimal_value), &dbl);
1980
longlong Field_new_decimal::val_int(void)
1982
ASSERT_COLUMN_MARKED_FOR_READ;
1984
my_decimal decimal_value;
1985
my_decimal2int(E_DEC_FATAL_ERROR, val_decimal(&decimal_value),
1991
my_decimal* Field_new_decimal::val_decimal(my_decimal *decimal_value)
1993
ASSERT_COLUMN_MARKED_FOR_READ;
1994
DBUG_ENTER("Field_new_decimal::val_decimal");
1995
binary2my_decimal(E_DEC_FATAL_ERROR, ptr, decimal_value,
1997
DBUG_EXECUTE("info", print_decimal_buff(decimal_value, (uchar *) ptr,
1999
DBUG_RETURN(decimal_value);
2003
String *Field_new_decimal::val_str(String *val_buffer,
2004
String *val_ptr __attribute__((unused)))
2006
ASSERT_COLUMN_MARKED_FOR_READ;
2007
my_decimal decimal_value;
2008
uint fixed_precision= zerofill ? precision : 0;
2009
my_decimal2string(E_DEC_FATAL_ERROR, val_decimal(&decimal_value),
2010
fixed_precision, dec, '0', val_buffer);
2015
int Field_new_decimal::cmp(const uchar *a,const uchar*b)
2017
return memcmp(a, b, bin_size);
2021
void Field_new_decimal::sort_string(uchar *buff,
2022
uint length __attribute__((unused)))
2024
memcpy(buff, ptr, bin_size);
2028
void Field_new_decimal::sql_type(String &str) const
2030
CHARSET_INFO *cs= str.charset();
2031
str.length(cs->cset->snprintf(cs, (char*) str.ptr(), str.alloced_length(),
2032
"decimal(%d,%d)", precision, (int)dec));
2033
add_zerofill_and_unsigned(str);
2038
Save the field metadata for new decimal fields.
2040
Saves the precision in the first byte and decimals() in the second
2041
byte of the field metadata array at index of *metadata_ptr and
2042
*(metadata_ptr + 1).
2044
@param metadata_ptr First byte of field metadata
2046
@returns number of bytes written to metadata_ptr
2048
int Field_new_decimal::do_save_field_metadata(uchar *metadata_ptr)
2050
*metadata_ptr= precision;
2051
*(metadata_ptr + 1)= decimals();
2057
Returns the number of bytes field uses in row-based replication
2060
This method is used in row-based replication to determine the number
2061
of bytes that the field consumes in the row record format. This is
2062
used to skip fields in the master that do not exist on the slave.
2064
@param field_metadata Encoded size in field metadata
2066
@returns The size of the field based on the field metadata.
2068
uint Field_new_decimal::pack_length_from_metadata(uint field_metadata)
2070
uint const source_precision= (field_metadata >> 8U) & 0x00ff;
2071
uint const source_decimal= field_metadata & 0x00ff;
2072
uint const source_size= my_decimal_get_binary_size(source_precision,
2074
return (source_size);
2079
Check to see if field size is compatible with destination.
2081
This method is used in row-based replication to verify that the slave's
2082
field size is less than or equal to the master's field size. The
2083
encoded field metadata (from the master or source) is decoded and compared
2084
to the size of this field (the slave or destination).
2086
@param field_metadata Encoded size in field metadata
2088
@retval 0 if this field's size is < the source field's size
2089
@retval 1 if this field's size is >= the source field's size
2091
int Field_new_decimal::compatible_field_size(uint field_metadata)
2094
uint const source_precision= (field_metadata >> 8U) & 0x00ff;
2095
uint const source_decimal= field_metadata & 0x00ff;
2096
uint const source_size= my_decimal_get_binary_size(source_precision,
2098
uint const destination_size= row_pack_length();
2099
compatible= (source_size <= destination_size);
2101
compatible= (source_precision <= precision) &&
2102
(source_decimal <= decimals());
2103
return (compatible);
2107
uint Field_new_decimal::is_equal(Create_field *new_field)
2109
return ((new_field->sql_type == real_type()) &&
2110
((new_field->flags & UNSIGNED_FLAG) ==
2111
(uint) (flags & UNSIGNED_FLAG)) &&
2112
((new_field->flags & AUTO_INCREMENT_FLAG) ==
2113
(uint) (flags & AUTO_INCREMENT_FLAG)) &&
2114
(new_field->length == max_display_length()) &&
2115
(new_field->decimals == dec));
2120
Unpack a decimal field from row data.
2122
This method is used to unpack a decimal or numeric field from a master
2123
whose size of the field is less than that of the slave.
2125
@param to Destination of the data
2126
@param from Source of the data
2127
@param param_data Precision (upper) and decimal (lower) values
2129
@return New pointer into memory based on from + length of the data
2132
Field_new_decimal::unpack(uchar* to,
2135
bool low_byte_first)
2137
if (param_data == 0)
2138
return Field::unpack(to, from, param_data, low_byte_first);
2140
uint from_precision= (param_data & 0xff00) >> 8U;
2141
uint from_decimal= param_data & 0x00ff;
2142
uint length=pack_length();
2143
uint from_pack_len= my_decimal_get_binary_size(from_precision, from_decimal);
2144
uint len= (param_data && (from_pack_len < length)) ?
2145
from_pack_len : length;
2146
if ((from_pack_len && (from_pack_len < length)) ||
2147
(from_precision < precision) ||
2148
(from_decimal < decimals()))
2151
If the master's data is smaller than the slave, we need to convert
2152
the binary to decimal then resize the decimal converting it back to
2153
a decimal and write that to the raw data buffer.
2155
decimal_digit_t dec_buf[DECIMAL_MAX_PRECISION];
2157
dec.len= from_precision;
2160
Note: bin2decimal does not change the length of the field. So it is
2161
just the first step the resizing operation. The second step does the
2162
resizing using the precision and decimals from the slave.
2164
bin2decimal((uchar *)from, &dec, from_precision, from_decimal);
2165
decimal2bin(&dec, to, precision, decimals());
2168
memcpy(to, from, len); // Sizes are the same, just copy the data.
2172
/****************************************************************************
2174
****************************************************************************/
2176
int Field_tiny::store(const char *from,uint len,CHARSET_INFO *cs)
2178
ASSERT_COLUMN_MARKED_FOR_WRITE;
2182
error= get_int(cs, from, len, &rnd, 255, -128, 127);
2183
ptr[0]= unsigned_flag ? (char) (uint64_t) rnd : (char) rnd;
2188
int Field_tiny::store(double nr)
2190
ASSERT_COLUMN_MARKED_FOR_WRITE;
2198
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2201
else if (nr > 255.0)
2204
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2215
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2218
else if (nr > 127.0)
2221
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2225
*ptr=(char) (int) nr;
2231
int Field_tiny::store(longlong nr, bool unsigned_val)
2233
ASSERT_COLUMN_MARKED_FOR_WRITE;
2238
if (nr < 0 && !unsigned_val)
2241
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2244
else if ((uint64_t) nr > (uint64_t) 255)
2247
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2255
if (nr < 0 && unsigned_val)
2256
nr= 256; // Generate overflow
2260
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2266
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2276
double Field_tiny::val_real(void)
2278
ASSERT_COLUMN_MARKED_FOR_READ;
2279
int tmp= unsigned_flag ? (int) ptr[0] :
2280
(int) ((signed char*) ptr)[0];
2281
return (double) tmp;
2285
longlong Field_tiny::val_int(void)
2287
ASSERT_COLUMN_MARKED_FOR_READ;
2288
int tmp= unsigned_flag ? (int) ptr[0] :
2289
(int) ((signed char*) ptr)[0];
2290
return (longlong) tmp;
2294
String *Field_tiny::val_str(String *val_buffer,
2295
String *val_ptr __attribute__((unused)))
2297
ASSERT_COLUMN_MARKED_FOR_READ;
2298
CHARSET_INFO *cs= &my_charset_bin;
2300
uint mlength=max(field_length+1,5*cs->mbmaxlen);
2301
val_buffer->alloc(mlength);
2302
char *to=(char*) val_buffer->ptr();
2305
length= (uint) cs->cset->long10_to_str(cs,to,mlength, 10,
2308
length= (uint) cs->cset->long10_to_str(cs,to,mlength,-10,
2309
(long) *((signed char*) ptr));
2311
val_buffer->length(length);
2313
prepend_zeros(val_buffer);
2317
bool Field_tiny::send_binary(Protocol *protocol)
2319
return protocol->store_tiny((longlong) (int8) ptr[0]);
2322
int Field_tiny::cmp(const uchar *a_ptr, const uchar *b_ptr)
2325
a=(signed char) a_ptr[0]; b= (signed char) b_ptr[0];
2327
return ((uchar) a < (uchar) b) ? -1 : ((uchar) a > (uchar) b) ? 1 : 0;
2328
return (a < b) ? -1 : (a > b) ? 1 : 0;
2331
void Field_tiny::sort_string(uchar *to,uint length __attribute__((unused)))
2336
to[0] = (char) (ptr[0] ^ (uchar) 128); /* Revers signbit */
2339
void Field_tiny::sql_type(String &res) const
2341
CHARSET_INFO *cs=res.charset();
2342
res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
2343
"tinyint(%d)",(int) field_length));
2344
add_zerofill_and_unsigned(res);
2347
/****************************************************************************
2348
Field type short int (2 byte)
2349
****************************************************************************/
2351
int Field_short::store(const char *from,uint len,CHARSET_INFO *cs)
2353
ASSERT_COLUMN_MARKED_FOR_WRITE;
2358
error= get_int(cs, from, len, &rnd, UINT_MAX16, INT_MIN16, INT_MAX16);
2359
store_tmp= unsigned_flag ? (int) (uint64_t) rnd : (int) rnd;
2360
#ifdef WORDS_BIGENDIAN
2361
if (table->s->db_low_byte_first)
2363
int2store(ptr, store_tmp);
2367
shortstore(ptr, (short) store_tmp);
2372
int Field_short::store(double nr)
2374
ASSERT_COLUMN_MARKED_FOR_WRITE;
2383
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2386
else if (nr > (double) UINT_MAX16)
2388
res=(int16) UINT_MAX16;
2389
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2393
res=(int16) (uint16) nr;
2397
if (nr < (double) INT_MIN16)
2400
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2403
else if (nr > (double) INT_MAX16)
2406
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2410
res=(int16) (int) nr;
2412
#ifdef WORDS_BIGENDIAN
2413
if (table->s->db_low_byte_first)
2419
shortstore(ptr,res);
2424
int Field_short::store(longlong nr, bool unsigned_val)
2426
ASSERT_COLUMN_MARKED_FOR_WRITE;
2432
if (nr < 0L && !unsigned_val)
2435
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2438
else if ((uint64_t) nr > (uint64_t) UINT_MAX16)
2440
res=(int16) UINT_MAX16;
2441
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2445
res=(int16) (uint16) nr;
2449
if (nr < 0 && unsigned_val)
2450
nr= UINT_MAX16+1; // Generate overflow
2455
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2458
else if (nr > (longlong) INT_MAX16)
2461
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2467
#ifdef WORDS_BIGENDIAN
2468
if (table->s->db_low_byte_first)
2474
shortstore(ptr,res);
2479
double Field_short::val_real(void)
2481
ASSERT_COLUMN_MARKED_FOR_READ;
2483
#ifdef WORDS_BIGENDIAN
2484
if (table->s->db_low_byte_first)
2489
return unsigned_flag ? (double) (unsigned short) j : (double) j;
2492
longlong Field_short::val_int(void)
2494
ASSERT_COLUMN_MARKED_FOR_READ;
2496
#ifdef WORDS_BIGENDIAN
2497
if (table->s->db_low_byte_first)
2502
return unsigned_flag ? (longlong) (unsigned short) j : (longlong) j;
2506
String *Field_short::val_str(String *val_buffer,
2507
String *val_ptr __attribute__((unused)))
2509
ASSERT_COLUMN_MARKED_FOR_READ;
2510
CHARSET_INFO *cs= &my_charset_bin;
2512
uint mlength=max(field_length+1,7*cs->mbmaxlen);
2513
val_buffer->alloc(mlength);
2514
char *to=(char*) val_buffer->ptr();
2516
#ifdef WORDS_BIGENDIAN
2517
if (table->s->db_low_byte_first)
2524
length=(uint) cs->cset->long10_to_str(cs, to, mlength, 10,
2527
length=(uint) cs->cset->long10_to_str(cs, to, mlength,-10, (long) j);
2528
val_buffer->length(length);
2530
prepend_zeros(val_buffer);
2535
bool Field_short::send_binary(Protocol *protocol)
2537
return protocol->store_short(Field_short::val_int());
2541
int Field_short::cmp(const uchar *a_ptr, const uchar *b_ptr)
2544
#ifdef WORDS_BIGENDIAN
2545
if (table->s->db_low_byte_first)
2558
return ((unsigned short) a < (unsigned short) b) ? -1 :
2559
((unsigned short) a > (unsigned short) b) ? 1 : 0;
2560
return (a < b) ? -1 : (a > b) ? 1 : 0;
2563
void Field_short::sort_string(uchar *to,uint length __attribute__((unused)))
2565
#ifdef WORDS_BIGENDIAN
2566
if (!table->s->db_low_byte_first)
2571
to[0] = (char) (ptr[0] ^ 128); /* Revers signbit */
2580
to[0] = (char) (ptr[1] ^ 128); /* Revers signbit */
2585
void Field_short::sql_type(String &res) const
2587
CHARSET_INFO *cs=res.charset();
2588
res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
2589
"smallint(%d)",(int) field_length));
2590
add_zerofill_and_unsigned(res);
2594
/****************************************************************************
2595
Field type medium int (3 byte)
2596
****************************************************************************/
2598
int Field_medium::store(const char *from,uint len,CHARSET_INFO *cs)
2600
ASSERT_COLUMN_MARKED_FOR_WRITE;
2605
error= get_int(cs, from, len, &rnd, UINT_MAX24, INT_MIN24, INT_MAX24);
2606
store_tmp= unsigned_flag ? (int) (uint64_t) rnd : (int) rnd;
2607
int3store(ptr, store_tmp);
2612
int Field_medium::store(double nr)
2614
ASSERT_COLUMN_MARKED_FOR_WRITE;
2622
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2625
else if (nr >= (double) (long) (1L << 24))
2627
uint32 tmp=(uint32) (1L << 24)-1L;
2629
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2633
int3store(ptr,(uint32) nr);
2637
if (nr < (double) INT_MIN24)
2639
long tmp=(long) INT_MIN24;
2641
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2644
else if (nr > (double) INT_MAX24)
2646
long tmp=(long) INT_MAX24;
2648
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2652
int3store(ptr,(long) nr);
2658
int Field_medium::store(longlong nr, bool unsigned_val)
2660
ASSERT_COLUMN_MARKED_FOR_WRITE;
2665
if (nr < 0 && !unsigned_val)
2668
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2671
else if ((uint64_t) nr >= (uint64_t) (long) (1L << 24))
2673
long tmp= (long) (1L << 24)-1L;
2675
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2679
int3store(ptr,(uint32) nr);
2683
if (nr < 0 && unsigned_val)
2684
nr= (uint64_t) (long) (1L << 24); // Generate overflow
2686
if (nr < (longlong) INT_MIN24)
2688
long tmp= (long) INT_MIN24;
2690
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2693
else if (nr > (longlong) INT_MAX24)
2695
long tmp=(long) INT_MAX24;
2697
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2701
int3store(ptr,(long) nr);
2707
double Field_medium::val_real(void)
2709
ASSERT_COLUMN_MARKED_FOR_READ;
2710
long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
2715
longlong Field_medium::val_int(void)
2717
ASSERT_COLUMN_MARKED_FOR_READ;
2718
long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
2719
return (longlong) j;
2723
String *Field_medium::val_str(String *val_buffer,
2724
String *val_ptr __attribute__((unused)))
2726
ASSERT_COLUMN_MARKED_FOR_READ;
2727
CHARSET_INFO *cs= &my_charset_bin;
2729
uint mlength=max(field_length+1,10*cs->mbmaxlen);
2730
val_buffer->alloc(mlength);
2731
char *to=(char*) val_buffer->ptr();
2732
long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
2734
length=(uint) cs->cset->long10_to_str(cs,to,mlength,-10,j);
2735
val_buffer->length(length);
2737
prepend_zeros(val_buffer); /* purecov: inspected */
2742
bool Field_medium::send_binary(Protocol *protocol)
2744
ASSERT_COLUMN_MARKED_FOR_READ;
2745
return protocol->store_long(Field_medium::val_int());
2749
int Field_medium::cmp(const uchar *a_ptr, const uchar *b_ptr)
2762
return (a < b) ? -1 : (a > b) ? 1 : 0;
2765
void Field_medium::sort_string(uchar *to,uint length __attribute__((unused)))
2770
to[0] = (uchar) (ptr[2] ^ 128); /* Revers signbit */
2776
void Field_medium::sql_type(String &res) const
2778
CHARSET_INFO *cs=res.charset();
2779
res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
2780
"mediumint(%d)",(int) field_length));
2781
add_zerofill_and_unsigned(res);
2784
/****************************************************************************
2786
****************************************************************************/
2788
int Field_long::store(const char *from,uint len,CHARSET_INFO *cs)
2790
ASSERT_COLUMN_MARKED_FOR_WRITE;
2795
error= get_int(cs, from, len, &rnd, UINT_MAX32, INT_MIN32, INT_MAX32);
2796
store_tmp= unsigned_flag ? (long) (uint64_t) rnd : (long) rnd;
2797
#ifdef WORDS_BIGENDIAN
2798
if (table->s->db_low_byte_first)
2800
int4store(ptr, store_tmp);
2804
longstore(ptr, store_tmp);
2809
int Field_long::store(double nr)
2811
ASSERT_COLUMN_MARKED_FOR_WRITE;
2822
else if (nr > (double) UINT_MAX32)
2825
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2829
res=(int32) (ulong) nr;
2833
if (nr < (double) INT_MIN32)
2835
res=(int32) INT_MIN32;
2838
else if (nr > (double) INT_MAX32)
2840
res=(int32) INT_MAX32;
2844
res=(int32) (longlong) nr;
2847
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2849
#ifdef WORDS_BIGENDIAN
2850
if (table->s->db_low_byte_first)
2861
int Field_long::store(longlong nr, bool unsigned_val)
2863
ASSERT_COLUMN_MARKED_FOR_WRITE;
2869
if (nr < 0 && !unsigned_val)
2874
else if ((uint64_t) nr >= (1LL << 32))
2876
res=(int32) (uint32) ~0L;
2880
res=(int32) (uint32) nr;
2884
if (nr < 0 && unsigned_val)
2885
nr= ((longlong) INT_MAX32) + 1; // Generate overflow
2886
if (nr < (longlong) INT_MIN32)
2888
res=(int32) INT_MIN32;
2891
else if (nr > (longlong) INT_MAX32)
2893
res=(int32) INT_MAX32;
2900
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2902
#ifdef WORDS_BIGENDIAN
2903
if (table->s->db_low_byte_first)
2914
double Field_long::val_real(void)
2916
ASSERT_COLUMN_MARKED_FOR_READ;
2918
#ifdef WORDS_BIGENDIAN
2919
if (table->s->db_low_byte_first)
2924
return unsigned_flag ? (double) (uint32) j : (double) j;
2927
longlong Field_long::val_int(void)
2929
ASSERT_COLUMN_MARKED_FOR_READ;
2931
/* See the comment in Field_long::store(long long) */
2932
DBUG_ASSERT(table->in_use == current_thd);
2933
#ifdef WORDS_BIGENDIAN
2934
if (table->s->db_low_byte_first)
2939
return unsigned_flag ? (longlong) (uint32) j : (longlong) j;
2942
String *Field_long::val_str(String *val_buffer,
2943
String *val_ptr __attribute__((unused)))
2945
ASSERT_COLUMN_MARKED_FOR_READ;
2946
CHARSET_INFO *cs= &my_charset_bin;
2948
uint mlength=max(field_length+1,12*cs->mbmaxlen);
2949
val_buffer->alloc(mlength);
2950
char *to=(char*) val_buffer->ptr();
2952
#ifdef WORDS_BIGENDIAN
2953
if (table->s->db_low_byte_first)
2960
length=cs->cset->long10_to_str(cs,to,mlength, 10,(long) (uint32)j);
2962
length=cs->cset->long10_to_str(cs,to,mlength,-10,(long) j);
2963
val_buffer->length(length);
2965
prepend_zeros(val_buffer);
2970
bool Field_long::send_binary(Protocol *protocol)
2972
ASSERT_COLUMN_MARKED_FOR_READ;
2973
return protocol->store_long(Field_long::val_int());
2976
int Field_long::cmp(const uchar *a_ptr, const uchar *b_ptr)
2979
#ifdef WORDS_BIGENDIAN
2980
if (table->s->db_low_byte_first)
2992
return ((uint32) a < (uint32) b) ? -1 : ((uint32) a > (uint32) b) ? 1 : 0;
2993
return (a < b) ? -1 : (a > b) ? 1 : 0;
2996
void Field_long::sort_string(uchar *to,uint length __attribute__((unused)))
2998
#ifdef WORDS_BIGENDIAN
2999
if (!table->s->db_low_byte_first)
3004
to[0] = (char) (ptr[0] ^ 128); /* Revers signbit */
3015
to[0] = (char) (ptr[3] ^ 128); /* Revers signbit */
3023
void Field_long::sql_type(String &res) const
3025
CHARSET_INFO *cs=res.charset();
3026
res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
3027
"int(%d)",(int) field_length));
3028
add_zerofill_and_unsigned(res);
3031
/****************************************************************************
3032
Field type longlong int (8 bytes)
3033
****************************************************************************/
3035
int Field_longlong::store(const char *from,uint len,CHARSET_INFO *cs)
3037
ASSERT_COLUMN_MARKED_FOR_WRITE;
3042
tmp= cs->cset->strntoull10rnd(cs,from,len,unsigned_flag,&end,&error);
3043
if (error == MY_ERRNO_ERANGE)
3045
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3048
else if (table->in_use->count_cuted_fields &&
3049
check_int(cs, from, len, end, error))
3053
#ifdef WORDS_BIGENDIAN
3054
if (table->s->db_low_byte_first)
3060
longlongstore(ptr,tmp);
3065
int Field_longlong::store(double nr)
3067
ASSERT_COLUMN_MARKED_FOR_WRITE;
3079
else if (nr >= (double) ULONGLONG_MAX)
3085
res=(longlong) (uint64_t) nr;
3089
if (nr <= (double) LONGLONG_MIN)
3092
error= (nr < (double) LONGLONG_MIN);
3094
else if (nr >= (double) (uint64_t) LONGLONG_MAX)
3097
error= (nr > (double) LONGLONG_MAX);
3103
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3105
#ifdef WORDS_BIGENDIAN
3106
if (table->s->db_low_byte_first)
3112
longlongstore(ptr,res);
3117
int Field_longlong::store(longlong nr, bool unsigned_val)
3119
ASSERT_COLUMN_MARKED_FOR_WRITE;
3122
if (nr < 0) // Only possible error
3125
if field is unsigned and value is signed (< 0) or
3126
if field is signed and value is unsigned we have an overflow
3128
if (unsigned_flag != unsigned_val)
3130
nr= unsigned_flag ? (uint64_t) 0 : (uint64_t) LONGLONG_MAX;
3131
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3136
#ifdef WORDS_BIGENDIAN
3137
if (table->s->db_low_byte_first)
3143
longlongstore(ptr,nr);
3148
double Field_longlong::val_real(void)
3150
ASSERT_COLUMN_MARKED_FOR_READ;
3152
#ifdef WORDS_BIGENDIAN
3153
if (table->s->db_low_byte_first)
3160
/* The following is open coded to avoid a bug in gcc 3.3 */
3163
uint64_t tmp= (uint64_t) j;
3164
return ulonglong2double(tmp);
3170
longlong Field_longlong::val_int(void)
3172
ASSERT_COLUMN_MARKED_FOR_READ;
3174
#ifdef WORDS_BIGENDIAN
3175
if (table->s->db_low_byte_first)
3184
String *Field_longlong::val_str(String *val_buffer,
3185
String *val_ptr __attribute__((unused)))
3187
CHARSET_INFO *cs= &my_charset_bin;
3189
uint mlength=max(field_length+1,22*cs->mbmaxlen);
3190
val_buffer->alloc(mlength);
3191
char *to=(char*) val_buffer->ptr();
3193
#ifdef WORDS_BIGENDIAN
3194
if (table->s->db_low_byte_first)
3200
length=(uint) (cs->cset->longlong10_to_str)(cs,to,mlength,
3201
unsigned_flag ? 10 : -10, j);
3202
val_buffer->length(length);
3204
prepend_zeros(val_buffer);
3209
bool Field_longlong::send_binary(Protocol *protocol)
3211
ASSERT_COLUMN_MARKED_FOR_READ;
3212
return protocol->store_longlong(Field_longlong::val_int(), unsigned_flag);
3216
int Field_longlong::cmp(const uchar *a_ptr, const uchar *b_ptr)
3219
#ifdef WORDS_BIGENDIAN
3220
if (table->s->db_low_byte_first)
3228
longlongget(a,a_ptr);
3229
longlongget(b,b_ptr);
3232
return ((uint64_t) a < (uint64_t) b) ? -1 :
3233
((uint64_t) a > (uint64_t) b) ? 1 : 0;
3234
return (a < b) ? -1 : (a > b) ? 1 : 0;
3237
void Field_longlong::sort_string(uchar *to,uint length __attribute__((unused)))
3239
#ifdef WORDS_BIGENDIAN
3240
if (!table->s->db_low_byte_first)
3245
to[0] = (char) (ptr[0] ^ 128); /* Revers signbit */
3260
to[0] = (char) (ptr[7] ^ 128); /* Revers signbit */
3272
void Field_longlong::sql_type(String &res) const
3274
CHARSET_INFO *cs=res.charset();
3275
res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
3276
"bigint(%d)",(int) field_length));
3277
add_zerofill_and_unsigned(res);
3282
Floating-point numbers
3286
Field_real::pack(uchar *to, const uchar *from,
3287
uint max_length, bool low_byte_first)
3289
DBUG_ENTER("Field_real::pack");
3290
DBUG_ASSERT(max_length >= pack_length());
3291
DBUG_PRINT("debug", ("pack_length(): %u", pack_length()));
3292
#ifdef WORDS_BIGENDIAN
3293
if (low_byte_first != table->s->db_low_byte_first)
3295
const uchar *dptr= from + pack_length();
3296
while (dptr-- > from)
3302
DBUG_RETURN(Field::pack(to, from, max_length, low_byte_first));
3306
Field_real::unpack(uchar *to, const uchar *from,
3307
uint param_data, bool low_byte_first)
3309
DBUG_ENTER("Field_real::unpack");
3310
DBUG_PRINT("debug", ("pack_length(): %u", pack_length()));
3311
#ifdef WORDS_BIGENDIAN
3312
if (low_byte_first != table->s->db_low_byte_first)
3314
const uchar *dptr= from + pack_length();
3315
while (dptr-- > from)
3317
DBUG_RETURN(from + pack_length());
3321
DBUG_RETURN(Field::unpack(to, from, param_data, low_byte_first));
3324
/****************************************************************************
3325
single precision float
3326
****************************************************************************/
3328
int Field_float::store(const char *from,uint len,CHARSET_INFO *cs)
3332
double nr= my_strntod(cs,(char*) from,len,&end,&error);
3333
if (error || (!len || (((uint)(end-from) != len) && table->in_use->count_cuted_fields)))
3335
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3336
(error ? ER_WARN_DATA_OUT_OF_RANGE : WARN_DATA_TRUNCATED), 1);
3337
error= error ? 1 : 2;
3339
Field_float::store(nr);
3344
int Field_float::store(double nr)
3346
ASSERT_COLUMN_MARKED_FOR_WRITE;
3347
int error= truncate(&nr, FLT_MAX);
3350
#ifdef WORDS_BIGENDIAN
3351
if (table->s->db_low_byte_first)
3357
memcpy_fixed(ptr,(uchar*) &j,sizeof(j));
3362
int Field_float::store(longlong nr, bool unsigned_val)
3364
return Field_float::store(unsigned_val ? ulonglong2double((uint64_t) nr) :
3369
double Field_float::val_real(void)
3371
ASSERT_COLUMN_MARKED_FOR_READ;
3373
#ifdef WORDS_BIGENDIAN
3374
if (table->s->db_low_byte_first)
3380
memcpy_fixed((uchar*) &j,ptr,sizeof(j));
3381
return ((double) j);
3384
longlong Field_float::val_int(void)
3387
#ifdef WORDS_BIGENDIAN
3388
if (table->s->db_low_byte_first)
3394
memcpy_fixed((uchar*) &j,ptr,sizeof(j));
3395
return (longlong) rint(j);
3399
String *Field_float::val_str(String *val_buffer,
3400
String *val_ptr __attribute__((unused)))
3402
ASSERT_COLUMN_MARKED_FOR_READ;
3404
#ifdef WORDS_BIGENDIAN
3405
if (table->s->db_low_byte_first)
3411
memcpy_fixed((uchar*) &nr,ptr,sizeof(nr));
3413
uint to_length=max(field_length,70);
3414
val_buffer->alloc(to_length);
3415
char *to=(char*) val_buffer->ptr();
3418
if (dec >= NOT_FIXED_DEC)
3419
len= my_gcvt(nr, MY_GCVT_ARG_FLOAT, to_length - 1, to, NULL);
3423
We are safe here because the buffer length is >= 70, and
3424
fabs(float) < 10^39, dec < NOT_FIXED_DEC. So the resulting string
3425
will be not longer than 69 chars + terminating '\0'.
3427
len= my_fcvt(nr, dec, to, NULL);
3429
val_buffer->length((uint) len);
3431
prepend_zeros(val_buffer);
3436
int Field_float::cmp(const uchar *a_ptr, const uchar *b_ptr)
3439
#ifdef WORDS_BIGENDIAN
3440
if (table->s->db_low_byte_first)
3448
memcpy_fixed(&a,a_ptr,sizeof(float));
3449
memcpy_fixed(&b,b_ptr,sizeof(float));
3451
return (a < b) ? -1 : (a > b) ? 1 : 0;
3454
#define FLT_EXP_DIG (sizeof(float)*8-FLT_MANT_DIG)
3456
void Field_float::sort_string(uchar *to,uint length __attribute__((unused)))
3459
#ifdef WORDS_BIGENDIAN
3460
if (table->s->db_low_byte_first)
3466
memcpy_fixed(&nr,ptr,sizeof(float));
3469
if (nr == (float) 0.0)
3470
{ /* Change to zero string */
3472
bzero((char*) tmp+1,sizeof(nr)-1);
3476
#ifdef WORDS_BIGENDIAN
3477
memcpy_fixed(tmp,&nr,sizeof(nr));
3479
tmp[0]= ptr[3]; tmp[1]=ptr[2]; tmp[2]= ptr[1]; tmp[3]=ptr[0];
3481
if (tmp[0] & 128) /* Negative */
3482
{ /* make complement */
3484
for (i=0 ; i < sizeof(nr); i++)
3485
tmp[i]= (uchar) (tmp[i] ^ (uchar) 255);
3489
ushort exp_part=(((ushort) tmp[0] << 8) | (ushort) tmp[1] |
3491
exp_part+= (ushort) 1 << (16-1-FLT_EXP_DIG);
3492
tmp[0]= (uchar) (exp_part >> 8);
3493
tmp[1]= (uchar) exp_part;
3499
bool Field_float::send_binary(Protocol *protocol)
3501
ASSERT_COLUMN_MARKED_FOR_READ;
3502
return protocol->store((float) Field_float::val_real(), dec, (String*) 0);
3507
Save the field metadata for float fields.
3509
Saves the pack length in the first byte.
3511
@param metadata_ptr First byte of field metadata
3513
@returns number of bytes written to metadata_ptr
3515
int Field_float::do_save_field_metadata(uchar *metadata_ptr)
3517
*metadata_ptr= pack_length();
3522
void Field_float::sql_type(String &res) const
3524
if (dec == NOT_FIXED_DEC)
3526
res.set_ascii(STRING_WITH_LEN("float"));
3530
CHARSET_INFO *cs= res.charset();
3531
res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
3532
"float(%d,%d)",(int) field_length,dec));
3534
add_zerofill_and_unsigned(res);
3538
/****************************************************************************
3539
double precision floating point numbers
3540
****************************************************************************/
3542
int Field_double::store(const char *from,uint len,CHARSET_INFO *cs)
3546
double nr= my_strntod(cs,(char*) from, len, &end, &error);
3547
if (error || (!len || (((uint) (end-from) != len) && table->in_use->count_cuted_fields)))
3549
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3550
(error ? ER_WARN_DATA_OUT_OF_RANGE : WARN_DATA_TRUNCATED), 1);
3551
error= error ? 1 : 2;
3553
Field_double::store(nr);
3558
int Field_double::store(double nr)
3560
ASSERT_COLUMN_MARKED_FOR_WRITE;
3561
int error= truncate(&nr, DBL_MAX);
3563
#ifdef WORDS_BIGENDIAN
3564
if (table->s->db_low_byte_first)
3566
float8store(ptr,nr);
3570
doublestore(ptr,nr);
3575
int Field_double::store(longlong nr, bool unsigned_val)
3577
return Field_double::store(unsigned_val ? ulonglong2double((uint64_t) nr) :
3582
If a field has fixed length, truncate the double argument pointed to by 'nr'
3584
Also ensure that the argument is within [-max_value; max_value] range.
3587
int Field_real::truncate(double *nr, double max_value)
3596
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3599
else if (unsigned_flag && res < 0)
3602
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3608
uint order= field_length - dec;
3609
uint step= array_elements(log_10) - 1;
3611
for (; order > step; order-= step)
3612
max_value*= log_10[step];
3613
max_value*= log_10[order];
3614
max_value-= 1.0 / log_10[dec];
3616
/* Check for infinity so we don't get NaN in calculations */
3619
double tmp= rint((res - floor(res)) * log_10[dec]) / log_10[dec];
3620
res= floor(res) + tmp;
3624
if (res < -max_value)
3627
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3629
else if (res > max_value)
3632
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3643
int Field_real::store_decimal(const my_decimal *dm)
3646
my_decimal2double(E_DEC_FATAL_ERROR, dm, &dbl);
3650
double Field_double::val_real(void)
3652
ASSERT_COLUMN_MARKED_FOR_READ;
3654
#ifdef WORDS_BIGENDIAN
3655
if (table->s->db_low_byte_first)
3665
longlong Field_double::val_int(void)
3667
ASSERT_COLUMN_MARKED_FOR_READ;
3670
#ifdef WORDS_BIGENDIAN
3671
if (table->s->db_low_byte_first)
3678
/* Check whether we fit into longlong range */
3679
if (j <= (double) LONGLONG_MIN)
3681
res= (longlong) LONGLONG_MIN;
3684
if (j >= (double) (uint64_t) LONGLONG_MAX)
3686
res= (longlong) LONGLONG_MAX;
3689
return (longlong) rint(j);
3693
char buf[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
3694
String tmp(buf, sizeof(buf), &my_charset_latin1), *str;
3695
str= val_str(&tmp, 0);
3696
push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
3697
ER_TRUNCATED_WRONG_VALUE,
3698
ER(ER_TRUNCATED_WRONG_VALUE), "INTEGER",
3705
my_decimal *Field_real::val_decimal(my_decimal *decimal_value)
3707
ASSERT_COLUMN_MARKED_FOR_READ;
3708
double2my_decimal(E_DEC_FATAL_ERROR, val_real(), decimal_value);
3709
return decimal_value;
3713
String *Field_double::val_str(String *val_buffer,
3714
String *val_ptr __attribute__((unused)))
3716
ASSERT_COLUMN_MARKED_FOR_READ;
3718
#ifdef WORDS_BIGENDIAN
3719
if (table->s->db_low_byte_first)
3727
uint to_length=max(field_length, DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE);
3728
val_buffer->alloc(to_length);
3729
char *to=(char*) val_buffer->ptr();
3732
if (dec >= NOT_FIXED_DEC)
3733
len= my_gcvt(nr, MY_GCVT_ARG_DOUBLE, to_length - 1, to, NULL);
3735
len= my_fcvt(nr, dec, to, NULL);
3737
val_buffer->length((uint) len);
3739
prepend_zeros(val_buffer);
3743
bool Field_double::send_binary(Protocol *protocol)
3745
return protocol->store((double) Field_double::val_real(), dec, (String*) 0);
3749
int Field_double::cmp(const uchar *a_ptr, const uchar *b_ptr)
3751
ASSERT_COLUMN_MARKED_FOR_READ;
3753
#ifdef WORDS_BIGENDIAN
3754
if (table->s->db_low_byte_first)
3762
doubleget(a, a_ptr);
3763
doubleget(b, b_ptr);
3765
return (a < b) ? -1 : (a > b) ? 1 : 0;
3769
#define DBL_EXP_DIG (sizeof(double)*8-DBL_MANT_DIG)
3771
/* The following should work for IEEE */
3773
void Field_double::sort_string(uchar *to,uint length __attribute__((unused)))
3776
#ifdef WORDS_BIGENDIAN
3777
if (table->s->db_low_byte_first)
3784
change_double_for_sort(nr, to);
3789
Save the field metadata for double fields.
3791
Saves the pack length in the first byte of the field metadata array
3792
at index of *metadata_ptr.
3794
@param metadata_ptr First byte of field metadata
3796
@returns number of bytes written to metadata_ptr
3798
int Field_double::do_save_field_metadata(uchar *metadata_ptr)
3800
*metadata_ptr= pack_length();
3805
void Field_double::sql_type(String &res) const
3807
CHARSET_INFO *cs=res.charset();
3808
if (dec == NOT_FIXED_DEC)
3810
res.set_ascii(STRING_WITH_LEN("double"));
3814
res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
3815
"double(%d,%d)",(int) field_length,dec));
3817
add_zerofill_and_unsigned(res);
3822
TIMESTAMP type holds datetime values in range from 1970-01-01 00:00:01 UTC to
3823
2038-01-01 00:00:00 UTC stored as number of seconds since Unix
3826
Up to one of timestamps columns in the table can be automatically
3827
set on row update and/or have NOW() as default value.
3828
TABLE::timestamp_field points to Field object for such timestamp with
3829
auto-set-on-update. TABLE::time_stamp holds offset in record + 1 for this
3830
field, and is used by handler code which performs updates required.
3832
Actually SQL-99 says that we should allow niladic functions (like NOW())
3833
as defaults for any field. Current limitations (only NOW() and only
3834
for one TIMESTAMP field) are because of restricted binary .frm format
3835
and should go away in the future.
3837
Also because of this limitation of binary .frm format we use 5 different
3838
unireg_check values with TIMESTAMP field to distinguish various cases of
3839
DEFAULT or ON UPDATE values. These values are:
3841
TIMESTAMP_OLD_FIELD - old timestamp, if there was not any fields with
3842
auto-set-on-update (or now() as default) in this table before, then this
3843
field has NOW() as default and is updated when row changes, else it is
3844
field which has 0 as default value and is not automatically updated.
3845
TIMESTAMP_DN_FIELD - field with NOW() as default but not set on update
3846
automatically (TIMESTAMP DEFAULT NOW())
3847
TIMESTAMP_UN_FIELD - field which is set on update automatically but has not
3848
NOW() as default (but it may has 0 or some other const timestamp as
3849
default) (TIMESTAMP ON UPDATE NOW()).
3850
TIMESTAMP_DNUN_FIELD - field which has now() as default and is auto-set on
3851
update. (TIMESTAMP DEFAULT NOW() ON UPDATE NOW())
3852
NONE - field which is not auto-set on update with some other than NOW()
3853
default value (TIMESTAMP DEFAULT 0).
3855
Note that TIMESTAMP_OLD_FIELDs are never created explicitly now, they are
3856
left only for preserving ability to read old tables. Such fields replaced
3857
with their newer analogs in CREATE TABLE and in SHOW CREATE TABLE. This is
3858
because we want to prefer NONE unireg_check before TIMESTAMP_OLD_FIELD for
3859
"TIMESTAMP DEFAULT 'Const'" field. (Old timestamps allowed such
3860
specification too but ignored default value for first timestamp, which of
3861
course is non-standard.) In most cases user won't notice any change, only
3862
exception is different behavior of old/new timestamps during ALTER TABLE.
3865
Field_timestamp::Field_timestamp(uchar *ptr_arg, uint32 len_arg,
3866
uchar *null_ptr_arg, uchar null_bit_arg,
3867
enum utype unireg_check_arg,
3868
const char *field_name_arg,
3871
:Field_str(ptr_arg, MAX_DATETIME_WIDTH, null_ptr_arg, null_bit_arg,
3872
unireg_check_arg, field_name_arg, cs)
3874
/* For 4.0 MYD and 4.0 InnoDB compatibility */
3875
flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
3876
if (!share->timestamp_field && unireg_check != NONE)
3878
/* This timestamp has auto-update */
3879
share->timestamp_field= this;
3880
flags|= TIMESTAMP_FLAG;
3881
if (unireg_check != TIMESTAMP_DN_FIELD)
3882
flags|= ON_UPDATE_NOW_FLAG;
3887
Field_timestamp::Field_timestamp(bool maybe_null_arg,
3888
const char *field_name_arg,
3890
:Field_str((uchar*) 0, MAX_DATETIME_WIDTH,
3891
maybe_null_arg ? (uchar*) "": 0, 0,
3892
NONE, field_name_arg, cs)
3894
/* For 4.0 MYD and 4.0 InnoDB compatibility */
3895
flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
3896
if (unireg_check != TIMESTAMP_DN_FIELD)
3897
flags|= ON_UPDATE_NOW_FLAG;
3902
Get auto-set type for TIMESTAMP field.
3904
Returns value indicating during which operations this TIMESTAMP field
3905
should be auto-set to current timestamp.
3907
timestamp_auto_set_type Field_timestamp::get_auto_set_type() const
3909
switch (unireg_check)
3911
case TIMESTAMP_DN_FIELD:
3912
return TIMESTAMP_AUTO_SET_ON_INSERT;
3913
case TIMESTAMP_UN_FIELD:
3914
return TIMESTAMP_AUTO_SET_ON_UPDATE;
3915
case TIMESTAMP_OLD_FIELD:
3917
Although we can have several such columns in legacy tables this
3918
function should be called only for first of them (i.e. the one
3919
having auto-set property).
3921
DBUG_ASSERT(table->timestamp_field == this);
3923
case TIMESTAMP_DNUN_FIELD:
3924
return TIMESTAMP_AUTO_SET_ON_BOTH;
3927
Normally this function should not be called for TIMESTAMPs without
3931
return TIMESTAMP_NO_AUTO_SET;
3936
int Field_timestamp::store(const char *from,uint len,CHARSET_INFO *cs)
3938
ASSERT_COLUMN_MARKED_FOR_WRITE;
3942
bool have_smth_to_conv;
3943
my_bool in_dst_time_gap;
3944
THD *thd= table ? table->in_use : current_thd;
3946
/* We don't want to store invalid or fuzzy datetime values in TIMESTAMP */
3947
have_smth_to_conv= (str_to_datetime(from, len, &l_time, 1, &error) >
3948
MYSQL_TIMESTAMP_ERROR);
3950
if (error || !have_smth_to_conv)
3953
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
3954
from, len, MYSQL_TIMESTAMP_DATETIME, 1);
3957
/* Only convert a correct date (not a zero date) */
3958
if (have_smth_to_conv && l_time.month)
3960
if (!(tmp= TIME_to_timestamp(thd, &l_time, &in_dst_time_gap)))
3962
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3963
ER_WARN_DATA_OUT_OF_RANGE,
3964
from, len, MYSQL_TIMESTAMP_DATETIME, !error);
3967
else if (in_dst_time_gap)
3969
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3970
ER_WARN_INVALID_TIMESTAMP,
3971
from, len, MYSQL_TIMESTAMP_DATETIME, !error);
3975
store_timestamp(tmp);
3980
int Field_timestamp::store(double nr)
3983
if (nr < 0 || nr > 99991231235959.0)
3985
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3986
ER_WARN_DATA_OUT_OF_RANGE,
3987
nr, MYSQL_TIMESTAMP_DATETIME);
3988
nr= 0; // Avoid overflow on buff
3991
error|= Field_timestamp::store((longlong) rint(nr), FALSE);
3996
int Field_timestamp::store(longlong nr, bool unsigned_val)
3998
ASSERT_COLUMN_MARKED_FOR_WRITE;
4000
my_time_t timestamp= 0;
4002
my_bool in_dst_time_gap;
4003
THD *thd= table ? table->in_use : current_thd;
4005
/* We don't want to store invalid or fuzzy datetime values in TIMESTAMP */
4006
longlong tmp= number_to_datetime(nr, &l_time, (thd->variables.sql_mode &
4007
MODE_NO_ZERO_DATE) |
4008
MODE_NO_ZERO_IN_DATE, &error);
4016
if (!(timestamp= TIME_to_timestamp(thd, &l_time, &in_dst_time_gap)))
4018
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4019
ER_WARN_DATA_OUT_OF_RANGE,
4020
nr, MYSQL_TIMESTAMP_DATETIME, 1);
4023
if (in_dst_time_gap)
4025
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4026
ER_WARN_INVALID_TIMESTAMP,
4027
nr, MYSQL_TIMESTAMP_DATETIME, 1);
4031
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4032
WARN_DATA_TRUNCATED,
4033
nr, MYSQL_TIMESTAMP_DATETIME, 1);
4035
store_timestamp(timestamp);
4039
double Field_timestamp::val_real(void)
4041
ASSERT_COLUMN_MARKED_FOR_READ;
4042
return (double) Field_timestamp::val_int();
4045
longlong Field_timestamp::val_int(void)
4047
ASSERT_COLUMN_MARKED_FOR_READ;
4049
MYSQL_TIME time_tmp;
4050
THD *thd= table ? table->in_use : current_thd;
4052
thd->time_zone_used= 1;
4053
#ifdef WORDS_BIGENDIAN
4054
if (table && table->s->db_low_byte_first)
4055
temp=uint4korr(ptr);
4060
if (temp == 0L) // No time
4061
return(0); /* purecov: inspected */
4063
thd->variables.time_zone->gmt_sec_to_TIME(&time_tmp, (my_time_t)temp);
4065
return time_tmp.year * 10000000000LL + time_tmp.month * 100000000LL +
4066
time_tmp.day * 1000000L + time_tmp.hour * 10000L +
4067
time_tmp.minute * 100 + time_tmp.second;
4071
String *Field_timestamp::val_str(String *val_buffer, String *val_ptr)
4073
ASSERT_COLUMN_MARKED_FOR_READ;
4075
MYSQL_TIME time_tmp;
4076
THD *thd= table ? table->in_use : current_thd;
4079
val_buffer->alloc(field_length+1);
4080
to= (char*) val_buffer->ptr();
4081
val_buffer->length(field_length);
4083
thd->time_zone_used= 1;
4084
#ifdef WORDS_BIGENDIAN
4085
if (table && table->s->db_low_byte_first)
4086
temp=uint4korr(ptr);
4092
{ /* Zero time is "000000" */
4093
val_ptr->set(STRING_WITH_LEN("0000-00-00 00:00:00"), &my_charset_bin);
4096
val_buffer->set_charset(&my_charset_bin); // Safety
4098
thd->variables.time_zone->gmt_sec_to_TIME(&time_tmp,(my_time_t)temp);
4100
temp= time_tmp.year % 100;
4101
if (temp < YY_PART_YEAR - 1)
4111
temp2=temp/10; temp=temp-temp2*10;
4112
*to++= (char) ('0'+(char) (temp2));
4113
*to++= (char) ('0'+(char) (temp));
4115
temp=time_tmp.month;
4116
temp2=temp/10; temp=temp-temp2*10;
4117
*to++= (char) ('0'+(char) (temp2));
4118
*to++= (char) ('0'+(char) (temp));
4121
temp2=temp/10; temp=temp-temp2*10;
4122
*to++= (char) ('0'+(char) (temp2));
4123
*to++= (char) ('0'+(char) (temp));
4126
temp2=temp/10; temp=temp-temp2*10;
4127
*to++= (char) ('0'+(char) (temp2));
4128
*to++= (char) ('0'+(char) (temp));
4130
temp=time_tmp.minute;
4131
temp2=temp/10; temp=temp-temp2*10;
4132
*to++= (char) ('0'+(char) (temp2));
4133
*to++= (char) ('0'+(char) (temp));
4135
temp=time_tmp.second;
4136
temp2=temp/10; temp=temp-temp2*10;
4137
*to++= (char) ('0'+(char) (temp2));
4138
*to++= (char) ('0'+(char) (temp));
4144
bool Field_timestamp::get_date(MYSQL_TIME *ltime, uint fuzzydate)
4147
THD *thd= table ? table->in_use : current_thd;
4148
thd->time_zone_used= 1;
4149
#ifdef WORDS_BIGENDIAN
4150
if (table && table->s->db_low_byte_first)
4151
temp=uint4korr(ptr);
4156
{ /* Zero time is "000000" */
4157
if (fuzzydate & TIME_NO_ZERO_DATE)
4159
bzero((char*) ltime,sizeof(*ltime));
4163
thd->variables.time_zone->gmt_sec_to_TIME(ltime, (my_time_t)temp);
4168
bool Field_timestamp::get_time(MYSQL_TIME *ltime)
4170
return Field_timestamp::get_date(ltime,0);
4174
bool Field_timestamp::send_binary(Protocol *protocol)
4177
Field_timestamp::get_date(&tm, 0);
4178
return protocol->store(&tm);
4182
int Field_timestamp::cmp(const uchar *a_ptr, const uchar *b_ptr)
4185
#ifdef WORDS_BIGENDIAN
4186
if (table && table->s->db_low_byte_first)
4197
return ((uint32) a < (uint32) b) ? -1 : ((uint32) a > (uint32) b) ? 1 : 0;
4201
void Field_timestamp::sort_string(uchar *to,uint length __attribute__((unused)))
4203
#ifdef WORDS_BIGENDIAN
4204
if (!table || !table->s->db_low_byte_first)
4222
void Field_timestamp::sql_type(String &res) const
4224
res.set_ascii(STRING_WITH_LEN("timestamp"));
4228
void Field_timestamp::set_time()
4230
THD *thd= table ? table->in_use : current_thd;
4231
long tmp= (long) thd->query_start();
4233
store_timestamp(tmp);
4236
/****************************************************************************
4238
** In string context: HH:MM:SS
4239
** In number context: HHMMSS
4240
** Stored as a 3 byte unsigned int
4241
****************************************************************************/
4243
int Field_time::store(const char *from,uint len,CHARSET_INFO *cs)
4250
if (str_to_time(from, len, <ime, &warning))
4254
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
4255
from, len, MYSQL_TIMESTAMP_TIME, 1);
4259
if (warning & MYSQL_TIME_WARN_TRUNCATED)
4261
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4262
WARN_DATA_TRUNCATED,
4263
from, len, MYSQL_TIMESTAMP_TIME, 1);
4266
if (warning & MYSQL_TIME_WARN_OUT_OF_RANGE)
4268
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4269
ER_WARN_DATA_OUT_OF_RANGE,
4270
from, len, MYSQL_TIMESTAMP_TIME, !error);
4275
tmp=(ltime.day*24L+ltime.hour)*10000L+(ltime.minute*100+ltime.second);
4285
int Field_time::store_time(MYSQL_TIME *ltime, timestamp_type time_type)
4287
long tmp= ((ltime->month ? 0 : ltime->day * 24L) + ltime->hour) * 10000L +
4288
(ltime->minute * 100 + ltime->second);
4291
return Field_time::store((longlong) tmp, FALSE);
4295
int Field_time::store(double nr)
4297
ASSERT_COLUMN_MARKED_FOR_WRITE;
4300
if (nr > (double)TIME_MAX_VALUE)
4302
tmp= TIME_MAX_VALUE;
4303
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4304
ER_WARN_DATA_OUT_OF_RANGE, nr, MYSQL_TIMESTAMP_TIME);
4307
else if (nr < (double)-TIME_MAX_VALUE)
4309
tmp= -TIME_MAX_VALUE;
4310
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4311
ER_WARN_DATA_OUT_OF_RANGE, nr, MYSQL_TIMESTAMP_TIME);
4316
tmp=(long) floor(fabs(nr)); // Remove fractions
4319
if (tmp % 100 > 59 || tmp/100 % 100 > 59)
4322
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4323
ER_WARN_DATA_OUT_OF_RANGE, nr,
4324
MYSQL_TIMESTAMP_TIME);
4333
int Field_time::store(longlong nr, bool unsigned_val)
4335
ASSERT_COLUMN_MARKED_FOR_WRITE;
4338
if (nr < (longlong) -TIME_MAX_VALUE && !unsigned_val)
4340
tmp= -TIME_MAX_VALUE;
4341
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4342
ER_WARN_DATA_OUT_OF_RANGE, nr,
4343
MYSQL_TIMESTAMP_TIME, 1);
4346
else if (nr > (longlong) TIME_MAX_VALUE || (nr < 0 && unsigned_val))
4348
tmp= TIME_MAX_VALUE;
4349
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4350
ER_WARN_DATA_OUT_OF_RANGE, nr,
4351
MYSQL_TIMESTAMP_TIME, 1);
4357
if (tmp % 100 > 59 || tmp/100 % 100 > 59)
4360
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4361
ER_WARN_DATA_OUT_OF_RANGE, nr,
4362
MYSQL_TIMESTAMP_TIME, 1);
4371
double Field_time::val_real(void)
4373
ASSERT_COLUMN_MARKED_FOR_READ;
4374
uint32 j= (uint32) uint3korr(ptr);
4378
longlong Field_time::val_int(void)
4380
ASSERT_COLUMN_MARKED_FOR_READ;
4381
return (longlong) sint3korr(ptr);
4387
This function is multi-byte safe as the result string is always of type
4391
String *Field_time::val_str(String *val_buffer,
4392
String *val_ptr __attribute__((unused)))
4394
ASSERT_COLUMN_MARKED_FOR_READ;
4396
val_buffer->alloc(MAX_DATE_STRING_REP_LENGTH);
4397
long tmp=(long) sint3korr(ptr);
4404
ltime.day= (uint) 0;
4405
ltime.hour= (uint) (tmp/10000);
4406
ltime.minute= (uint) (tmp/100 % 100);
4407
ltime.second= (uint) (tmp % 100);
4408
make_time((DATE_TIME_FORMAT*) 0, <ime, val_buffer);
4415
Normally we would not consider 'time' as a valid date, but we allow
4416
get_date() here to be able to do things like
4417
DATE_FORMAT(time, "%l.%i %p")
4420
bool Field_time::get_date(MYSQL_TIME *ltime, uint fuzzydate)
4423
THD *thd= table ? table->in_use : current_thd;
4424
if (!(fuzzydate & TIME_FUZZY_DATE))
4426
push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
4427
ER_WARN_DATA_OUT_OF_RANGE,
4428
ER(ER_WARN_DATA_OUT_OF_RANGE), field_name,
4432
tmp=(long) sint3korr(ptr);
4439
ltime->hour=tmp/10000;
4440
tmp-=ltime->hour*10000;
4441
ltime->minute= tmp/100;
4442
ltime->second= tmp % 100;
4443
ltime->year= ltime->month= ltime->day= ltime->second_part= 0;
4448
bool Field_time::get_time(MYSQL_TIME *ltime)
4450
long tmp=(long) sint3korr(ptr);
4458
ltime->hour= (int) (tmp/10000);
4459
tmp-=ltime->hour*10000;
4460
ltime->minute= (int) tmp/100;
4461
ltime->second= (int) tmp % 100;
4462
ltime->second_part=0;
4463
ltime->time_type= MYSQL_TIMESTAMP_TIME;
4468
bool Field_time::send_binary(Protocol *protocol)
4471
Field_time::get_time(&tm);
4472
tm.day= tm.hour/24; // Move hours to days
4473
tm.hour-= tm.day*24;
4474
return protocol->store_time(&tm);
4478
int Field_time::cmp(const uchar *a_ptr, const uchar *b_ptr)
4481
a=(int32) sint3korr(a_ptr);
4482
b=(int32) sint3korr(b_ptr);
4483
return (a < b) ? -1 : (a > b) ? 1 : 0;
4486
void Field_time::sort_string(uchar *to,uint length __attribute__((unused)))
4488
to[0] = (uchar) (ptr[2] ^ 128);
4493
void Field_time::sql_type(String &res) const
4495
res.set_ascii(STRING_WITH_LEN("time"));
4498
/****************************************************************************
4500
** Save in a byte the year 0, 1901->2155
4501
** Can handle 2 byte or 4 byte years!
4502
****************************************************************************/
4504
int Field_year::store(const char *from, uint len,CHARSET_INFO *cs)
4506
ASSERT_COLUMN_MARKED_FOR_WRITE;
4509
longlong nr= cs->cset->strntoull10rnd(cs, from, len, 0, &end, &error);
4511
if (nr < 0 || (nr >= 100 && nr <= 1900) || nr > 2155 ||
4512
error == MY_ERRNO_ERANGE)
4515
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
4518
if (table->in_use->count_cuted_fields &&
4519
(error= check_int(cs, from, len, end, error)))
4521
if (error == 1) /* empty or incorrect string */
4529
if (nr != 0 || len != 4)
4531
if (nr < YY_PART_YEAR)
4532
nr+=100; // 2000 - 2069
4536
*ptr= (char) (uchar) nr;
4541
int Field_year::store(double nr)
4543
if (nr < 0.0 || nr >= 2155.0)
4545
(void) Field_year::store((longlong) -1, FALSE);
4548
return Field_year::store((longlong) nr, FALSE);
4552
int Field_year::store(longlong nr, bool unsigned_val)
4554
ASSERT_COLUMN_MARKED_FOR_WRITE;
4555
if (nr < 0 || (nr >= 100 && nr <= 1900) || nr > 2155)
4558
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
4561
if (nr != 0 || field_length != 4) // 0000 -> 0; 00 -> 2000
4563
if (nr < YY_PART_YEAR)
4564
nr+=100; // 2000 - 2069
4568
*ptr= (char) (uchar) nr;
4573
bool Field_year::send_binary(Protocol *protocol)
4575
ASSERT_COLUMN_MARKED_FOR_READ;
4576
uint64_t tmp= Field_year::val_int();
4577
return protocol->store_short(tmp);
4581
double Field_year::val_real(void)
4583
return (double) Field_year::val_int();
4587
longlong Field_year::val_int(void)
4589
ASSERT_COLUMN_MARKED_FOR_READ;
4590
int tmp= (int) ptr[0];
4591
if (field_length != 4)
4592
tmp%=100; // Return last 2 char
4595
return (longlong) tmp;
4599
String *Field_year::val_str(String *val_buffer,
4600
String *val_ptr __attribute__((unused)))
4602
val_buffer->alloc(5);
4603
val_buffer->length(field_length);
4604
char *to=(char*) val_buffer->ptr();
4605
sprintf(to,field_length == 2 ? "%02d" : "%04d",(int) Field_year::val_int());
4610
void Field_year::sql_type(String &res) const
4612
CHARSET_INFO *cs=res.charset();
4613
res.length(cs->cset->snprintf(cs,(char*)res.ptr(),res.alloced_length(),
4614
"year(%d)",(int) field_length));
4618
/****************************************************************************
4620
** In string context: YYYY-MM-DD
4621
** In number context: YYYYMMDD
4622
** Stored as a 4 byte unsigned int
4623
****************************************************************************/
4625
int Field_date::store(const char *from, uint len,CHARSET_INFO *cs)
4627
ASSERT_COLUMN_MARKED_FOR_WRITE;
4631
THD *thd= table ? table->in_use : current_thd;
4633
if (str_to_datetime(from, len, &l_time, TIME_FUZZY_DATE |
4634
(thd->variables.sql_mode &
4635
(MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
4636
MODE_INVALID_DATES)),
4637
&error) <= MYSQL_TIMESTAMP_ERROR)
4643
tmp=(uint32) l_time.year*10000L + (uint32) (l_time.month*100+l_time.day);
4646
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
4647
from, len, MYSQL_TIMESTAMP_DATE, 1);
4649
#ifdef WORDS_BIGENDIAN
4650
if (table && table->s->db_low_byte_first)
4661
int Field_date::store(double nr)
4665
if (nr >= 19000000000000.0 && nr <= 99991231235959.0)
4666
nr=floor(nr/1000000.0); // Timestamp to date
4667
if (nr < 0.0 || nr > 99991231.0)
4670
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4671
ER_WARN_DATA_OUT_OF_RANGE,
4672
nr, MYSQL_TIMESTAMP_DATE);
4676
tmp= (longlong) rint(nr);
4678
return Field_date::store(tmp, TRUE);
4682
int Field_date::store(longlong nr, bool unsigned_val)
4684
ASSERT_COLUMN_MARKED_FOR_WRITE;
4685
MYSQL_TIME not_used;
4687
longlong initial_nr= nr;
4688
THD *thd= table ? table->in_use : current_thd;
4690
nr= number_to_datetime(nr, ¬_used, (TIME_FUZZY_DATE |
4691
(thd->variables.sql_mode &
4692
(MODE_NO_ZERO_IN_DATE |
4694
MODE_INVALID_DATES))), &error);
4702
if (nr >= 19000000000000.0 && nr <= 99991231235959.0)
4703
nr= (longlong) floor(nr/1000000.0); // Timestamp to date
4706
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4707
error == 2 ? ER_WARN_DATA_OUT_OF_RANGE :
4708
WARN_DATA_TRUNCATED, initial_nr,
4709
MYSQL_TIMESTAMP_DATETIME, 1);
4711
#ifdef WORDS_BIGENDIAN
4712
if (table && table->s->db_low_byte_first)
4723
bool Field_date::send_binary(Protocol *protocol)
4725
longlong tmp= Field_date::val_int();
4727
tm.year= (uint32) tmp/10000L % 10000;
4728
tm.month= (uint32) tmp/100 % 100;
4729
tm.day= (uint32) tmp % 100;
4730
return protocol->store_date(&tm);
4734
double Field_date::val_real(void)
4736
ASSERT_COLUMN_MARKED_FOR_READ;
4738
#ifdef WORDS_BIGENDIAN
4739
if (table && table->s->db_low_byte_first)
4744
return (double) (uint32) j;
4748
longlong Field_date::val_int(void)
4750
ASSERT_COLUMN_MARKED_FOR_READ;
4752
#ifdef WORDS_BIGENDIAN
4753
if (table && table->s->db_low_byte_first)
4758
return (longlong) (uint32) j;
4762
String *Field_date::val_str(String *val_buffer,
4763
String *val_ptr __attribute__((unused)))
4765
ASSERT_COLUMN_MARKED_FOR_READ;
4767
val_buffer->alloc(field_length);
4769
#ifdef WORDS_BIGENDIAN
4770
if (table && table->s->db_low_byte_first)
4776
ltime.year= (int) ((uint32) tmp/10000L % 10000);
4777
ltime.month= (int) ((uint32) tmp/100 % 100);
4778
ltime.day= (int) ((uint32) tmp % 100);
4779
make_date((DATE_TIME_FORMAT *) 0, <ime, val_buffer);
4784
bool Field_date::get_time(MYSQL_TIME *ltime)
4786
bzero((char *)ltime, sizeof(MYSQL_TIME));
4791
int Field_date::cmp(const uchar *a_ptr, const uchar *b_ptr)
4794
#ifdef WORDS_BIGENDIAN
4795
if (table && table->s->db_low_byte_first)
4806
return ((uint32) a < (uint32) b) ? -1 : ((uint32) a > (uint32) b) ? 1 : 0;
4810
void Field_date::sort_string(uchar *to,uint length __attribute__((unused)))
4812
#ifdef WORDS_BIGENDIAN
4813
if (!table || !table->s->db_low_byte_first)
4830
void Field_date::sql_type(String &res) const
4832
res.set_ascii(STRING_WITH_LEN("date"));
4836
/****************************************************************************
4837
** The new date type
4838
** This is identical to the old date type, but stored on 3 bytes instead of 4
4839
** In number context: YYYYMMDD
4840
****************************************************************************/
4843
Store string into a date field
4846
Field_newdate::store()
4848
len Length of date field
4849
cs Character set (not used)
4853
1 Value was cut during conversion
4855
3 Datetime value that was cut (warning level NOTE)
4856
This is used by opt_range.cc:get_mm_leaf(). Note that there is a
4857
nearly-identical class Field_date doesn't ever return 3 from its
4861
int Field_newdate::store(const char *from,uint len,CHARSET_INFO *cs)
4863
ASSERT_COLUMN_MARKED_FOR_WRITE;
4867
THD *thd= table ? table->in_use : current_thd;
4868
enum enum_mysql_timestamp_type ret;
4869
if ((ret= str_to_datetime(from, len, &l_time,
4871
(thd->variables.sql_mode &
4872
(MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
4873
MODE_INVALID_DATES))),
4874
&error)) <= MYSQL_TIMESTAMP_ERROR)
4881
tmp= l_time.day + l_time.month*32 + l_time.year*16*32;
4882
if (!error && (ret != MYSQL_TIMESTAMP_DATE) &&
4883
(l_time.hour || l_time.minute || l_time.second || l_time.second_part))
4884
error= 3; // Datetime was cut (note)
4888
set_datetime_warning(error == 3 ? MYSQL_ERROR::WARN_LEVEL_NOTE :
4889
MYSQL_ERROR::WARN_LEVEL_WARN,
4890
WARN_DATA_TRUNCATED,
4891
from, len, MYSQL_TIMESTAMP_DATE, 1);
4893
int3store(ptr, tmp);
4898
int Field_newdate::store(double nr)
4900
if (nr < 0.0 || nr > 99991231235959.0)
4902
int3store(ptr,(int32) 0);
4903
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4904
WARN_DATA_TRUNCATED, nr, MYSQL_TIMESTAMP_DATE);
4907
return Field_newdate::store((longlong) rint(nr), FALSE);
4911
int Field_newdate::store(longlong nr, bool unsigned_val)
4913
ASSERT_COLUMN_MARKED_FOR_WRITE;
4917
THD *thd= table ? table->in_use : current_thd;
4918
if (number_to_datetime(nr, &l_time,
4920
(thd->variables.sql_mode &
4921
(MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
4922
MODE_INVALID_DATES))),
4929
tmp= l_time.day + l_time.month*32 + l_time.year*16*32;
4931
if (!error && l_time.time_type != MYSQL_TIMESTAMP_DATE &&
4932
(l_time.hour || l_time.minute || l_time.second || l_time.second_part))
4936
set_datetime_warning(error == 3 ? MYSQL_ERROR::WARN_LEVEL_NOTE :
4937
MYSQL_ERROR::WARN_LEVEL_WARN,
4939
ER_WARN_DATA_OUT_OF_RANGE : WARN_DATA_TRUNCATED,
4940
nr,MYSQL_TIMESTAMP_DATE, 1);
4947
int Field_newdate::store_time(MYSQL_TIME *ltime,timestamp_type time_type)
4949
ASSERT_COLUMN_MARKED_FOR_WRITE;
4952
if (time_type == MYSQL_TIMESTAMP_DATE ||
4953
time_type == MYSQL_TIMESTAMP_DATETIME)
4955
tmp=ltime->year*16*32+ltime->month*32+ltime->day;
4956
if (check_date(ltime, tmp != 0,
4958
(current_thd->variables.sql_mode &
4959
(MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
4960
MODE_INVALID_DATES))), &error))
4962
char buff[MAX_DATE_STRING_REP_LENGTH];
4963
String str(buff, sizeof(buff), &my_charset_latin1);
4964
make_date((DATE_TIME_FORMAT *) 0, ltime, &str);
4965
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
4966
str.ptr(), str.length(), MYSQL_TIMESTAMP_DATE, 1);
4968
if (!error && ltime->time_type != MYSQL_TIMESTAMP_DATE &&
4969
(ltime->hour || ltime->minute || ltime->second || ltime->second_part))
4971
char buff[MAX_DATE_STRING_REP_LENGTH];
4972
String str(buff, sizeof(buff), &my_charset_latin1);
4973
make_datetime((DATE_TIME_FORMAT *) 0, ltime, &str);
4974
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_NOTE,
4975
WARN_DATA_TRUNCATED,
4976
str.ptr(), str.length(), MYSQL_TIMESTAMP_DATE, 1);
4984
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
4991
bool Field_newdate::send_binary(Protocol *protocol)
4994
Field_newdate::get_date(&tm,0);
4995
return protocol->store_date(&tm);
4999
double Field_newdate::val_real(void)
5001
ASSERT_COLUMN_MARKED_FOR_READ;
5002
return (double) Field_newdate::val_int();
5006
longlong Field_newdate::val_int(void)
5008
ASSERT_COLUMN_MARKED_FOR_READ;
5009
ulong j= uint3korr(ptr);
5010
j= (j % 32L)+(j / 32L % 16L)*100L + (j/(16L*32L))*10000L;
5011
return (longlong) j;
5015
String *Field_newdate::val_str(String *val_buffer,
5016
String *val_ptr __attribute__((unused)))
5018
ASSERT_COLUMN_MARKED_FOR_READ;
5019
val_buffer->alloc(field_length);
5020
val_buffer->length(field_length);
5021
uint32 tmp=(uint32) uint3korr(ptr);
5023
char *pos=(char*) val_buffer->ptr()+10;
5025
/* Open coded to get more speed */
5026
*pos--=0; // End NULL
5027
part=(int) (tmp & 31);
5028
*pos--= (char) ('0'+part%10);
5029
*pos--= (char) ('0'+part/10);
5031
part=(int) (tmp >> 5 & 15);
5032
*pos--= (char) ('0'+part%10);
5033
*pos--= (char) ('0'+part/10);
5035
part=(int) (tmp >> 9);
5036
*pos--= (char) ('0'+part%10); part/=10;
5037
*pos--= (char) ('0'+part%10); part/=10;
5038
*pos--= (char) ('0'+part%10); part/=10;
5039
*pos= (char) ('0'+part);
5044
bool Field_newdate::get_date(MYSQL_TIME *ltime,uint fuzzydate)
5046
uint32 tmp=(uint32) uint3korr(ptr);
5047
ltime->day= tmp & 31;
5048
ltime->month= (tmp >> 5) & 15;
5049
ltime->year= (tmp >> 9);
5050
ltime->time_type= MYSQL_TIMESTAMP_DATE;
5051
ltime->hour= ltime->minute= ltime->second= ltime->second_part= ltime->neg= 0;
5052
return ((!(fuzzydate & TIME_FUZZY_DATE) && (!ltime->month || !ltime->day)) ?
5057
bool Field_newdate::get_time(MYSQL_TIME *ltime)
5059
return Field_newdate::get_date(ltime,0);
5063
int Field_newdate::cmp(const uchar *a_ptr, const uchar *b_ptr)
5066
a=(uint32) uint3korr(a_ptr);
5067
b=(uint32) uint3korr(b_ptr);
5068
return (a < b) ? -1 : (a > b) ? 1 : 0;
5072
void Field_newdate::sort_string(uchar *to,uint length __attribute__((unused)))
5080
void Field_newdate::sql_type(String &res) const
5082
res.set_ascii(STRING_WITH_LEN("date"));
5086
/****************************************************************************
5088
** In string context: YYYY-MM-DD HH:MM:DD
5089
** In number context: YYYYMMDDHHMMDD
5090
** Stored as a 8 byte unsigned int. Should sometimes be change to a 6 byte int.
5091
****************************************************************************/
5093
int Field_datetime::store(const char *from,uint len,CHARSET_INFO *cs)
5095
ASSERT_COLUMN_MARKED_FOR_WRITE;
5096
MYSQL_TIME time_tmp;
5099
enum enum_mysql_timestamp_type func_res;
5100
THD *thd= table ? table->in_use : current_thd;
5102
func_res= str_to_datetime(from, len, &time_tmp,
5104
(thd->variables.sql_mode &
5105
(MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
5106
MODE_INVALID_DATES))),
5108
if ((int) func_res > (int) MYSQL_TIMESTAMP_ERROR)
5109
tmp= TIME_to_ulonglong_datetime(&time_tmp);
5111
error= 1; // Fix if invalid zero date
5114
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
5115
ER_WARN_DATA_OUT_OF_RANGE,
5116
from, len, MYSQL_TIMESTAMP_DATETIME, 1);
5118
#ifdef WORDS_BIGENDIAN
5119
if (table && table->s->db_low_byte_first)
5125
longlongstore(ptr,tmp);
5130
int Field_datetime::store(double nr)
5133
if (nr < 0.0 || nr > 99991231235959.0)
5135
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
5136
ER_WARN_DATA_OUT_OF_RANGE,
5137
nr, MYSQL_TIMESTAMP_DATETIME);
5141
error|= Field_datetime::store((longlong) rint(nr), FALSE);
5146
int Field_datetime::store(longlong nr, bool unsigned_val)
5148
ASSERT_COLUMN_MARKED_FOR_WRITE;
5149
MYSQL_TIME not_used;
5151
longlong initial_nr= nr;
5152
THD *thd= table ? table->in_use : current_thd;
5154
nr= number_to_datetime(nr, ¬_used, (TIME_FUZZY_DATE |
5155
(thd->variables.sql_mode &
5156
(MODE_NO_ZERO_IN_DATE |
5158
MODE_INVALID_DATES))), &error);
5167
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
5168
error == 2 ? ER_WARN_DATA_OUT_OF_RANGE :
5169
WARN_DATA_TRUNCATED, initial_nr,
5170
MYSQL_TIMESTAMP_DATETIME, 1);
5172
#ifdef WORDS_BIGENDIAN
5173
if (table && table->s->db_low_byte_first)
5179
longlongstore(ptr,nr);
5184
int Field_datetime::store_time(MYSQL_TIME *ltime,timestamp_type time_type)
5186
ASSERT_COLUMN_MARKED_FOR_WRITE;
5190
We don't perform range checking here since values stored in TIME
5191
structure always fit into DATETIME range.
5193
if (time_type == MYSQL_TIMESTAMP_DATE ||
5194
time_type == MYSQL_TIMESTAMP_DATETIME)
5196
tmp=((ltime->year*10000L+ltime->month*100+ltime->day)*1000000LL+
5197
(ltime->hour*10000L+ltime->minute*100+ltime->second));
5198
if (check_date(ltime, tmp != 0,
5200
(current_thd->variables.sql_mode &
5201
(MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
5202
MODE_INVALID_DATES))), &error))
5204
char buff[MAX_DATE_STRING_REP_LENGTH];
5205
String str(buff, sizeof(buff), &my_charset_latin1);
5206
make_datetime((DATE_TIME_FORMAT *) 0, ltime, &str);
5207
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
5208
str.ptr(), str.length(), MYSQL_TIMESTAMP_DATETIME,1);
5215
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
5217
#ifdef WORDS_BIGENDIAN
5218
if (table && table->s->db_low_byte_first)
5224
longlongstore(ptr,tmp);
5228
bool Field_datetime::send_binary(Protocol *protocol)
5231
Field_datetime::get_date(&tm, TIME_FUZZY_DATE);
5232
return protocol->store(&tm);
5236
double Field_datetime::val_real(void)
5238
return (double) Field_datetime::val_int();
5241
longlong Field_datetime::val_int(void)
5243
ASSERT_COLUMN_MARKED_FOR_READ;
5245
#ifdef WORDS_BIGENDIAN
5246
if (table && table->s->db_low_byte_first)
5255
String *Field_datetime::val_str(String *val_buffer,
5256
String *val_ptr __attribute__((unused)))
5258
ASSERT_COLUMN_MARKED_FOR_READ;
5259
val_buffer->alloc(field_length);
5260
val_buffer->length(field_length);
5266
#ifdef WORDS_BIGENDIAN
5267
if (table && table->s->db_low_byte_first)
5271
longlongget(tmp,ptr);
5274
Avoid problem with slow longlong arithmetic and sprintf
5277
part1=(long) (tmp/1000000LL);
5278
part2=(long) (tmp - (uint64_t) part1*1000000LL);
5280
pos=(char*) val_buffer->ptr() + MAX_DATETIME_WIDTH;
5282
*pos--= (char) ('0'+(char) (part2%10)); part2/=10;
5283
*pos--= (char) ('0'+(char) (part2%10)); part3= (int) (part2 / 10);
5285
*pos--= (char) ('0'+(char) (part3%10)); part3/=10;
5286
*pos--= (char) ('0'+(char) (part3%10)); part3/=10;
5288
*pos--= (char) ('0'+(char) (part3%10)); part3/=10;
5289
*pos--= (char) ('0'+(char) part3);
5291
*pos--= (char) ('0'+(char) (part1%10)); part1/=10;
5292
*pos--= (char) ('0'+(char) (part1%10)); part1/=10;
5294
*pos--= (char) ('0'+(char) (part1%10)); part1/=10;
5295
*pos--= (char) ('0'+(char) (part1%10)); part3= (int) (part1/10);
5297
*pos--= (char) ('0'+(char) (part3%10)); part3/=10;
5298
*pos--= (char) ('0'+(char) (part3%10)); part3/=10;
5299
*pos--= (char) ('0'+(char) (part3%10)); part3/=10;
5300
*pos=(char) ('0'+(char) part3);
5304
bool Field_datetime::get_date(MYSQL_TIME *ltime, uint fuzzydate)
5306
longlong tmp=Field_datetime::val_int();
5308
part1=(uint32) (tmp/1000000LL);
5309
part2=(uint32) (tmp - (uint64_t) part1*1000000LL);
5311
ltime->time_type= MYSQL_TIMESTAMP_DATETIME;
5313
ltime->second_part= 0;
5314
ltime->second= (int) (part2%100);
5315
ltime->minute= (int) (part2/100%100);
5316
ltime->hour= (int) (part2/10000);
5317
ltime->day= (int) (part1%100);
5318
ltime->month= (int) (part1/100%100);
5319
ltime->year= (int) (part1/10000);
5320
return (!(fuzzydate & TIME_FUZZY_DATE) && (!ltime->month || !ltime->day)) ? 1 : 0;
5323
bool Field_datetime::get_time(MYSQL_TIME *ltime)
5325
return Field_datetime::get_date(ltime,0);
5328
int Field_datetime::cmp(const uchar *a_ptr, const uchar *b_ptr)
5331
#ifdef WORDS_BIGENDIAN
5332
if (table && table->s->db_low_byte_first)
5340
longlongget(a,a_ptr);
5341
longlongget(b,b_ptr);
5343
return ((uint64_t) a < (uint64_t) b) ? -1 :
5344
((uint64_t) a > (uint64_t) b) ? 1 : 0;
5347
void Field_datetime::sort_string(uchar *to,uint length __attribute__((unused)))
5349
#ifdef WORDS_BIGENDIAN
5350
if (!table || !table->s->db_low_byte_first)
5376
void Field_datetime::sql_type(String &res) const
5378
res.set_ascii(STRING_WITH_LEN("datetime"));
5381
/****************************************************************************
5383
** A string may be varchar or binary
5384
****************************************************************************/
5387
Report "not well formed" or "cannot convert" error
5388
after storing a character string info a field.
5391
check_string_copy_error()
5393
well_formed_error_pos - where not well formed data was first met
5394
cannot_convert_error_pos - where a not-convertable character was first met
5395
end - end of the string
5396
cs - character set of the string
5399
As of version 5.0 both cases return the same error:
5401
"Invalid string value: 'xxx' for column 't' at row 1"
5403
Future versions will possibly introduce a new error message:
5405
"Cannot convert character string: 'xxx' for column 't' at row 1"
5408
FALSE - If errors didn't happen
5409
TRUE - If an error happened
5413
check_string_copy_error(Field_str *field,
5414
const char *well_formed_error_pos,
5415
const char *cannot_convert_error_pos,
5419
const char *pos, *end_orig;
5422
if (!(pos= well_formed_error_pos) &&
5423
!(pos= cannot_convert_error_pos))
5427
set_if_smaller(end, pos + 6);
5429
for (t= tmp; pos < end; pos++)
5432
If the source string is ASCII compatible (mbminlen==1)
5433
and the source character is in ASCII printable range (0x20..0x7F),
5434
then display the character as is.
5436
Otherwise, if the source string is not ASCII compatible (e.g. UCS2),
5437
or the source character is not in the printable range,
5438
then print the character using HEX notation.
5440
if (((unsigned char) *pos) >= 0x20 &&
5441
((unsigned char) *pos) <= 0x7F &&
5450
*t++= _dig_vec_upper[((unsigned char) *pos) >> 4];
5451
*t++= _dig_vec_upper[((unsigned char) *pos) & 15];
5461
push_warning_printf(field->table->in_use,
5462
field->table->in_use->abort_on_warning ?
5463
MYSQL_ERROR::WARN_LEVEL_ERROR :
5464
MYSQL_ERROR::WARN_LEVEL_WARN,
5465
ER_TRUNCATED_WRONG_VALUE_FOR_FIELD,
5466
ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
5467
"string", tmp, field->field_name,
5468
(ulong) field->table->in_use->row_count);
5474
Check if we lost any important data and send a truncation error/warning
5477
Field_longstr::report_if_important_data()
5478
ptr - Truncated rest of string
5479
end - End of truncated string
5482
0 - None was truncated (or we don't count cut fields)
5483
2 - Some bytes was truncated
5486
Check if we lost any important data (anything in a binary string,
5487
or any non-space in others). If only trailing spaces was lost,
5488
send a truncation note, otherwise send a truncation error.
5492
Field_longstr::report_if_important_data(const char *ptr, const char *end)
5494
if ((ptr < end) && table->in_use->count_cuted_fields)
5496
if (test_if_important_data(field_charset, ptr, end))
5498
if (table->in_use->abort_on_warning)
5499
set_warning(MYSQL_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
5501
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
5503
else /* If we lost only spaces then produce a NOTE, not a WARNING */
5504
set_warning(MYSQL_ERROR::WARN_LEVEL_NOTE, WARN_DATA_TRUNCATED, 1);
5511
/* Copy a string and fill with space */
5513
int Field_string::store(const char *from,uint length,CHARSET_INFO *cs)
5515
ASSERT_COLUMN_MARKED_FOR_WRITE;
5517
const char *well_formed_error_pos;
5518
const char *cannot_convert_error_pos;
5519
const char *from_end_pos;
5521
/* See the comment for Field_long::store(long long) */
5522
DBUG_ASSERT(table->in_use == current_thd);
5524
copy_length= well_formed_copy_nchars(field_charset,
5525
(char*) ptr, field_length,
5527
field_length / field_charset->mbmaxlen,
5528
&well_formed_error_pos,
5529
&cannot_convert_error_pos,
5532
/* Append spaces if the string was shorter than the field. */
5533
if (copy_length < field_length)
5534
field_charset->cset->fill(field_charset,(char*) ptr+copy_length,
5535
field_length-copy_length,
5536
field_charset->pad_char);
5538
if (check_string_copy_error(this, well_formed_error_pos,
5539
cannot_convert_error_pos, from + length, cs))
5542
return report_if_important_data(from_end_pos, from + length);
5547
Store double value in Field_string or Field_varstring.
5549
Pretty prints double number into field_length characters buffer.
5554
int Field_str::store(double nr)
5556
ASSERT_COLUMN_MARKED_FOR_WRITE;
5557
char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
5558
uint local_char_length= field_length / charset()->mbmaxlen;
5562
length= my_gcvt(nr, MY_GCVT_ARG_DOUBLE, local_char_length, buff, &error);
5565
if (table->in_use->abort_on_warning)
5566
set_warning(MYSQL_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
5568
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
5570
return store(buff, length, charset());
5574
uint Field::is_equal(Create_field *new_field)
5576
return (new_field->sql_type == real_type());
5580
/* If one of the fields is binary and the other one isn't return 1 else 0 */
5582
bool Field_str::compare_str_field_flags(Create_field *new_field, uint32 flag_arg)
5584
return (((new_field->flags & (BINCMP_FLAG | BINARY_FLAG)) &&
5585
!(flag_arg & (BINCMP_FLAG | BINARY_FLAG))) ||
5586
(!(new_field->flags & (BINCMP_FLAG | BINARY_FLAG)) &&
5587
(flag_arg & (BINCMP_FLAG | BINARY_FLAG))));
5591
uint Field_str::is_equal(Create_field *new_field)
5593
if (compare_str_field_flags(new_field, flags))
5596
return ((new_field->sql_type == real_type()) &&
5597
new_field->charset == field_charset &&
5598
new_field->length == max_display_length());
5602
int Field_string::store(longlong nr, bool unsigned_val)
5606
CHARSET_INFO *cs=charset();
5607
l= (cs->cset->longlong10_to_str)(cs,buff,sizeof(buff),
5608
unsigned_val ? 10 : -10, nr);
5609
return Field_string::store(buff,(uint)l,cs);
5613
int Field_longstr::store_decimal(const my_decimal *d)
5615
char buff[DECIMAL_MAX_STR_LENGTH+1];
5616
String str(buff, sizeof(buff), &my_charset_bin);
5617
my_decimal2string(E_DEC_FATAL_ERROR, d, 0, 0, 0, &str);
5618
return store(str.ptr(), str.length(), str.charset());
5621
uint32 Field_longstr::max_data_length() const
5623
return field_length + (field_length > 255 ? 2 : 1);
5627
double Field_string::val_real(void)
5629
ASSERT_COLUMN_MARKED_FOR_READ;
5632
CHARSET_INFO *cs= charset();
5635
result= my_strntod(cs,(char*) ptr,field_length,&end,&error);
5636
if (!table->in_use->no_errors &&
5637
(error || (field_length != (uint32)(end - (char*) ptr) &&
5638
!check_if_only_end_space(cs, end,
5639
(char*) ptr + field_length))))
5641
char buf[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
5642
String tmp(buf, sizeof(buf), cs);
5643
tmp.copy((char*) ptr, field_length, cs);
5644
push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
5645
ER_TRUNCATED_WRONG_VALUE,
5646
ER(ER_TRUNCATED_WRONG_VALUE),
5647
"DOUBLE", tmp.c_ptr());
5653
longlong Field_string::val_int(void)
5655
ASSERT_COLUMN_MARKED_FOR_READ;
5658
CHARSET_INFO *cs= charset();
5661
result= my_strntoll(cs, (char*) ptr,field_length,10,&end,&error);
5662
if (!table->in_use->no_errors &&
5663
(error || (field_length != (uint32)(end - (char*) ptr) &&
5664
!check_if_only_end_space(cs, end,
5665
(char*) ptr + field_length))))
5667
char buf[LONGLONG_TO_STRING_CONVERSION_BUFFER_SIZE];
5668
String tmp(buf, sizeof(buf), cs);
5669
tmp.copy((char*) ptr, field_length, cs);
5670
push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
5671
ER_TRUNCATED_WRONG_VALUE,
5672
ER(ER_TRUNCATED_WRONG_VALUE),
5673
"INTEGER", tmp.c_ptr());
5679
String *Field_string::val_str(String *val_buffer __attribute__((unused)),
5682
ASSERT_COLUMN_MARKED_FOR_READ;
5683
/* See the comment for Field_long::store(long long) */
5684
DBUG_ASSERT(table->in_use == current_thd);
5686
if (table->in_use->variables.sql_mode &
5687
MODE_PAD_CHAR_TO_FULL_LENGTH)
5688
length= my_charpos(field_charset, ptr, ptr + field_length, field_length);
5690
length= field_charset->cset->lengthsp(field_charset, (const char*) ptr,
5692
val_ptr->set((const char*) ptr, length, field_charset);
5697
my_decimal *Field_string::val_decimal(my_decimal *decimal_value)
5699
ASSERT_COLUMN_MARKED_FOR_READ;
5700
int err= str2my_decimal(E_DEC_FATAL_ERROR, (char*) ptr, field_length,
5701
charset(), decimal_value);
5702
if (!table->in_use->no_errors && err)
5704
char buf[DECIMAL_TO_STRING_CONVERSION_BUFFER_SIZE];
5705
CHARSET_INFO *cs= charset();
5706
String tmp(buf, sizeof(buf), cs);
5707
tmp.copy((char*) ptr, field_length, cs);
5708
push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
5709
ER_TRUNCATED_WRONG_VALUE,
5710
ER(ER_TRUNCATED_WRONG_VALUE),
5711
"DECIMAL", tmp.c_ptr());
5714
return decimal_value;
5718
int Field_string::cmp(const uchar *a_ptr, const uchar *b_ptr)
5722
if (field_charset->mbmaxlen != 1)
5724
uint char_len= field_length/field_charset->mbmaxlen;
5725
a_len= my_charpos(field_charset, a_ptr, a_ptr + field_length, char_len);
5726
b_len= my_charpos(field_charset, b_ptr, b_ptr + field_length, char_len);
5729
a_len= b_len= field_length;
5731
We have to remove end space to be able to compare multi-byte-characters
5732
like in latin_de 'ae' and 0xe4
5734
return field_charset->coll->strnncollsp(field_charset,
5741
void Field_string::sort_string(uchar *to,uint length)
5743
IF_DBUG(uint tmp=) my_strnxfrm(field_charset,
5746
DBUG_ASSERT(tmp == length);
5750
void Field_string::sql_type(String &res) const
5752
THD *thd= table->in_use;
5753
CHARSET_INFO *cs=res.charset();
5756
length= cs->cset->snprintf(cs,(char*) res.ptr(),
5757
res.alloced_length(), "%s(%d)",
5758
((type() == MYSQL_TYPE_VAR_STRING &&
5759
!thd->variables.new_mode) ?
5760
(has_charset() ? "varchar" : "varbinary") :
5761
(has_charset() ? "char" : "binary")),
5762
(int) field_length / charset()->mbmaxlen);
5764
if ((thd->variables.sql_mode & (MODE_MYSQL323 | MODE_MYSQL40)) &&
5765
has_charset() && (charset()->state & MY_CS_BINSORT))
5766
res.append(STRING_WITH_LEN(" binary"));
5770
uchar *Field_string::pack(uchar *to, const uchar *from,
5772
bool low_byte_first __attribute__((unused)))
5774
uint length= min(field_length,max_length);
5775
uint local_char_length= max_length/field_charset->mbmaxlen;
5776
if (length > local_char_length)
5777
local_char_length= my_charpos(field_charset, from, from+length,
5779
set_if_smaller(length, local_char_length);
5780
while (length && from[length-1] == field_charset->pad_char)
5783
// Length always stored little-endian
5784
*to++= (uchar) length;
5785
if (field_length > 255)
5786
*to++= (uchar) (length >> 8);
5788
// Store the actual bytes of the string
5789
memcpy(to, from, length);
5795
Unpack a string field from row data.
5797
This method is used to unpack a string field from a master whose size
5798
of the field is less than that of the slave. Note that there can be a
5799
variety of field types represented with this class. Certain types like
5800
ENUM or SET are processed differently. Hence, the upper byte of the
5801
@c param_data argument contains the result of field->real_type() from
5804
@param to Destination of the data
5805
@param from Source of the data
5806
@param param_data Real type (upper) and length (lower) values
5808
@return New pointer into memory based on from + length of the data
5811
Field_string::unpack(uchar *to,
5814
bool low_byte_first __attribute__((unused)))
5817
param_data ? min(param_data & 0x00ff, field_length) : field_length;
5820
if (from_length > 255)
5822
length= uint2korr(from);
5826
length= (uint) *from++;
5828
memcpy(to, from, length);
5829
// Pad the string with the pad character of the fields charset
5830
bfill(to + length, field_length - length, field_charset->pad_char);
5836
Save the field metadata for string fields.
5838
Saves the real type in the first byte and the field length in the
5839
second byte of the field metadata array at index of *metadata_ptr and
5840
*(metadata_ptr + 1).
5842
@param metadata_ptr First byte of field metadata
5844
@returns number of bytes written to metadata_ptr
5846
int Field_string::do_save_field_metadata(uchar *metadata_ptr)
5848
*metadata_ptr= real_type();
5849
*(metadata_ptr + 1)= field_length;
5855
Compare two packed keys
5862
insert_or_update 1 if this is an insert or update
5870
int Field_string::pack_cmp(const uchar *a, const uchar *b, uint length,
5871
my_bool insert_or_update)
5873
uint a_length, b_length;
5876
a_length= uint2korr(a);
5877
b_length= uint2korr(b);
5883
a_length= (uint) *a++;
5884
b_length= (uint) *b++;
5886
return field_charset->coll->strnncollsp(field_charset,
5894
Compare a packed key against row.
5896
@param key Original key
5897
@param length Key length. (May be less than field length)
5898
@param insert_or_update 1 if this is an insert or update
5908
int Field_string::pack_cmp(const uchar *key, uint length,
5909
my_bool insert_or_update)
5911
uint row_length, local_key_length;
5915
local_key_length= uint2korr(key);
5919
local_key_length= (uint) *key++;
5921
/* Only use 'length' of key, not field_length */
5923
while (end > ptr && end[-1] == ' ')
5925
row_length= (uint) (end - ptr);
5927
return field_charset->coll->strnncollsp(field_charset,
5929
key, local_key_length,
5934
uint Field_string::packed_col_length(const uchar *data_ptr, uint length)
5937
return uint2korr(data_ptr)+2;
5938
return (uint) *data_ptr + 1;
5942
uint Field_string::max_packed_col_length(uint max_length)
5944
return (max_length > 255 ? 2 : 1)+max_length;
5948
uint Field_string::get_key_image(uchar *buff, uint length, imagetype type_arg)
5950
uint bytes = my_charpos(field_charset, (char*) ptr,
5951
(char*) ptr + field_length,
5952
length / field_charset->mbmaxlen);
5953
memcpy(buff, ptr, bytes);
5955
field_charset->cset->fill(field_charset, (char*) buff + bytes,
5956
length - bytes, field_charset->pad_char);
5961
Field *Field_string::new_field(MEM_ROOT *root, struct st_table *new_table,
5965
if (type() != MYSQL_TYPE_VAR_STRING || keep_type)
5966
field= Field::new_field(root, new_table, keep_type);
5967
else if ((field= new Field_varstring(field_length, maybe_null(), field_name,
5968
new_table->s, charset())))
5971
Old VARCHAR field which should be modified to a VARCHAR on copy
5972
This is done to ensure that ALTER TABLE will convert old VARCHAR fields
5973
to now VARCHAR fields.
5975
field->init(new_table);
5977
Normally orig_table is different from table only if field was created
5978
via ::new_field. Here we alter the type of field, so ::new_field is
5979
not applicable. But we still need to preserve the original field
5980
metadata for the client-server protocol.
5982
field->orig_table= orig_table;
5988
/****************************************************************************
5990
Data in field->ptr is stored as:
5991
1 or 2 bytes length-prefix-header (from Field_varstring::length_bytes)
5995
When VARCHAR is stored in a key (for handler::index_read() etc) it's always
5996
stored with a 2 byte prefix. (Just like blob keys).
5998
Normally length_bytes is calculated as (field_length < 256 : 1 ? 2)
5999
The exception is if there is a prefix key field that is part of a long
6000
VARCHAR, in which case field_length for this may be 1 but the length_bytes
6002
****************************************************************************/
6004
const uint Field_varstring::MAX_SIZE= UINT_MAX16;
6007
Save the field metadata for varstring fields.
6009
Saves the field length in the first byte. Note: may consume
6010
2 bytes. Caller must ensure second byte is contiguous with
6011
first byte (e.g. array index 0,1).
6013
@param metadata_ptr First byte of field metadata
6015
@returns number of bytes written to metadata_ptr
6017
int Field_varstring::do_save_field_metadata(uchar *metadata_ptr)
6019
char *ptr= (char *)metadata_ptr;
6020
DBUG_ASSERT(field_length <= 65535);
6021
int2store(ptr, field_length);
6025
int Field_varstring::store(const char *from,uint length,CHARSET_INFO *cs)
6027
ASSERT_COLUMN_MARKED_FOR_WRITE;
6029
const char *well_formed_error_pos;
6030
const char *cannot_convert_error_pos;
6031
const char *from_end_pos;
6033
copy_length= well_formed_copy_nchars(field_charset,
6034
(char*) ptr + length_bytes,
6037
field_length / field_charset->mbmaxlen,
6038
&well_formed_error_pos,
6039
&cannot_convert_error_pos,
6042
if (length_bytes == 1)
6043
*ptr= (uchar) copy_length;
6045
int2store(ptr, copy_length);
6047
if (check_string_copy_error(this, well_formed_error_pos,
6048
cannot_convert_error_pos, from + length, cs))
6051
return report_if_important_data(from_end_pos, from + length);
6055
int Field_varstring::store(longlong nr, bool unsigned_val)
6059
length= (uint) (field_charset->cset->longlong10_to_str)(field_charset,
6065
return Field_varstring::store(buff, length, field_charset);
6069
double Field_varstring::val_real(void)
6071
ASSERT_COLUMN_MARKED_FOR_READ;
6074
uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
6075
return my_strntod(field_charset, (char*) ptr+length_bytes, length,
6076
&end_not_used, ¬_used);
6080
longlong Field_varstring::val_int(void)
6082
ASSERT_COLUMN_MARKED_FOR_READ;
6085
uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
6086
return my_strntoll(field_charset, (char*) ptr+length_bytes, length, 10,
6087
&end_not_used, ¬_used);
6090
String *Field_varstring::val_str(String *val_buffer __attribute__((unused)),
6093
ASSERT_COLUMN_MARKED_FOR_READ;
6094
uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
6095
val_ptr->set((const char*) ptr+length_bytes, length, field_charset);
6100
my_decimal *Field_varstring::val_decimal(my_decimal *decimal_value)
6102
ASSERT_COLUMN_MARKED_FOR_READ;
6103
uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
6104
str2my_decimal(E_DEC_FATAL_ERROR, (char*) ptr+length_bytes, length,
6105
charset(), decimal_value);
6106
return decimal_value;
6110
int Field_varstring::cmp_max(const uchar *a_ptr, const uchar *b_ptr,
6113
uint a_length, b_length;
6116
if (length_bytes == 1)
6118
a_length= (uint) *a_ptr;
6119
b_length= (uint) *b_ptr;
6123
a_length= uint2korr(a_ptr);
6124
b_length= uint2korr(b_ptr);
6126
set_if_smaller(a_length, max_len);
6127
set_if_smaller(b_length, max_len);
6128
diff= field_charset->coll->strnncollsp(field_charset,
6141
varstring and blob keys are ALWAYS stored with a 2 byte length prefix
6144
int Field_varstring::key_cmp(const uchar *key_ptr, uint max_key_length)
6146
uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
6147
uint local_char_length= max_key_length / field_charset->mbmaxlen;
6149
local_char_length= my_charpos(field_charset, ptr + length_bytes,
6150
ptr + length_bytes + length, local_char_length);
6151
set_if_smaller(length, local_char_length);
6152
return field_charset->coll->strnncollsp(field_charset,
6157
uint2korr(key_ptr), 0);
6162
Compare to key segments (always 2 byte length prefix).
6165
This is used only to compare key segments created for index_read().
6166
(keys are created and compared in key.cc)
6169
int Field_varstring::key_cmp(const uchar *a,const uchar *b)
6171
return field_charset->coll->strnncollsp(field_charset,
6172
a + HA_KEY_BLOB_LENGTH,
6174
b + HA_KEY_BLOB_LENGTH,
6180
void Field_varstring::sort_string(uchar *to,uint length)
6182
uint tot_length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
6184
if (field_charset == &my_charset_bin)
6186
/* Store length last in high-byte order to sort longer strings first */
6187
if (length_bytes == 1)
6188
to[length-1]= tot_length;
6190
mi_int2store(to+length-2, tot_length);
6191
length-= length_bytes;
6194
tot_length= my_strnxfrm(field_charset,
6195
to, length, ptr + length_bytes,
6197
DBUG_ASSERT(tot_length == length);
6201
enum ha_base_keytype Field_varstring::key_type() const
6203
enum ha_base_keytype res;
6206
res= length_bytes == 1 ? HA_KEYTYPE_VARBINARY1 : HA_KEYTYPE_VARBINARY2;
6208
res= length_bytes == 1 ? HA_KEYTYPE_VARTEXT1 : HA_KEYTYPE_VARTEXT2;
6213
void Field_varstring::sql_type(String &res) const
6215
THD *thd= table->in_use;
6216
CHARSET_INFO *cs=res.charset();
6219
length= cs->cset->snprintf(cs,(char*) res.ptr(),
6220
res.alloced_length(), "%s(%d)",
6221
(has_charset() ? "varchar" : "varbinary"),
6222
(int) field_length / charset()->mbmaxlen);
6224
if ((thd->variables.sql_mode & (MODE_MYSQL323 | MODE_MYSQL40)) &&
6225
has_charset() && (charset()->state & MY_CS_BINSORT))
6226
res.append(STRING_WITH_LEN(" binary"));
6230
uint32 Field_varstring::data_length()
6232
return length_bytes == 1 ? (uint32) *ptr : uint2korr(ptr);
6235
uint32 Field_varstring::used_length()
6237
return length_bytes == 1 ? 1 + (uint32) (uchar) *ptr : 2 + uint2korr(ptr);
6241
Functions to create a packed row.
6242
Here the number of length bytes are depending on the given max_length
6245
uchar *Field_varstring::pack(uchar *to, const uchar *from,
6247
bool low_byte_first __attribute__((unused)))
6249
uint length= length_bytes == 1 ? (uint) *from : uint2korr(from);
6250
set_if_smaller(max_length, field_length);
6251
if (length > max_length)
6254
/* Length always stored little-endian */
6255
*to++= length & 0xFF;
6256
if (max_length > 255)
6257
*to++= (length >> 8) & 0xFF;
6259
/* Store bytes of string */
6261
memcpy(to, from+length_bytes, length);
6267
Field_varstring::pack_key(uchar *to, const uchar *key, uint max_length,
6268
bool low_byte_first __attribute__((unused)))
6270
uint length= length_bytes == 1 ? (uint) *key : uint2korr(key);
6271
uint local_char_length= ((field_charset->mbmaxlen > 1) ?
6272
max_length/field_charset->mbmaxlen : max_length);
6274
if (length > local_char_length)
6276
local_char_length= my_charpos(field_charset, key, key+length,
6278
set_if_smaller(length, local_char_length);
6280
*to++= (char) (length & 255);
6281
if (max_length > 255)
6282
*to++= (char) (length >> 8);
6284
memcpy(to, key, length);
6290
Unpack a key into a record buffer.
6292
A VARCHAR key has a maximum size of 64K-1.
6293
In its packed form, the length field is one or two bytes long,
6294
depending on 'max_length'.
6296
@param to Pointer into the record buffer.
6297
@param key Pointer to the packed key.
6298
@param max_length Key length limit from key description.
6301
Pointer to end of 'key' (To the next key part if multi-segment key)
6305
Field_varstring::unpack_key(uchar *to, const uchar *key, uint max_length,
6306
bool low_byte_first __attribute__((unused)))
6308
/* get length of the blob key */
6309
uint32 length= *key++;
6310
if (max_length > 255)
6311
length+= (*key++) << 8;
6313
/* put the length into the record buffer */
6314
if (length_bytes == 1)
6315
*ptr= (uchar) length;
6317
int2store(ptr, length);
6318
memcpy(ptr + length_bytes, key, length);
6319
return key + length;
6323
Create a packed key that will be used for storage in the index tree.
6325
@param to Store packed key segment here
6326
@param from Key segment (as given to index_read())
6327
@param max_length Max length of key
6334
Field_varstring::pack_key_from_key_image(uchar *to, const uchar *from, uint max_length,
6335
bool low_byte_first __attribute__((unused)))
6337
/* Key length is always stored as 2 bytes */
6338
uint length= uint2korr(from);
6339
if (length > max_length)
6341
*to++= (char) (length & 255);
6342
if (max_length > 255)
6343
*to++= (char) (length >> 8);
6345
memcpy(to, from+HA_KEY_BLOB_LENGTH, length);
6351
Unpack a varstring field from row data.
6353
This method is used to unpack a varstring field from a master
6354
whose size of the field is less than that of the slave.
6357
The string length is always packed little-endian.
6359
@param to Destination of the data
6360
@param from Source of the data
6361
@param param_data Length bytes from the master's field data
6363
@return New pointer into memory based on from + length of the data
6366
Field_varstring::unpack(uchar *to, const uchar *from,
6368
bool low_byte_first __attribute__((unused)))
6371
uint l_bytes= (param_data && (param_data < field_length)) ?
6372
(param_data <= 255) ? 1 : 2 : length_bytes;
6377
if (length_bytes == 2)
6380
else /* l_bytes == 2 */
6382
length= uint2korr(from);
6387
memcpy(to+ length_bytes, from, length);
6392
int Field_varstring::pack_cmp(const uchar *a, const uchar *b,
6393
uint key_length_arg,
6394
my_bool insert_or_update)
6396
uint a_length, b_length;
6397
if (key_length_arg > 255)
6399
a_length=uint2korr(a); a+= 2;
6400
b_length=uint2korr(b); b+= 2;
6404
a_length= (uint) *a++;
6405
b_length= (uint) *b++;
6407
return field_charset->coll->strnncollsp(field_charset,
6414
int Field_varstring::pack_cmp(const uchar *b, uint key_length_arg,
6415
my_bool insert_or_update)
6417
uchar *a= ptr+ length_bytes;
6418
uint a_length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
6420
uint local_char_length= ((field_charset->mbmaxlen > 1) ?
6421
key_length_arg / field_charset->mbmaxlen :
6424
if (key_length_arg > 255)
6426
b_length=uint2korr(b); b+= HA_KEY_BLOB_LENGTH;
6429
b_length= (uint) *b++;
6431
if (a_length > local_char_length)
6433
local_char_length= my_charpos(field_charset, a, a+a_length,
6435
set_if_smaller(a_length, local_char_length);
6438
return field_charset->coll->strnncollsp(field_charset,
6445
uint Field_varstring::packed_col_length(const uchar *data_ptr, uint length)
6448
return uint2korr(data_ptr)+2;
6449
return (uint) *data_ptr + 1;
6453
uint Field_varstring::max_packed_col_length(uint max_length)
6455
return (max_length > 255 ? 2 : 1)+max_length;
6458
uint Field_varstring::get_key_image(uchar *buff, uint length, imagetype type)
6460
uint f_length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
6461
uint local_char_length= length / field_charset->mbmaxlen;
6462
uchar *pos= ptr+length_bytes;
6463
local_char_length= my_charpos(field_charset, pos, pos + f_length,
6465
set_if_smaller(f_length, local_char_length);
6466
/* Key is always stored with 2 bytes */
6467
int2store(buff,f_length);
6468
memcpy(buff+HA_KEY_BLOB_LENGTH, pos, f_length);
6469
if (f_length < length)
6472
Must clear this as we do a memcmp in opt_range.cc to detect
6475
bzero(buff+HA_KEY_BLOB_LENGTH+f_length, (length-f_length));
6477
return HA_KEY_BLOB_LENGTH+f_length;
6481
void Field_varstring::set_key_image(const uchar *buff,uint length)
6483
length= uint2korr(buff); // Real length is here
6484
(void) Field_varstring::store((const char*) buff+HA_KEY_BLOB_LENGTH, length,
6489
int Field_varstring::cmp_binary(const uchar *a_ptr, const uchar *b_ptr,
6492
uint32 a_length,b_length;
6494
if (length_bytes == 1)
6496
a_length= (uint) *a_ptr;
6497
b_length= (uint) *b_ptr;
6501
a_length= uint2korr(a_ptr);
6502
b_length= uint2korr(b_ptr);
6504
set_if_smaller(a_length, max_length);
6505
set_if_smaller(b_length, max_length);
6506
if (a_length != b_length)
6508
return memcmp(a_ptr+length_bytes, b_ptr+length_bytes, a_length);
6512
Field *Field_varstring::new_field(MEM_ROOT *root, struct st_table *new_table,
6515
Field_varstring *res= (Field_varstring*) Field::new_field(root, new_table,
6518
res->length_bytes= length_bytes;
6523
Field *Field_varstring::new_key_field(MEM_ROOT *root,
6524
struct st_table *new_table,
6525
uchar *new_ptr, uchar *new_null_ptr,
6528
Field_varstring *res;
6529
if ((res= (Field_varstring*) Field::new_key_field(root,
6535
/* Keys length prefixes are always packed with 2 bytes */
6536
res->length_bytes= 2;
6542
uint Field_varstring::is_equal(Create_field *new_field)
6544
if (new_field->sql_type == real_type() &&
6545
new_field->charset == field_charset)
6547
if (new_field->length == max_display_length())
6548
return IS_EQUAL_YES;
6549
if (new_field->length > max_display_length() &&
6550
((new_field->length <= 255 && max_display_length() <= 255) ||
6551
(new_field->length > 255 && max_display_length() > 255)))
6552
return IS_EQUAL_PACK_LENGTH; // VARCHAR, longer variable length
6558
void Field_varstring::hash(ulong *nr, ulong *nr2)
6562
*nr^= (*nr << 1) | 1;
6566
uint len= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
6567
CHARSET_INFO *cs= charset();
6568
cs->coll->hash_sort(cs, ptr + length_bytes, len, nr, nr2);
6573
/****************************************************************************
6575
** A blob is saved as a length and a pointer. The length is stored in the
6576
** packlength slot and may be from 1-4.
6577
****************************************************************************/
6579
Field_blob::Field_blob(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
6580
enum utype unireg_check_arg, const char *field_name_arg,
6581
TABLE_SHARE *share, uint blob_pack_length,
6583
:Field_longstr(ptr_arg, BLOB_PACK_LENGTH_TO_MAX_LENGH(blob_pack_length),
6584
null_ptr_arg, null_bit_arg, unireg_check_arg, field_name_arg,
6586
packlength(blob_pack_length)
6589
share->blob_fields++;
6590
/* TODO: why do not fill table->s->blob_field array here? */
6594
void Field_blob::store_length(uchar *i_ptr,
6597
bool low_byte_first)
6599
switch (i_packlength) {
6601
i_ptr[0]= (uchar) i_number;
6604
#ifdef WORDS_BIGENDIAN
6607
int2store(i_ptr,(unsigned short) i_number);
6611
shortstore(i_ptr,(unsigned short) i_number);
6614
int3store(i_ptr,i_number);
6617
#ifdef WORDS_BIGENDIAN
6620
int4store(i_ptr,i_number);
6624
longstore(i_ptr,i_number);
6629
uint32 Field_blob::get_length(const uchar *pos, uint packlength_arg, bool low_byte_first)
6631
switch (packlength_arg) {
6633
return (uint32) pos[0];
6637
#ifdef WORDS_BIGENDIAN
6643
return (uint32) tmp;
6646
return (uint32) uint3korr(pos);
6650
#ifdef WORDS_BIGENDIAN
6656
return (uint32) tmp;
6659
return 0; // Impossible
6664
Put a blob length field into a record buffer.
6666
Depending on the maximum length of a blob, its length field is
6667
put into 1 to 4 bytes. This is a property of the blob object,
6668
described by 'packlength'.
6670
@param pos Pointer into the record buffer.
6671
@param length The length value to put.
6674
void Field_blob::put_length(uchar *pos, uint32 length)
6676
switch (packlength) {
6678
*pos= (char) length;
6681
int2store(pos, length);
6684
int3store(pos, length);
6687
int4store(pos, length);
6693
int Field_blob::store(const char *from,uint length,CHARSET_INFO *cs)
6695
ASSERT_COLUMN_MARKED_FOR_WRITE;
6696
uint copy_length, new_length;
6697
const char *well_formed_error_pos;
6698
const char *cannot_convert_error_pos;
6699
const char *from_end_pos, *tmp;
6700
char buff[STRING_BUFFER_USUAL_SIZE];
6701
String tmpstr(buff,sizeof(buff), &my_charset_bin);
6705
bzero(ptr,Field_blob::pack_length());
6709
if (from == value.ptr())
6711
uint32 dummy_offset;
6712
if (!String::needs_conversion(length, cs, field_charset, &dummy_offset))
6714
Field_blob::store_length(length);
6715
bmove(ptr+packlength,(char*) &from,sizeof(char*));
6718
if (tmpstr.copy(from, length, cs))
6723
new_length= min(max_data_length(), field_charset->mbmaxlen * length);
6724
if (value.alloc(new_length))
6728
if (f_is_hex_escape(flags))
6730
copy_length= my_copy_with_hex_escaping(field_charset,
6731
(char*) value.ptr(), new_length,
6733
Field_blob::store_length(copy_length);
6735
bmove(ptr + packlength, (uchar*) &tmp, sizeof(char*));
6739
"length" is OK as "nchars" argument to well_formed_copy_nchars as this
6740
is never used to limit the length of the data. The cut of long data
6741
is done with the new_length value.
6743
copy_length= well_formed_copy_nchars(field_charset,
6744
(char*) value.ptr(), new_length,
6747
&well_formed_error_pos,
6748
&cannot_convert_error_pos,
6751
Field_blob::store_length(copy_length);
6753
bmove(ptr+packlength,(uchar*) &tmp,sizeof(char*));
6755
if (check_string_copy_error(this, well_formed_error_pos,
6756
cannot_convert_error_pos, from + length, cs))
6759
return report_if_important_data(from_end_pos, from + length);
6762
/* Fatal OOM error */
6763
bzero(ptr,Field_blob::pack_length());
6768
int Field_blob::store(double nr)
6770
CHARSET_INFO *cs=charset();
6771
value.set_real(nr, NOT_FIXED_DEC, cs);
6772
return Field_blob::store(value.ptr(),(uint) value.length(), cs);
6776
int Field_blob::store(longlong nr, bool unsigned_val)
6778
CHARSET_INFO *cs=charset();
6779
value.set_int(nr, unsigned_val, cs);
6780
return Field_blob::store(value.ptr(), (uint) value.length(), cs);
6784
double Field_blob::val_real(void)
6786
ASSERT_COLUMN_MARKED_FOR_READ;
6788
char *end_not_used, *blob;
6792
memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
6795
length= get_length(ptr);
6797
return my_strntod(cs, blob, length, &end_not_used, ¬_used);
6801
longlong Field_blob::val_int(void)
6803
ASSERT_COLUMN_MARKED_FOR_READ;
6806
memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
6809
uint32 length=get_length(ptr);
6810
return my_strntoll(charset(),blob,length,10,NULL,¬_used);
6813
String *Field_blob::val_str(String *val_buffer __attribute__((unused)),
6816
ASSERT_COLUMN_MARKED_FOR_READ;
6818
memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
6820
val_ptr->set("",0,charset()); // A bit safer than ->length(0)
6822
val_ptr->set((const char*) blob,get_length(ptr),charset());
6827
my_decimal *Field_blob::val_decimal(my_decimal *decimal_value)
6829
ASSERT_COLUMN_MARKED_FOR_READ;
6832
memcpy_fixed(&blob, ptr+packlength, sizeof(const uchar*));
6839
length= get_length(ptr);
6841
str2my_decimal(E_DEC_FATAL_ERROR, blob, length, charset(),
6843
return decimal_value;
6847
int Field_blob::cmp(const uchar *a,uint32 a_length, const uchar *b,
6850
return field_charset->coll->strnncollsp(field_charset,
6851
a, a_length, b, b_length,
6856
int Field_blob::cmp_max(const uchar *a_ptr, const uchar *b_ptr,
6859
uchar *blob1,*blob2;
6860
memcpy_fixed(&blob1,a_ptr+packlength,sizeof(char*));
6861
memcpy_fixed(&blob2,b_ptr+packlength,sizeof(char*));
6862
uint a_len= get_length(a_ptr), b_len= get_length(b_ptr);
6863
set_if_smaller(a_len, max_length);
6864
set_if_smaller(b_len, max_length);
6865
return Field_blob::cmp(blob1,a_len,blob2,b_len);
6869
int Field_blob::cmp_binary(const uchar *a_ptr, const uchar *b_ptr,
6874
uint32 a_length,b_length;
6875
memcpy_fixed(&a,a_ptr+packlength,sizeof(char*));
6876
memcpy_fixed(&b,b_ptr+packlength,sizeof(char*));
6877
a_length=get_length(a_ptr);
6878
if (a_length > max_length)
6879
a_length=max_length;
6880
b_length=get_length(b_ptr);
6881
if (b_length > max_length)
6882
b_length=max_length;
6883
diff=memcmp(a,b,min(a_length,b_length));
6884
return diff ? diff : (int) (a_length - b_length);
6888
/* The following is used only when comparing a key */
6890
uint Field_blob::get_key_image(uchar *buff,uint length, imagetype type_arg)
6892
uint32 blob_length= get_length(ptr);
6896
uint local_char_length= length / field_charset->mbmaxlen;
6897
local_char_length= my_charpos(field_charset, blob, blob + blob_length,
6899
set_if_smaller(blob_length, local_char_length);
6901
if ((uint32) length > blob_length)
6904
Must clear this as we do a memcmp in opt_range.cc to detect
6907
bzero(buff+HA_KEY_BLOB_LENGTH+blob_length, (length-blob_length));
6908
length=(uint) blob_length;
6910
int2store(buff,length);
6911
memcpy(buff+HA_KEY_BLOB_LENGTH, blob, length);
6912
return HA_KEY_BLOB_LENGTH+length;
6916
void Field_blob::set_key_image(const uchar *buff,uint length)
6918
length= uint2korr(buff);
6919
(void) Field_blob::store((const char*) buff+HA_KEY_BLOB_LENGTH, length,
6924
int Field_blob::key_cmp(const uchar *key_ptr, uint max_key_length)
6927
uint blob_length=get_length(ptr);
6928
memcpy_fixed(&blob1,ptr+packlength,sizeof(char*));
6929
CHARSET_INFO *cs= charset();
6930
uint local_char_length= max_key_length / cs->mbmaxlen;
6931
local_char_length= my_charpos(cs, blob1, blob1+blob_length,
6933
set_if_smaller(blob_length, local_char_length);
6934
return Field_blob::cmp(blob1, blob_length,
6935
key_ptr+HA_KEY_BLOB_LENGTH,
6936
uint2korr(key_ptr));
6939
int Field_blob::key_cmp(const uchar *a,const uchar *b)
6941
return Field_blob::cmp(a+HA_KEY_BLOB_LENGTH, uint2korr(a),
6942
b+HA_KEY_BLOB_LENGTH, uint2korr(b));
6947
Save the field metadata for blob fields.
6949
Saves the pack length in the first byte of the field metadata array
6950
at index of *metadata_ptr.
6952
@param metadata_ptr First byte of field metadata
6954
@returns number of bytes written to metadata_ptr
6956
int Field_blob::do_save_field_metadata(uchar *metadata_ptr)
6958
*metadata_ptr= pack_length_no_ptr();
6963
uint32 Field_blob::sort_length() const
6965
return (uint32) (current_thd->variables.max_sort_length +
6966
(field_charset == &my_charset_bin ? 0 : packlength));
6970
void Field_blob::sort_string(uchar *to,uint length)
6973
uint blob_length=get_length();
6979
if (field_charset == &my_charset_bin)
6984
Store length of blob last in blob to shorter blobs before longer blobs
6986
length-= packlength;
6989
switch (packlength) {
6991
*pos= (char) blob_length;
6994
mi_int2store(pos, blob_length);
6997
mi_int3store(pos, blob_length);
7000
mi_int4store(pos, blob_length);
7004
memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
7006
blob_length=my_strnxfrm(field_charset,
7007
to, length, blob, blob_length);
7008
DBUG_ASSERT(blob_length == length);
7013
void Field_blob::sql_type(String &res) const
7017
switch (packlength) {
7018
default: str="tiny"; length=4; break;
7019
case 2: str=""; length=0; break;
7020
case 3: str="medium"; length= 6; break;
7021
case 4: str="long"; length=4; break;
7023
res.set_ascii(str,length);
7024
if (charset() == &my_charset_bin)
7025
res.append(STRING_WITH_LEN("blob"));
7028
res.append(STRING_WITH_LEN("text"));
7032
uchar *Field_blob::pack(uchar *to, const uchar *from,
7033
uint max_length, bool low_byte_first)
7035
DBUG_ENTER("Field_blob::pack");
7036
DBUG_PRINT("enter", ("to: 0x%lx; from: 0x%lx;"
7037
" max_length: %u; low_byte_first: %d",
7038
(ulong) to, (ulong) from,
7039
max_length, low_byte_first));
7040
DBUG_DUMP("record", from, table->s->reclength);
7043
uint32 length=get_length(); // Length of from string
7046
Store max length, which will occupy packlength bytes. If the max
7047
length given is smaller than the actual length of the blob, we
7048
just store the initial bytes of the blob.
7050
store_length(to, packlength, min(length, max_length), low_byte_first);
7053
Store the actual blob data, which will occupy 'length' bytes.
7057
get_ptr((uchar**) &from);
7058
memcpy(to+packlength, from,length);
7060
ptr=save; // Restore org row pointer
7061
DBUG_DUMP("packed", to, packlength + length);
7062
DBUG_RETURN(to+packlength+length);
7067
Unpack a blob field from row data.
7069
This method is used to unpack a blob field from a master whose size of
7070
the field is less than that of the slave. Note: This method is included
7071
to satisfy inheritance rules, but is not needed for blob fields. It
7072
simply is used as a pass-through to the original unpack() method for
7075
@param to Destination of the data
7076
@param from Source of the data
7077
@param param_data @c TRUE if base types should be stored in little-
7078
endian format, @c FALSE if native format should
7081
@return New pointer into memory based on from + length of the data
7083
const uchar *Field_blob::unpack(uchar *to,
7086
bool low_byte_first)
7088
DBUG_ENTER("Field_blob::unpack");
7089
DBUG_PRINT("enter", ("to: 0x%lx; from: 0x%lx;"
7090
" param_data: %u; low_byte_first: %d",
7091
(ulong) to, (ulong) from, param_data, low_byte_first));
7092
uint const master_packlength=
7093
param_data > 0 ? param_data & 0xFF : packlength;
7094
uint32 const length= get_length(from, master_packlength, low_byte_first);
7095
DBUG_DUMP("packed", from, length + master_packlength);
7096
bitmap_set_bit(table->write_set, field_index);
7097
store(reinterpret_cast<const char*>(from) + master_packlength,
7098
length, field_charset);
7099
DBUG_DUMP("record", to, table->s->reclength);
7100
DBUG_RETURN(from + master_packlength + length);
7103
/* Keys for blobs are like keys on varchars */
7105
int Field_blob::pack_cmp(const uchar *a, const uchar *b, uint key_length_arg,
7106
my_bool insert_or_update)
7108
uint a_length, b_length;
7109
if (key_length_arg > 255)
7111
a_length=uint2korr(a); a+=2;
7112
b_length=uint2korr(b); b+=2;
7116
a_length= (uint) *a++;
7117
b_length= (uint) *b++;
7119
return field_charset->coll->strnncollsp(field_charset,
7126
int Field_blob::pack_cmp(const uchar *b, uint key_length_arg,
7127
my_bool insert_or_update)
7130
uint a_length, b_length;
7131
memcpy_fixed(&a,ptr+packlength,sizeof(char*));
7133
return key_length_arg > 0 ? -1 : 0;
7135
a_length= get_length(ptr);
7136
if (key_length_arg > 255)
7138
b_length= uint2korr(b); b+=2;
7141
b_length= (uint) *b++;
7142
return field_charset->coll->strnncollsp(field_charset,
7148
/** Create a packed key that will be used for storage from a MySQL row. */
7151
Field_blob::pack_key(uchar *to, const uchar *from, uint max_length,
7152
bool low_byte_first __attribute__((unused)))
7156
uint32 length=get_length(); // Length of from string
7157
uint local_char_length= ((field_charset->mbmaxlen > 1) ?
7158
max_length/field_charset->mbmaxlen : max_length);
7160
get_ptr((uchar**) &from);
7161
if (length > local_char_length)
7162
local_char_length= my_charpos(field_charset, from, from+length,
7164
set_if_smaller(length, local_char_length);
7165
*to++= (uchar) length;
7166
if (max_length > 255) // 2 byte length
7167
*to++= (uchar) (length >> 8);
7168
memcpy(to, from, length);
7169
ptr=save; // Restore org row pointer
7175
Unpack a blob key into a record buffer.
7177
A blob key has a maximum size of 64K-1.
7178
In its packed form, the length field is one or two bytes long,
7179
depending on 'max_length'.
7180
Depending on the maximum length of a blob, its length field is
7181
put into 1 to 4 bytes. This is a property of the blob object,
7182
described by 'packlength'.
7183
Blobs are internally stored apart from the record buffer, which
7184
contains a pointer to the blob buffer.
7187
@param to Pointer into the record buffer.
7188
@param from Pointer to the packed key.
7189
@param max_length Key length limit from key description.
7192
Pointer into 'from' past the last byte copied from packed key.
7196
Field_blob::unpack_key(uchar *to, const uchar *from, uint max_length,
7197
bool low_byte_first __attribute__((unused)))
7199
/* get length of the blob key */
7200
uint32 length= *from++;
7201
if (max_length > 255)
7202
length+= *from++ << 8;
7204
/* put the length into the record buffer */
7205
put_length(to, length);
7207
/* put the address of the blob buffer or NULL */
7209
memcpy_fixed(to + packlength, &from, sizeof(from));
7211
bzero(to + packlength, sizeof(from));
7213
/* point to first byte of next field in 'from' */
7214
return from + length;
7218
/** Create a packed key that will be used for storage from a MySQL key. */
7221
Field_blob::pack_key_from_key_image(uchar *to, const uchar *from, uint max_length,
7222
bool low_byte_first __attribute__((unused)))
7224
uint length=uint2korr(from);
7225
if (length > max_length)
7227
*to++= (char) (length & 255);
7228
if (max_length > 255)
7229
*to++= (char) (length >> 8);
7231
memcpy(to, from+HA_KEY_BLOB_LENGTH, length);
7236
uint Field_blob::packed_col_length(const uchar *data_ptr, uint length)
7239
return uint2korr(data_ptr)+2;
7240
return (uint) *data_ptr + 1;
7244
uint Field_blob::max_packed_col_length(uint max_length)
7246
return (max_length > 255 ? 2 : 1)+max_length;
7250
uint Field_blob::is_equal(Create_field *new_field)
7252
if (compare_str_field_flags(new_field, flags))
7255
return ((new_field->sql_type == get_blob_type_from_length(max_data_length()))
7256
&& new_field->charset == field_charset &&
7257
((Field_blob *)new_field->field)->max_data_length() ==
7262
/****************************************************************************
7264
** This is a string which only can have a selection of different values.
7265
** If one uses this string in a number context one gets the type number.
7266
****************************************************************************/
7268
enum ha_base_keytype Field_enum::key_type() const
7270
switch (packlength) {
7271
default: return HA_KEYTYPE_BINARY;
7272
case 2: return HA_KEYTYPE_USHORT_INT;
7273
case 3: return HA_KEYTYPE_UINT24;
7274
case 4: return HA_KEYTYPE_ULONG_INT;
7275
case 8: return HA_KEYTYPE_ULONGLONG;
7279
void Field_enum::store_type(uint64_t value)
7281
switch (packlength) {
7282
case 1: ptr[0]= (uchar) value; break;
7284
#ifdef WORDS_BIGENDIAN
7285
if (table->s->db_low_byte_first)
7287
int2store(ptr,(unsigned short) value);
7291
shortstore(ptr,(unsigned short) value);
7293
case 3: int3store(ptr,(long) value); break;
7295
#ifdef WORDS_BIGENDIAN
7296
if (table->s->db_low_byte_first)
7298
int4store(ptr,value);
7302
longstore(ptr,(long) value);
7305
#ifdef WORDS_BIGENDIAN
7306
if (table->s->db_low_byte_first)
7308
int8store(ptr,value);
7312
longlongstore(ptr,value); break;
7319
Storing a empty string in a enum field gives a warning
7320
(if there isn't a empty value in the enum)
7323
int Field_enum::store(const char *from,uint length,CHARSET_INFO *cs)
7325
ASSERT_COLUMN_MARKED_FOR_WRITE;
7328
char buff[STRING_BUFFER_USUAL_SIZE];
7329
String tmpstr(buff,sizeof(buff), &my_charset_bin);
7331
/* Convert character set if necessary */
7332
if (String::needs_conversion(length, cs, field_charset, ¬_used))
7335
tmpstr.copy(from, length, cs, field_charset, &dummy_errors);
7337
length= tmpstr.length();
7340
/* Remove end space */
7341
length= field_charset->cset->lengthsp(field_charset, from, length);
7342
uint tmp=find_type2(typelib, from, length, field_charset);
7345
if (length < 6) // Can't be more than 99999 enums
7347
/* This is for reading numbers with LOAD DATA INFILE */
7349
tmp=(uint) my_strntoul(cs,from,length,10,&end,&err);
7350
if (err || end != from+length || tmp > typelib->count)
7353
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
7355
if (!table->in_use->count_cuted_fields)
7359
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
7361
store_type((uint64_t) tmp);
7366
int Field_enum::store(double nr)
7368
return Field_enum::store((longlong) nr, FALSE);
7372
int Field_enum::store(longlong nr, bool unsigned_val)
7374
ASSERT_COLUMN_MARKED_FOR_WRITE;
7376
if ((uint64_t) nr > typelib->count || nr == 0)
7378
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
7379
if (nr != 0 || table->in_use->count_cuted_fields)
7385
store_type((uint64_t) (uint) nr);
7390
double Field_enum::val_real(void)
7392
return (double) Field_enum::val_int();
7396
longlong Field_enum::val_int(void)
7398
ASSERT_COLUMN_MARKED_FOR_READ;
7399
switch (packlength) {
7401
return (longlong) ptr[0];
7405
#ifdef WORDS_BIGENDIAN
7406
if (table->s->db_low_byte_first)
7411
return (longlong) tmp;
7414
return (longlong) uint3korr(ptr);
7418
#ifdef WORDS_BIGENDIAN
7419
if (table->s->db_low_byte_first)
7424
return (longlong) tmp;
7429
#ifdef WORDS_BIGENDIAN
7430
if (table->s->db_low_byte_first)
7434
longlongget(tmp,ptr);
7438
return 0; // impossible
7443
Save the field metadata for enum fields.
7445
Saves the real type in the first byte and the pack length in the
7446
second byte of the field metadata array at index of *metadata_ptr and
7447
*(metadata_ptr + 1).
7449
@param metadata_ptr First byte of field metadata
7451
@returns number of bytes written to metadata_ptr
7453
int Field_enum::do_save_field_metadata(uchar *metadata_ptr)
7455
*metadata_ptr= real_type();
7456
*(metadata_ptr + 1)= pack_length();
7461
String *Field_enum::val_str(String *val_buffer __attribute__((unused)),
7464
uint tmp=(uint) Field_enum::val_int();
7465
if (!tmp || tmp > typelib->count)
7466
val_ptr->set("", 0, field_charset);
7468
val_ptr->set((const char*) typelib->type_names[tmp-1],
7469
typelib->type_lengths[tmp-1],
7474
int Field_enum::cmp(const uchar *a_ptr, const uchar *b_ptr)
7477
ptr= (uchar*) a_ptr;
7478
uint64_t a=Field_enum::val_int();
7479
ptr= (uchar*) b_ptr;
7480
uint64_t b=Field_enum::val_int();
7482
return (a < b) ? -1 : (a > b) ? 1 : 0;
7485
void Field_enum::sort_string(uchar *to,uint length __attribute__((unused)))
7487
uint64_t value=Field_enum::val_int();
7489
for (uint i=0 ; i < packlength ; i++)
7491
*to-- = (uchar) (value & 255);
7497
void Field_enum::sql_type(String &res) const
7500
String enum_item(buffer, sizeof(buffer), res.charset());
7503
res.append(STRING_WITH_LEN("enum("));
7506
uint *len= typelib->type_lengths;
7507
for (const char **pos= typelib->type_names; *pos; pos++, len++)
7512
/* convert to res.charset() == utf8, then quote */
7513
enum_item.copy(*pos, *len, charset(), res.charset(), &dummy_errors);
7514
append_unescaped(&res, enum_item.ptr(), enum_item.length());
7521
Field *Field_enum::new_field(MEM_ROOT *root, struct st_table *new_table,
7524
Field_enum *res= (Field_enum*) Field::new_field(root, new_table, keep_type);
7526
res->typelib= copy_typelib(root, typelib);
7533
This is a string which can have a collection of different values.
7534
Each string value is separated with a ','.
7535
For example "One,two,five"
7536
If one uses this string in a number context one gets the bits as a longlong
7541
int Field_set::store(const char *from,uint length,CHARSET_INFO *cs)
7543
ASSERT_COLUMN_MARKED_FOR_WRITE;
7544
bool got_warning= 0;
7548
uint32 not_used_offset;
7549
char buff[STRING_BUFFER_USUAL_SIZE];
7550
String tmpstr(buff,sizeof(buff), &my_charset_bin);
7552
/* Convert character set if necessary */
7553
if (String::needs_conversion(length, cs, field_charset, ¬_used_offset))
7556
tmpstr.copy(from, length, cs, field_charset, &dummy_errors);
7558
length= tmpstr.length();
7560
uint64_t tmp= find_set(typelib, from, length, field_charset,
7561
¬_used, ¬_used2, &got_warning);
7562
if (!tmp && length && length < 22)
7564
/* This is for reading numbers with LOAD DATA INFILE */
7566
tmp=my_strntoull(cs,from,length,10,&end,&err);
7567
if (err || end != from+length ||
7568
tmp > (uint64_t) (((longlong) 1 << typelib->count) - (longlong) 1))
7571
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
7574
else if (got_warning)
7575
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
7581
int Field_set::store(longlong nr, bool unsigned_val)
7583
ASSERT_COLUMN_MARKED_FOR_WRITE;
7585
uint64_t max_nr= set_bits(uint64_t, typelib->count);
7586
if ((uint64_t) nr > max_nr)
7589
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
7592
store_type((uint64_t) nr);
7597
String *Field_set::val_str(String *val_buffer,
7598
String *val_ptr __attribute__((unused)))
7600
uint64_t tmp=(uint64_t) Field_enum::val_int();
7603
val_buffer->length(0);
7604
val_buffer->set_charset(field_charset);
7605
while (tmp && bitnr < (uint) typelib->count)
7609
if (val_buffer->length())
7610
val_buffer->append(&field_separator, 1, &my_charset_latin1);
7611
String str(typelib->type_names[bitnr],
7612
typelib->type_lengths[bitnr],
7614
val_buffer->append(str);
7623
void Field_set::sql_type(String &res) const
7626
String set_item(buffer, sizeof(buffer), res.charset());
7629
res.append(STRING_WITH_LEN("set("));
7632
uint *len= typelib->type_lengths;
7633
for (const char **pos= typelib->type_names; *pos; pos++, len++)
7638
/* convert to res.charset() == utf8, then quote */
7639
set_item.copy(*pos, *len, charset(), res.charset(), &dummy_errors);
7640
append_unescaped(&res, set_item.ptr(), set_item.length());
7648
1 if the fields are equally defined
7650
0 if the fields are unequally defined
861
7653
bool Field::eq_def(Field *field)
875
7671
if (typelib->count < from_lib->count)
877
for (uint32_t i=0 ; i < from_lib->count ; i++)
7673
for (uint i=0 ; i < from_lib->count ; i++)
878
7674
if (my_strnncoll(field_charset,
879
(const unsigned char*)typelib->type_names[i],
7675
(const uchar*)typelib->type_names[i],
880
7676
strlen(typelib->type_names[i]),
881
(const unsigned char*)from_lib->type_names[i],
7677
(const uchar*)from_lib->type_names[i],
882
7678
strlen(from_lib->type_names[i])))
887
uint32_t calc_pack_length(enum_field_types type,uint32_t length)
890
case DRIZZLE_TYPE_VARCHAR: return (length + (length < 256 ? 1: 2));
891
case DRIZZLE_TYPE_DATE:
892
case DRIZZLE_TYPE_ENUM:
893
case DRIZZLE_TYPE_LONG: return 4;
894
case DRIZZLE_TYPE_DOUBLE: return sizeof(double);
895
case DRIZZLE_TYPE_DATETIME:
896
case DRIZZLE_TYPE_TIMESTAMP:
897
case DRIZZLE_TYPE_LONGLONG: return 8; /* Don't crash if no int64_t */
898
case DRIZZLE_TYPE_NULL: return 0;
899
case DRIZZLE_TYPE_BLOB: return 4 + portable_sizeof_char_ptr;
900
case DRIZZLE_TYPE_DECIMAL:
907
uint32_t pack_length_to_packflag(uint32_t type)
910
case 1: return 1 << FIELDFLAG_PACK_SHIFT;
913
case 4: return f_settype((uint32_t) DRIZZLE_TYPE_LONG);
914
case 8: return f_settype((uint32_t) DRIZZLE_TYPE_LONGLONG);
7685
returns 1 if the fields are equally defined
7687
bool Field_num::eq_def(Field *field)
7689
if (!Field::eq_def(field))
7691
Field_num *from_num= (Field_num*) field;
7693
if (unsigned_flag != from_num->unsigned_flag ||
7694
(zerofill && !from_num->zerofill && !zero_pack()) ||
7695
dec != from_num->dec)
7701
uint Field_num::is_equal(Create_field *new_field)
7703
return ((new_field->sql_type == real_type()) &&
7704
((new_field->flags & UNSIGNED_FLAG) == (uint) (flags &
7706
((new_field->flags & AUTO_INCREMENT_FLAG) ==
7707
(uint) (flags & AUTO_INCREMENT_FLAG)) &&
7708
(new_field->length <= max_display_length()));
7712
/*****************************************************************************
7713
Handling of field and Create_field
7714
*****************************************************************************/
7717
Convert create_field::length from number of characters to number of bytes.
7720
void Create_field::create_length_to_internal_length(void)
7723
case MYSQL_TYPE_TINY_BLOB:
7724
case MYSQL_TYPE_MEDIUM_BLOB:
7725
case MYSQL_TYPE_LONG_BLOB:
7726
case MYSQL_TYPE_BLOB:
7727
case MYSQL_TYPE_VAR_STRING:
7728
case MYSQL_TYPE_STRING:
7729
case MYSQL_TYPE_VARCHAR:
7730
length*= charset->mbmaxlen;
7732
pack_length= calc_pack_length(sql_type, length);
7734
case MYSQL_TYPE_ENUM:
7735
case MYSQL_TYPE_SET:
7736
/* Pack_length already calculated in sql_parse.cc */
7737
length*= charset->mbmaxlen;
7738
key_length= pack_length;
7740
case MYSQL_TYPE_NEWDECIMAL:
7741
key_length= pack_length=
7742
my_decimal_get_binary_size(my_decimal_length_to_precision(length,
7749
key_length= pack_length= calc_pack_length(sql_type, length);
7756
Init for a tmp table field. To be extended if need be.
7758
void Create_field::init_for_tmp_table(enum_field_types sql_type_arg,
7759
uint32 length_arg, uint32 decimals_arg,
7760
bool maybe_null, bool is_unsigned)
7763
sql_type= sql_type_arg;
7764
char_length= length= length_arg;;
7765
unireg_check= Field::NONE;
7767
charset= &my_charset_bin;
7768
pack_flag= (FIELDFLAG_NUMBER |
7769
((decimals_arg & FIELDFLAG_MAX_DEC) << FIELDFLAG_DEC_SHIFT) |
7770
(maybe_null ? FIELDFLAG_MAYBE_NULL : 0) |
7771
(is_unsigned ? 0 : FIELDFLAG_DECIMAL));
7776
Initialize field definition for create.
7778
@param thd Thread handle
7779
@param fld_name Field name
7780
@param fld_type Field type
7781
@param fld_length Field length
7782
@param fld_decimals Decimal (if any)
7783
@param fld_type_modifier Additional type information
7784
@param fld_default_value Field default value (if any)
7785
@param fld_on_update_value The value of ON UPDATE clause
7786
@param fld_comment Field comment
7787
@param fld_change Field change
7788
@param fld_interval_list Interval list (if any)
7789
@param fld_charset Field charset
7797
bool Create_field::init(THD *thd, char *fld_name, enum_field_types fld_type,
7798
char *fld_length, char *fld_decimals,
7799
uint fld_type_modifier, Item *fld_default_value,
7800
Item *fld_on_update_value, LEX_STRING *fld_comment,
7801
char *fld_change, List<String> *fld_interval_list,
7802
CHARSET_INFO *fld_charset, uint fld_geom_type,
7803
enum ha_storage_media storage_type,
7804
enum column_format_type column_format)
7806
uint sign_len, allowed_type_modifier= 0;
7807
ulong max_field_charlength= MAX_FIELD_CHARLENGTH;
7809
DBUG_ENTER("Create_field::init()");
7812
field_name= fld_name;
7813
def= fld_default_value;
7814
flags= fld_type_modifier;
7815
flags|= (((uint)storage_type & STORAGE_TYPE_MASK) << FIELD_STORAGE_FLAGS);
7816
flags|= (((uint)column_format & COLUMN_FORMAT_MASK) << COLUMN_FORMAT_FLAGS);
7817
unireg_check= (fld_type_modifier & AUTO_INCREMENT_FLAG ?
7818
Field::NEXT_NUMBER : Field::NONE);
7819
decimals= fld_decimals ? (uint)atoi(fld_decimals) : 0;
7820
if (decimals >= NOT_FIXED_DEC)
7822
my_error(ER_TOO_BIG_SCALE, MYF(0), decimals, fld_name,
7831
pack_length= key_length= 0;
7832
charset= fld_charset;
7833
interval_list.empty();
7835
comment= *fld_comment;
7837
Set NO_DEFAULT_VALUE_FLAG if this field doesn't have a default value and
7838
it is NOT NULL, not an AUTO_INCREMENT field and not a TIMESTAMP.
7840
if (!fld_default_value && !(fld_type_modifier & AUTO_INCREMENT_FLAG) &&
7841
(fld_type_modifier & NOT_NULL_FLAG) && fld_type != MYSQL_TYPE_TIMESTAMP)
7842
flags|= NO_DEFAULT_VALUE_FLAG;
7844
if (fld_length && !(length= (uint) atoi(fld_length)))
7845
fld_length= 0; /* purecov: inspected */
7846
sign_len= fld_type_modifier & UNSIGNED_FLAG ? 0 : 1;
7849
case MYSQL_TYPE_TINY:
7851
length= MAX_TINYINT_WIDTH+sign_len;
7852
allowed_type_modifier= AUTO_INCREMENT_FLAG;
7854
case MYSQL_TYPE_SHORT:
7856
length= MAX_SMALLINT_WIDTH+sign_len;
7857
allowed_type_modifier= AUTO_INCREMENT_FLAG;
7859
case MYSQL_TYPE_INT24:
7861
length= MAX_MEDIUMINT_WIDTH+sign_len;
7862
allowed_type_modifier= AUTO_INCREMENT_FLAG;
7864
case MYSQL_TYPE_LONG:
7866
length= MAX_INT_WIDTH+sign_len;
7867
allowed_type_modifier= AUTO_INCREMENT_FLAG;
7869
case MYSQL_TYPE_LONGLONG:
7871
length= MAX_BIGINT_WIDTH;
7872
allowed_type_modifier= AUTO_INCREMENT_FLAG;
7874
case MYSQL_TYPE_NULL:
7876
case MYSQL_TYPE_NEWDECIMAL:
7877
my_decimal_trim(&length, &decimals);
7878
if (length > DECIMAL_MAX_PRECISION)
7880
my_error(ER_TOO_BIG_PRECISION, MYF(0), length, fld_name,
7881
DECIMAL_MAX_PRECISION);
7884
if (length < decimals)
7886
my_error(ER_M_BIGGER_THAN_D, MYF(0), fld_name);
7890
my_decimal_precision_to_length(length, decimals,
7891
fld_type_modifier & UNSIGNED_FLAG);
7893
my_decimal_get_binary_size(length, decimals);
7895
case MYSQL_TYPE_VARCHAR:
7897
Long VARCHAR's are automaticly converted to blobs in mysql_prepare_table
7898
if they don't have a default value
7900
max_field_charlength= MAX_FIELD_VARCHARLENGTH;
7902
case MYSQL_TYPE_STRING:
7904
case MYSQL_TYPE_BLOB:
7905
case MYSQL_TYPE_TINY_BLOB:
7906
case MYSQL_TYPE_LONG_BLOB:
7907
case MYSQL_TYPE_MEDIUM_BLOB:
7908
if (fld_default_value)
7910
/* Allow empty as default value. */
7912
res= fld_default_value->val_str(&str);
7914
A default other than '' is always an error, and any non-NULL
7915
specified default is an error in strict mode.
7917
if (res->length() || (thd->variables.sql_mode &
7918
(MODE_STRICT_TRANS_TABLES |
7919
MODE_STRICT_ALL_TABLES)))
7921
my_error(ER_BLOB_CANT_HAVE_DEFAULT, MYF(0),
7922
fld_name); /* purecov: inspected */
7928
Otherwise a default of '' is just a warning.
7930
push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
7931
ER_BLOB_CANT_HAVE_DEFAULT,
7932
ER(ER_BLOB_CANT_HAVE_DEFAULT),
7939
case MYSQL_TYPE_YEAR:
7940
if (!fld_length || length != 2)
7941
length= 4; /* Default length */
7942
flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
7944
case MYSQL_TYPE_FLOAT:
7945
/* change FLOAT(precision) to FLOAT or DOUBLE */
7946
allowed_type_modifier= AUTO_INCREMENT_FLAG;
7947
if (fld_length && !fld_decimals)
7949
uint tmp_length= length;
7950
if (tmp_length > PRECISION_FOR_DOUBLE)
7952
my_error(ER_WRONG_FIELD_SPEC, MYF(0), fld_name);
7955
else if (tmp_length > PRECISION_FOR_FLOAT)
7957
sql_type= MYSQL_TYPE_DOUBLE;
7958
length= DBL_DIG+7; /* -[digits].E+### */
7961
length= FLT_DIG+6; /* -[digits].E+## */
7962
decimals= NOT_FIXED_DEC;
7965
if (!fld_length && !fld_decimals)
7968
decimals= NOT_FIXED_DEC;
7970
if (length < decimals &&
7971
decimals != NOT_FIXED_DEC)
7973
my_error(ER_M_BIGGER_THAN_D, MYF(0), fld_name);
7977
case MYSQL_TYPE_DOUBLE:
7978
allowed_type_modifier= AUTO_INCREMENT_FLAG;
7979
if (!fld_length && !fld_decimals)
7982
decimals= NOT_FIXED_DEC;
7984
if (length < decimals &&
7985
decimals != NOT_FIXED_DEC)
7987
my_error(ER_M_BIGGER_THAN_D, MYF(0), fld_name);
7991
case MYSQL_TYPE_TIMESTAMP:
7994
/* Compressed date YYYYMMDDHHMMSS */
7995
length= MAX_DATETIME_COMPRESSED_WIDTH;
7997
else if (length != MAX_DATETIME_WIDTH)
8000
We support only even TIMESTAMP lengths less or equal than 14
8001
and 19 as length of 4.1 compatible representation.
8003
length= ((length+1)/2)*2; /* purecov: inspected */
8004
length= min(length, MAX_DATETIME_COMPRESSED_WIDTH); /* purecov: inspected */
8006
flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
8007
if (fld_default_value)
8009
/* Grammar allows only NOW() value for ON UPDATE clause */
8010
if (fld_default_value->type() == Item::FUNC_ITEM &&
8011
((Item_func*)fld_default_value)->functype() == Item_func::NOW_FUNC)
8013
unireg_check= (fld_on_update_value ? Field::TIMESTAMP_DNUN_FIELD:
8014
Field::TIMESTAMP_DN_FIELD);
8016
We don't need default value any longer moreover it is dangerous.
8017
Everything handled by unireg_check further.
8022
unireg_check= (fld_on_update_value ? Field::TIMESTAMP_UN_FIELD:
8028
If we have default TIMESTAMP NOT NULL column without explicit DEFAULT
8029
or ON UPDATE values then for the sake of compatiblity we should treat
8030
this column as having DEFAULT NOW() ON UPDATE NOW() (when we don't
8031
have another TIMESTAMP column with auto-set option before this one)
8032
or DEFAULT 0 (in other cases).
8033
So here we are setting TIMESTAMP_OLD_FIELD only temporary, and will
8034
replace this value by TIMESTAMP_DNUN_FIELD or NONE later when
8035
information about all TIMESTAMP fields in table will be availiable.
8037
If we have TIMESTAMP NULL column without explicit DEFAULT value
8038
we treat it as having DEFAULT NULL attribute.
8040
unireg_check= (fld_on_update_value ? Field::TIMESTAMP_UN_FIELD :
8041
(flags & NOT_NULL_FLAG ? Field::TIMESTAMP_OLD_FIELD :
8045
case MYSQL_TYPE_DATE:
8046
/* Old date type. */
8047
sql_type= MYSQL_TYPE_NEWDATE;
8049
case MYSQL_TYPE_NEWDATE:
8052
case MYSQL_TYPE_TIME:
8055
case MYSQL_TYPE_DATETIME:
8056
length= MAX_DATETIME_WIDTH;
8058
case MYSQL_TYPE_SET:
8060
pack_length= get_set_pack_length(fld_interval_list->elements);
8062
List_iterator<String> it(*fld_interval_list);
8065
interval_list.push_back(tmp);
8067
Set fake length to 1 to pass the below conditions.
8068
Real length will be set in mysql_prepare_table()
8069
when we know the character set of the column
8074
case MYSQL_TYPE_ENUM:
8076
/* Should be safe. */
8077
pack_length= get_enum_pack_length(fld_interval_list->elements);
8079
List_iterator<String> it(*fld_interval_list);
8082
interval_list.push_back(tmp);
8083
length= 1; /* See comment for MYSQL_TYPE_SET above. */
8086
case MYSQL_TYPE_VAR_STRING:
8087
DBUG_ASSERT(0); /* Impossible. */
8090
/* Remember the value of length */
8091
char_length= length;
8093
if (!(flags & BLOB_FLAG) &&
8094
((length > max_field_charlength && fld_type != MYSQL_TYPE_SET &&
8095
fld_type != MYSQL_TYPE_ENUM &&
8096
(fld_type != MYSQL_TYPE_VARCHAR || fld_default_value)) ||
8098
fld_type != MYSQL_TYPE_STRING &&
8099
fld_type != MYSQL_TYPE_VARCHAR)))
8101
my_error((fld_type == MYSQL_TYPE_VAR_STRING ||
8102
fld_type == MYSQL_TYPE_VARCHAR ||
8103
fld_type == MYSQL_TYPE_STRING) ? ER_TOO_BIG_FIELDLENGTH :
8104
ER_TOO_BIG_DISPLAYWIDTH,
8106
fld_name, max_field_charlength); /* purecov: inspected */
8109
fld_type_modifier&= AUTO_INCREMENT_FLAG;
8110
if ((~allowed_type_modifier) & fld_type_modifier)
8112
my_error(ER_WRONG_FIELD_SPEC, MYF(0), fld_name);
8116
DBUG_RETURN(FALSE); /* success */
8120
enum_field_types get_blob_type_from_length(ulong length)
8122
enum_field_types type;
8124
type= MYSQL_TYPE_TINY_BLOB;
8125
else if (length < 65536)
8126
type= MYSQL_TYPE_BLOB;
8127
else if (length < 256L*256L*256L)
8128
type= MYSQL_TYPE_MEDIUM_BLOB;
8130
type= MYSQL_TYPE_LONG_BLOB;
8136
Make a field from the .frm file info
8139
uint32 calc_pack_length(enum_field_types type,uint32 length)
8142
case MYSQL_TYPE_VAR_STRING:
8143
case MYSQL_TYPE_STRING:
8144
case MYSQL_TYPE_VARCHAR: return (length + (length < 256 ? 1: 2));
8145
case MYSQL_TYPE_YEAR:
8146
case MYSQL_TYPE_TINY : return 1;
8147
case MYSQL_TYPE_SHORT : return 2;
8148
case MYSQL_TYPE_INT24:
8149
case MYSQL_TYPE_NEWDATE:
8150
case MYSQL_TYPE_TIME: return 3;
8151
case MYSQL_TYPE_TIMESTAMP:
8152
case MYSQL_TYPE_DATE:
8153
case MYSQL_TYPE_LONG : return 4;
8154
case MYSQL_TYPE_FLOAT : return sizeof(float);
8155
case MYSQL_TYPE_DOUBLE: return sizeof(double);
8156
case MYSQL_TYPE_DATETIME:
8157
case MYSQL_TYPE_LONGLONG: return 8; /* Don't crash if no longlong */
8158
case MYSQL_TYPE_NULL : return 0;
8159
case MYSQL_TYPE_TINY_BLOB: return 1+portable_sizeof_char_ptr;
8160
case MYSQL_TYPE_BLOB: return 2+portable_sizeof_char_ptr;
8161
case MYSQL_TYPE_MEDIUM_BLOB: return 3+portable_sizeof_char_ptr;
8162
case MYSQL_TYPE_LONG_BLOB: return 4+portable_sizeof_char_ptr;
8163
case MYSQL_TYPE_SET:
8164
case MYSQL_TYPE_ENUM:
8165
case MYSQL_TYPE_NEWDECIMAL:
8166
abort(); return 0; // This shouldn't happen
8173
uint pack_length_to_packflag(uint type)
8176
case 1: return f_settype((uint) MYSQL_TYPE_TINY);
8177
case 2: return f_settype((uint) MYSQL_TYPE_SHORT);
8178
case 3: return f_settype((uint) MYSQL_TYPE_INT24);
8179
case 4: return f_settype((uint) MYSQL_TYPE_LONG);
8180
case 8: return f_settype((uint) MYSQL_TYPE_LONGLONG);
916
8182
return 0; // This shouldn't happen
8186
Field *make_field(TABLE_SHARE *share, uchar *ptr, uint32 field_length,
8187
uchar *null_pos, uchar null_bit,
8189
enum_field_types field_type,
8190
CHARSET_INFO *field_charset,
8191
Field::utype unireg_check,
8193
const char *field_name)
8195
if (!f_maybe_null(pack_flag))
8202
null_bit= ((uchar) 1) << null_bit;
8205
switch (field_type) {
8206
case MYSQL_TYPE_DATE:
8207
case MYSQL_TYPE_NEWDATE:
8208
case MYSQL_TYPE_TIME:
8209
case MYSQL_TYPE_DATETIME:
8210
case MYSQL_TYPE_TIMESTAMP:
8211
field_charset= &my_charset_bin;
8215
if (f_is_alpha(pack_flag))
8217
if (!f_is_packed(pack_flag))
8219
if (field_type == MYSQL_TYPE_STRING ||
8220
field_type == MYSQL_TYPE_VAR_STRING)
8221
return new Field_string(ptr,field_length,null_pos,null_bit,
8222
unireg_check, field_name,
8224
if (field_type == MYSQL_TYPE_VARCHAR)
8225
return new Field_varstring(ptr,field_length,
8226
HA_VARCHAR_PACKLENGTH(field_length),
8228
unireg_check, field_name,
8234
uint pack_length=calc_pack_length((enum_field_types)
8235
f_packtype(pack_flag),
8238
if (f_is_blob(pack_flag))
8239
return new Field_blob(ptr,null_pos,null_bit,
8240
unireg_check, field_name, share,
8241
pack_length, field_charset);
8244
if (f_is_enum(pack_flag))
8245
return new Field_enum(ptr,field_length,null_pos,null_bit,
8246
unireg_check, field_name,
8247
pack_length, interval, field_charset);
8249
return new Field_set(ptr,field_length,null_pos,null_bit,
8250
unireg_check, field_name,
8251
pack_length, interval, field_charset);
8255
switch (field_type) {
8256
case MYSQL_TYPE_NEWDECIMAL:
8257
return new Field_new_decimal(ptr,field_length,null_pos,null_bit,
8258
unireg_check, field_name,
8259
f_decimals(pack_flag),
8260
f_is_zerofill(pack_flag) != 0,
8261
f_is_dec(pack_flag) == 0);
8262
case MYSQL_TYPE_FLOAT:
8263
return new Field_float(ptr,field_length,null_pos,null_bit,
8264
unireg_check, field_name,
8265
f_decimals(pack_flag),
8266
f_is_zerofill(pack_flag) != 0,
8267
f_is_dec(pack_flag)== 0);
8268
case MYSQL_TYPE_DOUBLE:
8269
return new Field_double(ptr,field_length,null_pos,null_bit,
8270
unireg_check, field_name,
8271
f_decimals(pack_flag),
8272
f_is_zerofill(pack_flag) != 0,
8273
f_is_dec(pack_flag)== 0);
8274
case MYSQL_TYPE_TINY:
8275
return new Field_tiny(ptr,field_length,null_pos,null_bit,
8276
unireg_check, field_name,
8277
f_is_zerofill(pack_flag) != 0,
8278
f_is_dec(pack_flag) == 0);
8279
case MYSQL_TYPE_SHORT:
8280
return new Field_short(ptr,field_length,null_pos,null_bit,
8281
unireg_check, field_name,
8282
f_is_zerofill(pack_flag) != 0,
8283
f_is_dec(pack_flag) == 0);
8284
case MYSQL_TYPE_INT24:
8285
return new Field_medium(ptr,field_length,null_pos,null_bit,
8286
unireg_check, field_name,
8287
f_is_zerofill(pack_flag) != 0,
8288
f_is_dec(pack_flag) == 0);
8289
case MYSQL_TYPE_LONG:
8290
return new Field_long(ptr,field_length,null_pos,null_bit,
8291
unireg_check, field_name,
8292
f_is_zerofill(pack_flag) != 0,
8293
f_is_dec(pack_flag) == 0);
8294
case MYSQL_TYPE_LONGLONG:
8295
return new Field_longlong(ptr,field_length,null_pos,null_bit,
8296
unireg_check, field_name,
8297
f_is_zerofill(pack_flag) != 0,
8298
f_is_dec(pack_flag) == 0);
8299
case MYSQL_TYPE_TIMESTAMP:
8300
return new Field_timestamp(ptr,field_length, null_pos, null_bit,
8301
unireg_check, field_name, share,
8303
case MYSQL_TYPE_YEAR:
8304
return new Field_year(ptr,field_length,null_pos,null_bit,
8305
unireg_check, field_name);
8306
case MYSQL_TYPE_DATE:
8307
return new Field_date(ptr,null_pos,null_bit,
8308
unireg_check, field_name, field_charset);
8309
case MYSQL_TYPE_NEWDATE:
8310
return new Field_newdate(ptr,null_pos,null_bit,
8311
unireg_check, field_name, field_charset);
8312
case MYSQL_TYPE_TIME:
8313
return new Field_time(ptr,null_pos,null_bit,
8314
unireg_check, field_name, field_charset);
8315
case MYSQL_TYPE_DATETIME:
8316
return new Field_datetime(ptr,null_pos,null_bit,
8317
unireg_check, field_name, field_charset);
8318
case MYSQL_TYPE_NULL:
8319
return new Field_null(ptr, field_length, unireg_check, field_name,
8321
default: // Impossible (Wrong version)
8328
/** Create a field suitable for create of table. */
8330
Create_field::Create_field(Field *old_field,Field *orig_field)
8333
field_name=change=old_field->field_name;
8334
length= old_field->field_length;
8335
flags= old_field->flags;
8336
unireg_check=old_field->unireg_check;
8337
pack_length=old_field->pack_length();
8338
key_length= old_field->key_length();
8339
sql_type= old_field->real_type();
8340
charset= old_field->charset(); // May be NULL ptr
8341
comment= old_field->comment;
8342
decimals= old_field->decimals();
8344
/* Fix if the original table had 4 byte pointer blobs */
8345
if (flags & BLOB_FLAG)
8346
pack_length= (pack_length- old_field->table->s->blob_ptr_size +
8347
portable_sizeof_char_ptr);
8350
case MYSQL_TYPE_BLOB:
8351
switch (pack_length - portable_sizeof_char_ptr) {
8352
case 1: sql_type= MYSQL_TYPE_TINY_BLOB; break;
8353
case 2: sql_type= MYSQL_TYPE_BLOB; break;
8354
case 3: sql_type= MYSQL_TYPE_MEDIUM_BLOB; break;
8355
default: sql_type= MYSQL_TYPE_LONG_BLOB; break;
8357
length/= charset->mbmaxlen;
8358
key_length/= charset->mbmaxlen;
8360
case MYSQL_TYPE_STRING:
8361
/* Change CHAR -> VARCHAR if dynamic record length */
8362
if (old_field->type() == MYSQL_TYPE_VAR_STRING)
8363
sql_type= MYSQL_TYPE_VARCHAR;
8366
case MYSQL_TYPE_ENUM:
8367
case MYSQL_TYPE_SET:
8368
case MYSQL_TYPE_VARCHAR:
8369
case MYSQL_TYPE_VAR_STRING:
8370
/* This is corrected in create_length_to_internal_length */
8371
length= (length+charset->mbmaxlen-1) / charset->mbmaxlen;
8377
if (flags & (ENUM_FLAG | SET_FLAG))
8378
interval= ((Field_enum*) old_field)->typelib;
8382
char_length= length;
8384
if (!(flags & (NO_DEFAULT_VALUE_FLAG | BLOB_FLAG)) &&
8385
old_field->ptr && orig_field &&
8386
(sql_type != MYSQL_TYPE_TIMESTAMP || /* set def only if */
8387
old_field->table->timestamp_field != old_field || /* timestamp field */
8388
unireg_check == Field::TIMESTAMP_UN_FIELD)) /* has default val */
8390
char buff[MAX_FIELD_WIDTH];
8391
String tmp(buff,sizeof(buff), charset);
8394
/* Get the value from default_values */
8395
diff= (my_ptrdiff_t) (orig_field->table->s->default_values-
8396
orig_field->table->record[0]);
8397
orig_field->move_field_offset(diff); // Points now at default_values
8398
if (!orig_field->is_real_null())
8400
char buff[MAX_FIELD_WIDTH], *pos;
8401
String tmp(buff, sizeof(buff), charset), *res;
8402
res= orig_field->val_str(&tmp);
8403
pos= (char*) sql_strmake(res->ptr(), res->length());
8404
def= new Item_string(pos, res->length(), charset);
8406
orig_field->move_field_offset(-diff); // Back to record[0]
8412
maximum possible display length for blob.
8418
uint32 Field_blob::max_display_length()
8423
return 255 * field_charset->mbmaxlen;
8425
return 65535 * field_charset->mbmaxlen;
8427
return 16777215 * field_charset->mbmaxlen;
8429
return (uint32) 4294967295U;
8431
DBUG_ASSERT(0); // we should never go here
919
8437
/*****************************************************************************
920
8438
Warning handling
921
8439
*****************************************************************************/
923
bool Field::set_warning(DRIZZLE_ERROR::enum_warning_level level,
8442
Produce warning or note about data saved into field.
8444
@param level - level of message (Note/Warning/Error)
8445
@param code - error code of message to be produced
8446
@param cuted_increment - whenever we should increase cut fields count or not
8449
This function won't produce warning and increase cut fields counter
8450
if count_cuted_fields == CHECK_FIELD_IGNORE for current thread.
8452
if count_cuted_fields == CHECK_FIELD_IGNORE then we ignore notes.
8453
This allows us to avoid notes in optimisation, like convert_constant_item().
8456
1 if count_cuted_fields == CHECK_FIELD_IGNORE and error level is not NOTE
8462
Field::set_warning(MYSQL_ERROR::enum_warning_level level, uint code,
8463
int cuted_increment)
928
8466
If this field was created only for type conversion purposes it
929
8467
will have table == NULL.
931
Session *session= table ? table->in_use : current_session;
932
if (session->count_cuted_fields)
8469
THD *thd= table ? table->in_use : current_thd;
8470
if (thd->count_cuted_fields)
934
session->cuted_fields+= cuted_increment;
935
push_warning_printf(session, level, code, ER(code), field_name,
8472
thd->cuted_fields+= cuted_increment;
8473
push_warning_printf(thd, level, code, ER(code), field_name,
939
return level >= DRIZZLE_ERROR::WARN_LEVEL_WARN;
8477
return level >= MYSQL_ERROR::WARN_LEVEL_WARN;
943
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
947
enum enum_drizzle_timestamp_type ts_type,
8482
Produce warning or note about datetime string data saved into field.
8484
@param level level of message (Note/Warning/Error)
8485
@param code error code of message to be produced
8486
@param str string value which we tried to save
8487
@param str_length length of string which we tried to save
8488
@param ts_type type of datetime value (datetime/date/time)
8489
@param cuted_increment whenever we should increase cut fields count or not
8492
This function will always produce some warning but won't increase cut
8493
fields counter if count_cuted_fields ==FIELD_CHECK_IGNORE for current
8498
Field::set_datetime_warning(MYSQL_ERROR::enum_warning_level level, uint code,
8499
const char *str, uint str_length,
8500
timestamp_type ts_type, int cuted_increment)
950
Session *session= table ? table->in_use : current_session;
951
if ((session->really_abort_on_warning() &&
952
level >= DRIZZLE_ERROR::WARN_LEVEL_WARN) ||
8502
THD *thd= table ? table->in_use : current_thd;
8503
if ((thd->really_abort_on_warning() &&
8504
level >= MYSQL_ERROR::WARN_LEVEL_WARN) ||
953
8505
set_warning(level, code, cuted_increment))
954
make_truncated_value_warning(session, level, str, str_length, ts_type,
8506
make_truncated_value_warning(thd, level, str, str_length, ts_type,
958
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
961
enum enum_drizzle_timestamp_type ts_type,
8512
Produce warning or note about integer datetime value saved into field.
8514
@param level level of message (Note/Warning/Error)
8515
@param code error code of message to be produced
8516
@param nr numeric value which we tried to save
8517
@param ts_type type of datetime value (datetime/date/time)
8518
@param cuted_increment whenever we should increase cut fields count or not
8521
This function will always produce some warning but won't increase cut
8522
fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current
8527
Field::set_datetime_warning(MYSQL_ERROR::enum_warning_level level, uint code,
8528
longlong nr, timestamp_type ts_type,
8529
int cuted_increment)
964
Session *session= table ? table->in_use : current_session;
965
if (session->really_abort_on_warning() ||
8531
THD *thd= table ? table->in_use : current_thd;
8532
if (thd->really_abort_on_warning() ||
966
8533
set_warning(level, code, cuted_increment))
968
8535
char str_nr[22];
969
char *str_end= internal::int64_t10_to_str(nr, str_nr, -10);
970
make_truncated_value_warning(session, level, str_nr, (uint32_t) (str_end - str_nr),
8536
char *str_end= longlong10_to_str(nr, str_nr, -10);
8537
make_truncated_value_warning(thd, level, str_nr, (uint) (str_end - str_nr),
971
8538
ts_type, field_name);
975
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
978
enum enum_drizzle_timestamp_type ts_type)
8544
Produce warning or note about double datetime data saved into field.
8546
@param level level of message (Note/Warning/Error)
8547
@param code error code of message to be produced
8548
@param nr double value which we tried to save
8549
@param ts_type type of datetime value (datetime/date/time)
8552
This function will always produce some warning but won't increase cut
8553
fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current
8558
Field::set_datetime_warning(MYSQL_ERROR::enum_warning_level level, uint code,
8559
double nr, timestamp_type ts_type)
980
Session *session= table ? table->in_use : current_session;
981
if (session->really_abort_on_warning() ||
8561
THD *thd= table ? table->in_use : current_thd;
8562
if (thd->really_abort_on_warning() ||
982
8563
set_warning(level, code, 1))
984
8565
/* DBL_DIG is enough to print '-[digits].E+###' */
985
8566
char str_nr[DBL_DIG + 8];
986
uint32_t str_len= snprintf(str_nr, sizeof(str_nr), "%g", nr);
987
make_truncated_value_warning(session, level, str_nr, str_len, ts_type,
8567
uint str_len= my_sprintf(str_nr, (str_nr, "%g", nr));
8568
make_truncated_value_warning(thd, level, str_nr, str_len, ts_type,
992
bool Field::isReadSet()
994
return table->isReadSet(field_index);
997
bool Field::isWriteSet()
999
return table->isWriteSet(field_index);
1002
void Field::setReadSet(bool arg)
1005
table->setReadSet(field_index);
1007
table->clearReadSet(field_index);
1010
void Field::setWriteSet(bool arg)
1013
table->setWriteSet(field_index);
1015
table->clearWriteSet(field_index);
1018
} /* namespace drizzled */
added
removed
sql/field.cc
