59
72
static enum_field_types field_types_merge_rules [FIELDTYPE_NUM][FIELDTYPE_NUM]=
61
/* DRIZZLE_TYPE_DECIMAL -> */
63
//DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_TINY
64
DRIZZLE_TYPE_NEWDECIMAL, DRIZZLE_TYPE_NEWDECIMAL,
66
DRIZZLE_TYPE_NEWDECIMAL,
69
//DRIZZLE_TYPE_NULL DRIZZLE_TYPE_TIMESTAMP
70
DRIZZLE_TYPE_NEWDECIMAL, DRIZZLE_TYPE_VARCHAR,
71
//DRIZZLE_TYPE_LONGLONG
72
DRIZZLE_TYPE_NEWDECIMAL,
75
//DRIZZLE_TYPE_DATETIME
77
//DRIZZLE_TYPE_NEWDATE DRIZZLE_TYPE_VARCHAR
78
DRIZZLE_TYPE_VARCHAR, DRIZZLE_TYPE_VARCHAR,
79
// DRIZZLE_TYPE_VIRTUAL
81
//DRIZZLE_TYPE_NEWDECIMAL DRIZZLE_TYPE_ENUM
82
DRIZZLE_TYPE_NEWDECIMAL, DRIZZLE_TYPE_VARCHAR,
86
/* DRIZZLE_TYPE_TINY -> */
88
//DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_TINY
89
DRIZZLE_TYPE_NEWDECIMAL, DRIZZLE_TYPE_TINY,
94
//DRIZZLE_TYPE_NULL DRIZZLE_TYPE_TIMESTAMP
95
DRIZZLE_TYPE_TINY, DRIZZLE_TYPE_VARCHAR,
96
//DRIZZLE_TYPE_LONGLONG
97
DRIZZLE_TYPE_LONGLONG,
100
//DRIZZLE_TYPE_DATETIME
101
DRIZZLE_TYPE_VARCHAR,
102
//DRIZZLE_TYPE_NEWDATE DRIZZLE_TYPE_VARCHAR
103
DRIZZLE_TYPE_VARCHAR, DRIZZLE_TYPE_VARCHAR,
104
// DRIZZLE_TYPE_VIRTUAL
105
DRIZZLE_TYPE_VIRTUAL,
106
//DRIZZLE_TYPE_NEWDECIMAL DRIZZLE_TYPE_ENUM
107
DRIZZLE_TYPE_NEWDECIMAL, DRIZZLE_TYPE_VARCHAR,
111
/* DRIZZLE_TYPE_LONG -> */
113
//DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_TINY
114
DRIZZLE_TYPE_NEWDECIMAL, DRIZZLE_TYPE_LONG,
117
//DRIZZLE_TYPE_DOUBLE
119
//DRIZZLE_TYPE_NULL DRIZZLE_TYPE_TIMESTAMP
120
DRIZZLE_TYPE_LONG, DRIZZLE_TYPE_VARCHAR,
121
//DRIZZLE_TYPE_LONGLONG
122
DRIZZLE_TYPE_LONGLONG,
124
DRIZZLE_TYPE_VARCHAR,
125
//DRIZZLE_TYPE_DATETIME
126
DRIZZLE_TYPE_VARCHAR,
127
//DRIZZLE_TYPE_NEWDATE DRIZZLE_TYPE_VARCHAR
128
DRIZZLE_TYPE_VARCHAR, DRIZZLE_TYPE_VARCHAR,
129
// DRIZZLE_TYPE_VIRTUAL
130
DRIZZLE_TYPE_VIRTUAL,
131
//DRIZZLE_TYPE_NEWDECIMAL DRIZZLE_TYPE_ENUM
132
DRIZZLE_TYPE_NEWDECIMAL, DRIZZLE_TYPE_VARCHAR,
136
/* DRIZZLE_TYPE_DOUBLE -> */
138
//DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_TINY
139
DRIZZLE_TYPE_DOUBLE, DRIZZLE_TYPE_DOUBLE,
142
//DRIZZLE_TYPE_DOUBLE
144
//DRIZZLE_TYPE_NULL DRIZZLE_TYPE_TIMESTAMP
145
DRIZZLE_TYPE_DOUBLE, DRIZZLE_TYPE_VARCHAR,
146
//DRIZZLE_TYPE_LONGLONG
149
DRIZZLE_TYPE_VARCHAR,
150
//DRIZZLE_TYPE_DATETIME
151
DRIZZLE_TYPE_VARCHAR,
152
//DRIZZLE_TYPE_NEWDATE DRIZZLE_TYPE_VARCHAR
153
DRIZZLE_TYPE_VARCHAR, DRIZZLE_TYPE_VARCHAR,
154
// DRIZZLE_TYPE_VIRTUAL
155
DRIZZLE_TYPE_VIRTUAL,
156
//DRIZZLE_TYPE_NEWDECIMAL DRIZZLE_TYPE_ENUM
157
DRIZZLE_TYPE_DOUBLE, DRIZZLE_TYPE_VARCHAR,
161
/* DRIZZLE_TYPE_NULL -> */
163
//DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_TINY
164
DRIZZLE_TYPE_NEWDECIMAL, DRIZZLE_TYPE_TINY,
167
//DRIZZLE_TYPE_DOUBLE
169
//DRIZZLE_TYPE_NULL DRIZZLE_TYPE_TIMESTAMP
170
DRIZZLE_TYPE_NULL, DRIZZLE_TYPE_TIMESTAMP,
171
//DRIZZLE_TYPE_LONGLONG
172
DRIZZLE_TYPE_LONGLONG,
175
//DRIZZLE_TYPE_DATETIME
176
DRIZZLE_TYPE_DATETIME,
177
//DRIZZLE_TYPE_NEWDATE DRIZZLE_TYPE_VARCHAR
178
DRIZZLE_TYPE_NEWDATE, DRIZZLE_TYPE_VARCHAR,
179
// DRIZZLE_TYPE_VIRTUAL
180
DRIZZLE_TYPE_VIRTUAL,
181
//DRIZZLE_TYPE_NEWDECIMAL DRIZZLE_TYPE_ENUM
182
DRIZZLE_TYPE_NEWDECIMAL, DRIZZLE_TYPE_ENUM,
186
/* DRIZZLE_TYPE_TIMESTAMP -> */
188
//DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_TINY
189
DRIZZLE_TYPE_VARCHAR, DRIZZLE_TYPE_VARCHAR,
191
DRIZZLE_TYPE_VARCHAR,
192
//DRIZZLE_TYPE_DOUBLE
193
DRIZZLE_TYPE_VARCHAR,
194
//DRIZZLE_TYPE_NULL DRIZZLE_TYPE_TIMESTAMP
195
DRIZZLE_TYPE_TIMESTAMP, DRIZZLE_TYPE_TIMESTAMP,
196
//DRIZZLE_TYPE_LONGLONG
197
DRIZZLE_TYPE_VARCHAR,
199
DRIZZLE_TYPE_DATETIME,
200
//DRIZZLE_TYPE_DATETIME
201
DRIZZLE_TYPE_DATETIME,
202
//DRIZZLE_TYPE_NEWDATE DRIZZLE_TYPE_VARCHAR
203
DRIZZLE_TYPE_NEWDATE, DRIZZLE_TYPE_VARCHAR,
204
// DRIZZLE_TYPE_VIRTUAL
205
DRIZZLE_TYPE_VIRTUAL,
206
//DRIZZLE_TYPE_NEWDECIMAL DRIZZLE_TYPE_ENUM
207
DRIZZLE_TYPE_VARCHAR, DRIZZLE_TYPE_VARCHAR,
211
/* DRIZZLE_TYPE_LONGLONG -> */
213
//DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_TINY
214
DRIZZLE_TYPE_NEWDECIMAL, DRIZZLE_TYPE_LONGLONG,
216
DRIZZLE_TYPE_LONGLONG,
217
//DRIZZLE_TYPE_DOUBLE
219
//DRIZZLE_TYPE_NULL DRIZZLE_TYPE_TIMESTAMP
220
DRIZZLE_TYPE_LONGLONG, DRIZZLE_TYPE_VARCHAR,
221
//DRIZZLE_TYPE_LONGLONG
222
DRIZZLE_TYPE_LONGLONG,
224
DRIZZLE_TYPE_VARCHAR,
225
//DRIZZLE_TYPE_DATETIME
226
DRIZZLE_TYPE_VARCHAR,
227
//DRIZZLE_TYPE_NEWDATE DRIZZLE_TYPE_VARCHAR
228
DRIZZLE_TYPE_NEWDATE, DRIZZLE_TYPE_VARCHAR,
229
// DRIZZLE_TYPE_VIRTUAL
230
DRIZZLE_TYPE_VIRTUAL,
231
//DRIZZLE_TYPE_NEWDECIMAL DRIZZLE_TYPE_ENUM
232
DRIZZLE_TYPE_NEWDECIMAL, DRIZZLE_TYPE_VARCHAR,
236
/* DRIZZLE_TYPE_TIME -> */
238
//DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_TINY
239
DRIZZLE_TYPE_VARCHAR, DRIZZLE_TYPE_VARCHAR,
241
DRIZZLE_TYPE_VARCHAR,
242
//DRIZZLE_TYPE_DOUBLE
243
DRIZZLE_TYPE_VARCHAR,
244
//DRIZZLE_TYPE_NULL DRIZZLE_TYPE_TIMESTAMP
245
DRIZZLE_TYPE_TIME, DRIZZLE_TYPE_DATETIME,
246
//DRIZZLE_TYPE_LONGLONG
247
DRIZZLE_TYPE_VARCHAR,
250
//DRIZZLE_TYPE_DATETIME
251
DRIZZLE_TYPE_DATETIME,
252
//DRIZZLE_TYPE_NEWDATE DRIZZLE_TYPE_VARCHAR
253
DRIZZLE_TYPE_NEWDATE, DRIZZLE_TYPE_VARCHAR,
254
// DRIZZLE_TYPE_VIRTUAL
255
DRIZZLE_TYPE_VIRTUAL,
256
//DRIZZLE_TYPE_NEWDECIMAL DRIZZLE_TYPE_ENUM
257
DRIZZLE_TYPE_VARCHAR, DRIZZLE_TYPE_VARCHAR,
261
/* DRIZZLE_TYPE_DATETIME -> */
263
//DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_TINY
264
DRIZZLE_TYPE_VARCHAR, DRIZZLE_TYPE_VARCHAR,
266
DRIZZLE_TYPE_VARCHAR,
267
//DRIZZLE_TYPE_DOUBLE
268
DRIZZLE_TYPE_VARCHAR,
269
//DRIZZLE_TYPE_NULL DRIZZLE_TYPE_TIMESTAMP
270
DRIZZLE_TYPE_DATETIME, DRIZZLE_TYPE_DATETIME,
271
//DRIZZLE_TYPE_LONGLONG
272
DRIZZLE_TYPE_VARCHAR,
274
DRIZZLE_TYPE_DATETIME,
275
//DRIZZLE_TYPE_DATETIME
276
DRIZZLE_TYPE_DATETIME,
277
//DRIZZLE_TYPE_NEWDATE DRIZZLE_TYPE_VARCHAR
278
DRIZZLE_TYPE_NEWDATE, DRIZZLE_TYPE_VARCHAR,
279
// DRIZZLE_TYPE_VIRTUAL
280
DRIZZLE_TYPE_VIRTUAL,
281
//DRIZZLE_TYPE_NEWDECIMAL DRIZZLE_TYPE_ENUM
282
DRIZZLE_TYPE_VARCHAR, DRIZZLE_TYPE_VARCHAR,
286
/* DRIZZLE_TYPE_NEWDATE -> */
288
//DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_TINY
289
DRIZZLE_TYPE_VARCHAR, DRIZZLE_TYPE_VARCHAR,
291
DRIZZLE_TYPE_VARCHAR,
292
//DRIZZLE_TYPE_DOUBLE
293
DRIZZLE_TYPE_VARCHAR,
294
//DRIZZLE_TYPE_NULL DRIZZLE_TYPE_TIMESTAMP
295
DRIZZLE_TYPE_NEWDATE, DRIZZLE_TYPE_DATETIME,
296
//DRIZZLE_TYPE_LONGLONG
297
DRIZZLE_TYPE_VARCHAR,
299
DRIZZLE_TYPE_DATETIME,
300
//DRIZZLE_TYPE_DATETIME
301
DRIZZLE_TYPE_DATETIME,
302
//DRIZZLE_TYPE_NEWDATE DRIZZLE_TYPE_VARCHAR
303
DRIZZLE_TYPE_NEWDATE, DRIZZLE_TYPE_VARCHAR,
304
// DRIZZLE_TYPE_VIRTUAL
305
DRIZZLE_TYPE_VIRTUAL,
306
//DRIZZLE_TYPE_NEWDECIMAL DRIZZLE_TYPE_ENUM
307
DRIZZLE_TYPE_VARCHAR, DRIZZLE_TYPE_VARCHAR,
311
/* DRIZZLE_TYPE_VARCHAR -> */
313
//DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_TINY
314
DRIZZLE_TYPE_VARCHAR, DRIZZLE_TYPE_VARCHAR,
316
DRIZZLE_TYPE_VARCHAR,
317
//DRIZZLE_TYPE_DOUBLE
318
DRIZZLE_TYPE_VARCHAR,
319
//DRIZZLE_TYPE_NULL DRIZZLE_TYPE_TIMESTAMP
320
DRIZZLE_TYPE_VARCHAR, DRIZZLE_TYPE_VARCHAR,
321
//DRIZZLE_TYPE_LONGLONG
322
DRIZZLE_TYPE_VARCHAR,
324
DRIZZLE_TYPE_VARCHAR,
325
//DRIZZLE_TYPE_DATETIME
326
DRIZZLE_TYPE_VARCHAR,
327
//DRIZZLE_TYPE_NEWDATE DRIZZLE_TYPE_VARCHAR
328
DRIZZLE_TYPE_VARCHAR, DRIZZLE_TYPE_VARCHAR,
329
// DRIZZLE_TYPE_VIRTUAL
330
DRIZZLE_TYPE_VIRTUAL,
331
//DRIZZLE_TYPE_NEWDECIMAL DRIZZLE_TYPE_ENUM
332
DRIZZLE_TYPE_VARCHAR, DRIZZLE_TYPE_VARCHAR,
336
/* DRIZZLE_TYPE_VIRTUAL -> */
338
//DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_TINY
339
DRIZZLE_TYPE_VIRTUAL, DRIZZLE_TYPE_VIRTUAL,
341
DRIZZLE_TYPE_VIRTUAL,
342
//DRIZZLE_TYPE_DOUBLE
343
DRIZZLE_TYPE_VIRTUAL,
344
//DRIZZLE_TYPE_NULL DRIZZLE_TYPE_TIMESTAMP
345
DRIZZLE_TYPE_VIRTUAL, DRIZZLE_TYPE_VIRTUAL,
346
//DRIZZLE_TYPE_LONGLONG
347
DRIZZLE_TYPE_VIRTUAL,
349
DRIZZLE_TYPE_VIRTUAL,
350
//DRIZZLE_TYPE_DATETIME
351
DRIZZLE_TYPE_VIRTUAL,
352
//DRIZZLE_TYPE_NEWDATE DRIZZLE_TYPE_VARCHAR
353
DRIZZLE_TYPE_VIRTUAL, DRIZZLE_TYPE_VIRTUAL,
354
// DRIZZLE_TYPE_VIRTUAL
355
DRIZZLE_TYPE_VIRTUAL,
356
//DRIZZLE_TYPE_NEWDECIMAL DRIZZLE_TYPE_ENUM
357
DRIZZLE_TYPE_VIRTUAL, DRIZZLE_TYPE_VIRTUAL,
359
DRIZZLE_TYPE_VIRTUAL,
361
/* DRIZZLE_TYPE_NEWDECIMAL -> */
363
//DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_TINY
364
DRIZZLE_TYPE_NEWDECIMAL, DRIZZLE_TYPE_NEWDECIMAL,
366
DRIZZLE_TYPE_NEWDECIMAL,
367
//DRIZZLE_TYPE_DOUBLE
369
//DRIZZLE_TYPE_NULL DRIZZLE_TYPE_TIMESTAMP
370
DRIZZLE_TYPE_NEWDECIMAL, DRIZZLE_TYPE_VARCHAR,
371
//DRIZZLE_TYPE_LONGLONG
372
DRIZZLE_TYPE_NEWDECIMAL,
374
DRIZZLE_TYPE_VARCHAR,
375
//DRIZZLE_TYPE_DATETIME
376
DRIZZLE_TYPE_VARCHAR,
377
//DRIZZLE_TYPE_NEWDATE DRIZZLE_TYPE_VARCHAR
378
DRIZZLE_TYPE_VARCHAR, DRIZZLE_TYPE_VARCHAR,
379
// DRIZZLE_TYPE_VIRTUAL
380
DRIZZLE_TYPE_VIRTUAL,
381
//DRIZZLE_TYPE_NEWDECIMAL DRIZZLE_TYPE_ENUM
382
DRIZZLE_TYPE_NEWDECIMAL, DRIZZLE_TYPE_VARCHAR,
386
/* DRIZZLE_TYPE_ENUM -> */
388
//DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_TINY
389
DRIZZLE_TYPE_VARCHAR, DRIZZLE_TYPE_VARCHAR,
391
DRIZZLE_TYPE_VARCHAR,
392
//DRIZZLE_TYPE_DOUBLE
393
DRIZZLE_TYPE_VARCHAR,
394
//DRIZZLE_TYPE_NULL DRIZZLE_TYPE_TIMESTAMP
395
DRIZZLE_TYPE_ENUM, DRIZZLE_TYPE_VARCHAR,
396
//DRIZZLE_TYPE_LONGLONG
397
DRIZZLE_TYPE_VARCHAR,
399
DRIZZLE_TYPE_VARCHAR,
400
//DRIZZLE_TYPE_DATETIME
401
DRIZZLE_TYPE_VARCHAR,
402
//DRIZZLE_TYPE_NEWDATE DRIZZLE_TYPE_VARCHAR
403
DRIZZLE_TYPE_VARCHAR, DRIZZLE_TYPE_VARCHAR,
404
// DRIZZLE_TYPE_VIRTUAL
405
DRIZZLE_TYPE_VIRTUAL,
406
//DRIZZLE_TYPE_NEWDECIMAL DRIZZLE_TYPE_ENUM
407
DRIZZLE_TYPE_VARCHAR, DRIZZLE_TYPE_VARCHAR,
411
/* DRIZZLE_TYPE_BLOB -> */
413
//DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_TINY
414
DRIZZLE_TYPE_BLOB, DRIZZLE_TYPE_BLOB,
417
//DRIZZLE_TYPE_DOUBLE
419
//DRIZZLE_TYPE_NULL DRIZZLE_TYPE_TIMESTAMP
420
DRIZZLE_TYPE_BLOB, DRIZZLE_TYPE_BLOB,
421
//DRIZZLE_TYPE_LONGLONG
425
//DRIZZLE_TYPE_DATETIME
427
//DRIZZLE_TYPE_NEWDATE DRIZZLE_TYPE_VARCHAR
428
DRIZZLE_TYPE_BLOB, DRIZZLE_TYPE_BLOB,
429
// DRIZZLE_TYPE_VIRTUAL
430
DRIZZLE_TYPE_VIRTUAL,
431
//DRIZZLE_TYPE_NEWDECIMAL DRIZZLE_TYPE_ENUM
432
DRIZZLE_TYPE_BLOB, DRIZZLE_TYPE_BLOB,
74
/* MYSQL_TYPE_DECIMAL -> */
76
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
77
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_NEWDECIMAL,
78
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
79
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_NEWDECIMAL,
80
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
81
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_DOUBLE,
82
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
83
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
84
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
85
//MYSQL_TYPE_DECIMAL, MYSQL_TYPE_DECIMAL,
86
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
87
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
88
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
89
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
90
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
91
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
92
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
93
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
96
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
97
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
101
/* MYSQL_TYPE_TINY -> */
103
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
104
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_TINY,
105
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
106
MYSQL_TYPE_SHORT, MYSQL_TYPE_LONG,
107
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
108
MYSQL_TYPE_FLOAT, MYSQL_TYPE_DOUBLE,
109
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
110
MYSQL_TYPE_TINY, MYSQL_TYPE_VARCHAR,
111
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
112
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_INT24,
113
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
114
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
115
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
116
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY,
117
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
118
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
119
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
120
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
123
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
124
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
128
/* MYSQL_TYPE_SHORT -> */
130
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
131
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_SHORT,
132
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
133
MYSQL_TYPE_SHORT, MYSQL_TYPE_LONG,
134
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
135
MYSQL_TYPE_FLOAT, MYSQL_TYPE_DOUBLE,
136
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
137
MYSQL_TYPE_SHORT, MYSQL_TYPE_VARCHAR,
138
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
139
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_INT24,
140
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
141
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
142
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
143
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_SHORT,
144
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
145
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
146
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
147
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
150
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
151
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
155
/* MYSQL_TYPE_LONG -> */
157
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
158
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_LONG,
159
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
160
MYSQL_TYPE_LONG, MYSQL_TYPE_LONG,
161
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
162
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_DOUBLE,
163
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
164
MYSQL_TYPE_LONG, MYSQL_TYPE_VARCHAR,
165
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
166
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_INT24,
167
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
168
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
169
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
170
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_LONG,
171
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
172
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
173
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
174
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
177
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
178
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
182
/* MYSQL_TYPE_FLOAT -> */
184
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
185
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_FLOAT,
186
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
187
MYSQL_TYPE_FLOAT, MYSQL_TYPE_DOUBLE,
188
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
189
MYSQL_TYPE_FLOAT, MYSQL_TYPE_DOUBLE,
190
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
191
MYSQL_TYPE_FLOAT, MYSQL_TYPE_VARCHAR,
192
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
193
MYSQL_TYPE_FLOAT, MYSQL_TYPE_INT24,
194
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
195
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
196
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
197
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_FLOAT,
198
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
199
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
200
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
201
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_VARCHAR,
204
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
205
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
209
/* MYSQL_TYPE_DOUBLE -> */
211
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
212
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_DOUBLE,
213
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
214
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_DOUBLE,
215
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
216
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_DOUBLE,
217
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
218
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_VARCHAR,
219
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
220
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_INT24,
221
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
222
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
223
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
224
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_DOUBLE,
225
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
226
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
227
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
228
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_VARCHAR,
231
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
232
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
236
/* MYSQL_TYPE_NULL -> */
238
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
239
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_TINY,
240
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
241
MYSQL_TYPE_SHORT, MYSQL_TYPE_LONG,
242
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
243
MYSQL_TYPE_FLOAT, MYSQL_TYPE_DOUBLE,
244
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
245
MYSQL_TYPE_NULL, MYSQL_TYPE_TIMESTAMP,
246
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
247
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_INT24,
248
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
249
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_TIME,
250
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
251
MYSQL_TYPE_DATETIME, MYSQL_TYPE_YEAR,
252
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
253
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
254
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
255
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_ENUM,
258
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
259
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
263
/* MYSQL_TYPE_TIMESTAMP -> */
265
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
266
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
267
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
268
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
269
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
270
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
271
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
272
MYSQL_TYPE_TIMESTAMP, MYSQL_TYPE_TIMESTAMP,
273
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
274
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
275
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
276
MYSQL_TYPE_DATETIME, MYSQL_TYPE_DATETIME,
277
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
278
MYSQL_TYPE_DATETIME, MYSQL_TYPE_VARCHAR,
279
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
280
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
281
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
282
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
285
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
286
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
290
/* MYSQL_TYPE_LONGLONG -> */
292
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
293
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_LONGLONG,
294
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
295
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_LONGLONG,
296
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
297
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_DOUBLE,
298
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
299
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_VARCHAR,
300
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
301
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_LONG,
302
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
303
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
304
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
305
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_LONGLONG,
306
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
307
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
308
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
309
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
312
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
313
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
317
/* MYSQL_TYPE_INT24 -> */
319
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
320
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_INT24,
321
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
322
MYSQL_TYPE_INT24, MYSQL_TYPE_LONG,
323
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
324
MYSQL_TYPE_FLOAT, MYSQL_TYPE_DOUBLE,
325
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
326
MYSQL_TYPE_INT24, MYSQL_TYPE_VARCHAR,
327
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
328
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_INT24,
329
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
330
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
331
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
332
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_INT24,
333
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
334
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
335
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
336
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
339
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
340
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
344
/* MYSQL_TYPE_DATE -> */
346
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
347
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
348
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
349
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
350
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
351
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
352
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
353
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_DATETIME,
354
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
355
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
356
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
357
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_DATETIME,
358
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
359
MYSQL_TYPE_DATETIME, MYSQL_TYPE_VARCHAR,
360
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
361
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
362
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
363
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
366
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
367
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
371
/* MYSQL_TYPE_TIME -> */
373
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
374
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
375
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
376
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
377
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
378
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
379
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
380
MYSQL_TYPE_TIME, MYSQL_TYPE_DATETIME,
381
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
382
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
383
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
384
MYSQL_TYPE_DATETIME, MYSQL_TYPE_TIME,
385
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
386
MYSQL_TYPE_DATETIME, MYSQL_TYPE_VARCHAR,
387
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
388
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
389
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
390
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
393
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
394
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
398
/* MYSQL_TYPE_DATETIME -> */
400
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
401
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
402
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
403
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
404
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
405
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
406
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
407
MYSQL_TYPE_DATETIME, MYSQL_TYPE_DATETIME,
408
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
409
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
410
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
411
MYSQL_TYPE_DATETIME, MYSQL_TYPE_DATETIME,
412
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
413
MYSQL_TYPE_DATETIME, MYSQL_TYPE_VARCHAR,
414
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
415
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
416
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
417
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
420
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
421
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
425
/* MYSQL_TYPE_YEAR -> */
427
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
428
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_TINY,
429
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
430
MYSQL_TYPE_SHORT, MYSQL_TYPE_LONG,
431
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
432
MYSQL_TYPE_FLOAT, MYSQL_TYPE_DOUBLE,
433
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
434
MYSQL_TYPE_YEAR, MYSQL_TYPE_VARCHAR,
435
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
436
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_INT24,
437
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
438
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
439
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
440
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_YEAR,
441
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
442
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
443
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
444
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
447
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
448
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
452
/* MYSQL_TYPE_NEWDATE -> */
454
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
455
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
456
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
457
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
458
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
459
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
460
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
461
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_DATETIME,
462
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
463
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
464
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
465
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_DATETIME,
466
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
467
MYSQL_TYPE_DATETIME, MYSQL_TYPE_VARCHAR,
468
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
469
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
470
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
471
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
474
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
475
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
479
/* MYSQL_TYPE_VARCHAR -> */
481
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
482
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
483
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
484
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
485
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
486
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
487
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
488
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
489
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
490
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
491
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
492
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
493
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
494
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
495
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
496
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
497
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
498
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
501
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
502
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
506
/* MYSQL_TYPE_NEWDECIMAL -> */
508
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
509
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_NEWDECIMAL,
510
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
511
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_NEWDECIMAL,
512
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
513
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_DOUBLE,
514
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
515
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
516
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
517
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_NEWDECIMAL,
518
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
519
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
520
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
521
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_NEWDECIMAL,
522
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
523
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
524
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
525
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
528
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
529
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
533
/* MYSQL_TYPE_ENUM -> */
535
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
536
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
537
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
538
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
539
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
540
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
541
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
542
MYSQL_TYPE_ENUM, MYSQL_TYPE_VARCHAR,
543
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
544
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
545
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
546
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
547
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
548
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
549
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
550
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
551
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
552
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
555
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
556
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
560
/* MYSQL_TYPE_SET -> */
562
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
563
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
564
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
565
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
566
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
567
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
568
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
569
MYSQL_TYPE_SET, MYSQL_TYPE_VARCHAR,
570
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
571
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
572
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
573
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
574
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
575
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
576
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
577
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
578
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
579
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
582
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
583
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
587
/* MYSQL_TYPE_BLOB -> */
589
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
590
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
591
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
592
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
593
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
594
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
595
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
596
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
597
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
598
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
599
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
600
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
601
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
602
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
603
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
604
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
605
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
606
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
609
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
610
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
614
/* MYSQL_TYPE_VAR_STRING -> */
616
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
617
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
618
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
619
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
620
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
621
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
622
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
623
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
624
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
625
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
626
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
627
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
628
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
629
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
630
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
631
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
632
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
633
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
636
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
637
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
641
/* MYSQL_TYPE_STRING -> */
643
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
644
MYSQL_TYPE_STRING, MYSQL_TYPE_STRING,
645
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
646
MYSQL_TYPE_STRING, MYSQL_TYPE_STRING,
647
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
648
MYSQL_TYPE_STRING, MYSQL_TYPE_STRING,
649
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
650
MYSQL_TYPE_STRING, MYSQL_TYPE_STRING,
651
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
652
MYSQL_TYPE_STRING, MYSQL_TYPE_STRING,
653
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
654
MYSQL_TYPE_STRING, MYSQL_TYPE_STRING,
655
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
656
MYSQL_TYPE_STRING, MYSQL_TYPE_STRING,
657
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
658
MYSQL_TYPE_STRING, MYSQL_TYPE_VARCHAR,
659
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
660
MYSQL_TYPE_STRING, MYSQL_TYPE_STRING,
663
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
664
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
1045
1560
/****************************************************************************
1561
Field_null, a field that always return NULL
1562
****************************************************************************/
1564
void Field_null::sql_type(String &res) const
1566
res.set_ascii(STRING_WITH_LEN("null"));
1570
/****************************************************************************
1571
** Field_new_decimal
1572
****************************************************************************/
1574
Field_new_decimal::Field_new_decimal(uchar *ptr_arg,
1575
uint32 len_arg, uchar *null_ptr_arg,
1577
enum utype unireg_check_arg,
1578
const char *field_name_arg,
1579
uint8 dec_arg,bool zero_arg,
1581
:Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
1582
unireg_check_arg, field_name_arg, dec_arg, zero_arg, unsigned_arg)
1584
precision= my_decimal_length_to_precision(len_arg, dec_arg, unsigned_arg);
1585
set_if_smaller(precision, DECIMAL_MAX_PRECISION);
1586
assert((precision <= DECIMAL_MAX_PRECISION) &&
1587
(dec <= DECIMAL_MAX_SCALE));
1588
bin_size= my_decimal_get_binary_size(precision, dec);
1592
Field_new_decimal::Field_new_decimal(uint32 len_arg,
1593
bool maybe_null_arg,
1597
:Field_num((uchar*) 0, len_arg,
1598
maybe_null_arg ? (uchar*) "": 0, 0,
1599
NONE, name, dec_arg, 0, unsigned_arg)
1601
precision= my_decimal_length_to_precision(len_arg, dec_arg, unsigned_arg);
1602
set_if_smaller(precision, DECIMAL_MAX_PRECISION);
1603
assert((precision <= DECIMAL_MAX_PRECISION) &&
1604
(dec <= DECIMAL_MAX_SCALE));
1605
bin_size= my_decimal_get_binary_size(precision, dec);
1609
int Field_new_decimal::reset(void)
1611
store_value(&decimal_zero);
1617
Generate max/min decimal value in case of overflow.
1619
@param decimal_value buffer for value
1620
@param sign sign of value which caused overflow
1623
void Field_new_decimal::set_value_on_overflow(my_decimal *decimal_value,
1626
max_my_decimal(decimal_value, precision, decimals());
1630
my_decimal_set_zero(decimal_value);
1632
decimal_value->sign(true);
1639
Store decimal value in the binary buffer.
1641
Checks if decimal_value fits into field size.
1642
If it does, stores the decimal in the buffer using binary format.
1643
Otherwise sets maximal number that can be stored in the field.
1645
@param decimal_value my_decimal
1653
bool Field_new_decimal::store_value(const my_decimal *decimal_value)
1657
/* check that we do not try to write negative value in unsigned field */
1658
if (unsigned_flag && decimal_value->sign())
1660
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1662
decimal_value= &decimal_zero;
1665
if (warn_if_overflow(my_decimal2binary(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW,
1666
decimal_value, ptr, precision, dec)))
1669
set_value_on_overflow(&buff, decimal_value->sign());
1670
my_decimal2binary(E_DEC_FATAL_ERROR, &buff, ptr, precision, dec);
1677
int Field_new_decimal::store(const char *from, uint length,
1678
CHARSET_INFO *charset_arg)
1681
my_decimal decimal_value;
1683
if ((err= str2my_decimal(E_DEC_FATAL_ERROR &
1684
~(E_DEC_OVERFLOW | E_DEC_BAD_NUM),
1685
from, length, charset_arg,
1687
table->in_use->abort_on_warning)
1689
/* Because "from" is not NUL-terminated and we use %s in the ER() */
1691
from_as_str.copy(from, length, &my_charset_bin);
1693
push_warning_printf(table->in_use, MYSQL_ERROR::WARN_LEVEL_ERROR,
1694
ER_TRUNCATED_WRONG_VALUE_FOR_FIELD,
1695
ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
1696
"decimal", from_as_str.c_ptr(), field_name,
1697
(ulong) table->in_use->row_count);
1703
case E_DEC_TRUNCATED:
1704
set_warning(MYSQL_ERROR::WARN_LEVEL_NOTE, WARN_DATA_TRUNCATED, 1);
1706
case E_DEC_OVERFLOW:
1707
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1708
set_value_on_overflow(&decimal_value, decimal_value.sign());
1712
/* Because "from" is not NUL-terminated and we use %s in the ER() */
1714
from_as_str.copy(from, length, &my_charset_bin);
1716
push_warning_printf(table->in_use, MYSQL_ERROR::WARN_LEVEL_WARN,
1717
ER_TRUNCATED_WRONG_VALUE_FOR_FIELD,
1718
ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
1719
"decimal", from_as_str.c_ptr(), field_name,
1720
(ulong) table->in_use->row_count);
1721
my_decimal_set_zero(&decimal_value);
1727
store_value(&decimal_value);
1734
Fix following when double2my_decimal when double2decimal
1735
will return E_DEC_TRUNCATED always correctly
1738
int Field_new_decimal::store(double nr)
1740
my_decimal decimal_value;
1743
err= double2my_decimal(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW, nr,
1747
if (check_overflow(err))
1748
set_value_on_overflow(&decimal_value, decimal_value.sign());
1749
/* Only issue a warning if store_value doesn't issue an warning */
1750
table->in_use->got_warning= 0;
1752
if (store_value(&decimal_value))
1754
else if (err && !table->in_use->got_warning)
1755
err= warn_if_overflow(err);
1760
int Field_new_decimal::store(int64_t nr, bool unsigned_val)
1762
my_decimal decimal_value;
1765
if ((err= int2my_decimal(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW,
1766
nr, unsigned_val, &decimal_value)))
1768
if (check_overflow(err))
1769
set_value_on_overflow(&decimal_value, decimal_value.sign());
1770
/* Only issue a warning if store_value doesn't issue an warning */
1771
table->in_use->got_warning= 0;
1773
if (store_value(&decimal_value))
1775
else if (err && !table->in_use->got_warning)
1776
err= warn_if_overflow(err);
1781
int Field_new_decimal::store_decimal(const my_decimal *decimal_value)
1783
return store_value(decimal_value);
1787
int Field_new_decimal::store_time(MYSQL_TIME *ltime,
1788
timestamp_type t_type __attribute__((__unused__)))
1790
my_decimal decimal_value;
1791
return store_value(date2my_decimal(ltime, &decimal_value));
1795
double Field_new_decimal::val_real(void)
1798
my_decimal decimal_value;
1799
my_decimal2double(E_DEC_FATAL_ERROR, val_decimal(&decimal_value), &dbl);
1804
int64_t Field_new_decimal::val_int(void)
1807
my_decimal decimal_value;
1808
my_decimal2int(E_DEC_FATAL_ERROR, val_decimal(&decimal_value),
1814
my_decimal* Field_new_decimal::val_decimal(my_decimal *decimal_value)
1816
binary2my_decimal(E_DEC_FATAL_ERROR, ptr, decimal_value,
1818
return(decimal_value);
1822
String *Field_new_decimal::val_str(String *val_buffer,
1823
String *val_ptr __attribute__((unused)))
1825
my_decimal decimal_value;
1826
uint fixed_precision= zerofill ? precision : 0;
1827
my_decimal2string(E_DEC_FATAL_ERROR, val_decimal(&decimal_value),
1828
fixed_precision, dec, '0', val_buffer);
1833
int Field_new_decimal::cmp(const uchar *a,const uchar*b)
1835
return memcmp(a, b, bin_size);
1839
void Field_new_decimal::sort_string(uchar *buff,
1840
uint length __attribute__((unused)))
1842
memcpy(buff, ptr, bin_size);
1846
void Field_new_decimal::sql_type(String &str) const
1848
CHARSET_INFO *cs= str.charset();
1849
str.length(cs->cset->snprintf(cs, (char*) str.ptr(), str.alloced_length(),
1850
"decimal(%d,%d)", precision, (int)dec));
1851
add_zerofill_and_unsigned(str);
1856
Save the field metadata for new decimal fields.
1858
Saves the precision in the first byte and decimals() in the second
1859
byte of the field metadata array at index of *metadata_ptr and
1860
*(metadata_ptr + 1).
1862
@param metadata_ptr First byte of field metadata
1864
@returns number of bytes written to metadata_ptr
1866
int Field_new_decimal::do_save_field_metadata(uchar *metadata_ptr)
1868
*metadata_ptr= precision;
1869
*(metadata_ptr + 1)= decimals();
1875
Returns the number of bytes field uses in row-based replication
1878
This method is used in row-based replication to determine the number
1879
of bytes that the field consumes in the row record format. This is
1880
used to skip fields in the master that do not exist on the slave.
1882
@param field_metadata Encoded size in field metadata
1884
@returns The size of the field based on the field metadata.
1886
uint Field_new_decimal::pack_length_from_metadata(uint field_metadata)
1888
uint const source_precision= (field_metadata >> 8U) & 0x00ff;
1889
uint const source_decimal= field_metadata & 0x00ff;
1890
uint const source_size= my_decimal_get_binary_size(source_precision,
1892
return (source_size);
1897
Check to see if field size is compatible with destination.
1899
This method is used in row-based replication to verify that the slave's
1900
field size is less than or equal to the master's field size. The
1901
encoded field metadata (from the master or source) is decoded and compared
1902
to the size of this field (the slave or destination).
1904
@param field_metadata Encoded size in field metadata
1906
@retval 0 if this field's size is < the source field's size
1907
@retval 1 if this field's size is >= the source field's size
1909
int Field_new_decimal::compatible_field_size(uint field_metadata)
1912
uint const source_precision= (field_metadata >> 8U) & 0x00ff;
1913
uint const source_decimal= field_metadata & 0x00ff;
1914
uint const source_size= my_decimal_get_binary_size(source_precision,
1916
uint const destination_size= row_pack_length();
1917
compatible= (source_size <= destination_size);
1919
compatible= (source_precision <= precision) &&
1920
(source_decimal <= decimals());
1921
return (compatible);
1925
uint Field_new_decimal::is_equal(Create_field *new_field)
1927
return ((new_field->sql_type == real_type()) &&
1928
((new_field->flags & UNSIGNED_FLAG) ==
1929
(uint) (flags & UNSIGNED_FLAG)) &&
1930
((new_field->flags & AUTO_INCREMENT_FLAG) ==
1931
(uint) (flags & AUTO_INCREMENT_FLAG)) &&
1932
(new_field->length == max_display_length()) &&
1933
(new_field->decimals == dec));
1938
Unpack a decimal field from row data.
1940
This method is used to unpack a decimal or numeric field from a master
1941
whose size of the field is less than that of the slave.
1943
@param to Destination of the data
1944
@param from Source of the data
1945
@param param_data Precision (upper) and decimal (lower) values
1947
@return New pointer into memory based on from + length of the data
1950
Field_new_decimal::unpack(uchar* to,
1953
bool low_byte_first)
1955
if (param_data == 0)
1956
return Field::unpack(to, from, param_data, low_byte_first);
1958
uint from_precision= (param_data & 0xff00) >> 8U;
1959
uint from_decimal= param_data & 0x00ff;
1960
uint length=pack_length();
1961
uint from_pack_len= my_decimal_get_binary_size(from_precision, from_decimal);
1962
uint len= (param_data && (from_pack_len < length)) ?
1963
from_pack_len : length;
1964
if ((from_pack_len && (from_pack_len < length)) ||
1965
(from_precision < precision) ||
1966
(from_decimal < decimals()))
1969
If the master's data is smaller than the slave, we need to convert
1970
the binary to decimal then resize the decimal converting it back to
1971
a decimal and write that to the raw data buffer.
1973
decimal_digit_t dec_buf[DECIMAL_MAX_PRECISION];
1975
dec.len= from_precision;
1978
Note: bin2decimal does not change the length of the field. So it is
1979
just the first step the resizing operation. The second step does the
1980
resizing using the precision and decimals from the slave.
1982
bin2decimal((uchar *)from, &dec, from_precision, from_decimal);
1983
decimal2bin(&dec, to, precision, decimals());
1986
memcpy(to, from, len); // Sizes are the same, just copy the data.
1990
/****************************************************************************
1047
1992
****************************************************************************/
1049
int Field_tiny::store(const char *from,uint32_t len, const CHARSET_INFO * const cs)
1994
int Field_tiny::store(const char *from,uint len,CHARSET_INFO *cs)
1054
1999
error= get_int(cs, from, len, &rnd, 255, -128, 127);
2000
ptr[0]= unsigned_flag ? (char) (uint64_t) rnd : (char) rnd;
1125
2107
String *Field_tiny::val_str(String *val_buffer,
1126
2108
String *val_ptr __attribute__((unused)))
1128
const CHARSET_INFO * const cs= &my_charset_bin;
1130
uint32_t mlength=cmax(field_length+1,5*cs->mbmaxlen);
2110
CHARSET_INFO *cs= &my_charset_bin;
2112
uint mlength=max(field_length+1,5*cs->mbmaxlen);
1131
2113
val_buffer->alloc(mlength);
1132
2114
char *to=(char*) val_buffer->ptr();
1134
length= (uint32_t) cs->cset->long10_to_str(cs,to,mlength,-10,
1135
(long) *((signed char*) ptr));
2117
length= (uint) cs->cset->long10_to_str(cs,to,mlength, 10,
2120
length= (uint) cs->cset->long10_to_str(cs,to,mlength,-10,
2121
(long) *((signed char*) ptr));
1137
2123
val_buffer->length(length);
2125
prepend_zeros(val_buffer);
1139
2126
return val_buffer;
1142
2129
bool Field_tiny::send_binary(Protocol *protocol)
1144
return protocol->store_tiny((int64_t) (int8_t) ptr[0]);
2131
return protocol->store_tiny((int64_t) (int8) ptr[0]);
1147
int Field_tiny::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)
2134
int Field_tiny::cmp(const uchar *a_ptr, const uchar *b_ptr)
1149
2136
signed char a,b;
1150
2137
a=(signed char) a_ptr[0]; b= (signed char) b_ptr[0];
2139
return ((uchar) a < (uchar) b) ? -1 : ((uchar) a > (uchar) b) ? 1 : 0;
1152
2140
return (a < b) ? -1 : (a > b) ? 1 : 0;
1155
void Field_tiny::sort_string(unsigned char *to,uint32_t length __attribute__((unused)))
2143
void Field_tiny::sort_string(uchar *to,uint length __attribute__((unused)))
1157
to[0] = (char) (ptr[0] ^ (unsigned char) 128); /* Revers signbit */
2148
to[0] = (char) (ptr[0] ^ (uchar) 128); /* Revers signbit */
1160
2151
void Field_tiny::sql_type(String &res) const
1162
const CHARSET_INFO * const cs=res.charset();
2153
CHARSET_INFO *cs=res.charset();
1163
2154
res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
1164
2155
"tinyint(%d)",(int) field_length));
2156
add_zerofill_and_unsigned(res);
2159
/****************************************************************************
2160
Field type short int (2 byte)
2161
****************************************************************************/
2163
int Field_short::store(const char *from,uint len,CHARSET_INFO *cs)
2169
error= get_int(cs, from, len, &rnd, UINT_MAX16, INT_MIN16, INT_MAX16);
2170
store_tmp= unsigned_flag ? (int) (uint64_t) rnd : (int) rnd;
2171
#ifdef WORDS_BIGENDIAN
2172
if (table->s->db_low_byte_first)
2174
int2store(ptr, store_tmp);
2178
shortstore(ptr, (short) store_tmp);
2183
int Field_short::store(double nr)
2193
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2196
else if (nr > (double) UINT_MAX16)
2198
res=(int16) UINT_MAX16;
2199
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2203
res=(int16) (uint16) nr;
2207
if (nr < (double) INT_MIN16)
2210
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2213
else if (nr > (double) INT_MAX16)
2216
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2220
res=(int16) (int) nr;
2222
#ifdef WORDS_BIGENDIAN
2223
if (table->s->db_low_byte_first)
2229
shortstore(ptr,res);
2234
int Field_short::store(int64_t nr, bool unsigned_val)
2241
if (nr < 0L && !unsigned_val)
2244
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2247
else if ((uint64_t) nr > (uint64_t) UINT_MAX16)
2249
res=(int16) UINT_MAX16;
2250
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2254
res=(int16) (uint16) nr;
2258
if (nr < 0 && unsigned_val)
2259
nr= UINT_MAX16+1; // Generate overflow
2264
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2267
else if (nr > (int64_t) INT_MAX16)
2270
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2276
#ifdef WORDS_BIGENDIAN
2277
if (table->s->db_low_byte_first)
2283
shortstore(ptr,res);
2288
double Field_short::val_real(void)
2291
#ifdef WORDS_BIGENDIAN
2292
if (table->s->db_low_byte_first)
2297
return unsigned_flag ? (double) (unsigned short) j : (double) j;
2300
int64_t Field_short::val_int(void)
2303
#ifdef WORDS_BIGENDIAN
2304
if (table->s->db_low_byte_first)
2309
return unsigned_flag ? (int64_t) (unsigned short) j : (int64_t) j;
2313
String *Field_short::val_str(String *val_buffer,
2314
String *val_ptr __attribute__((unused)))
2316
CHARSET_INFO *cs= &my_charset_bin;
2318
uint mlength=max(field_length+1,7*cs->mbmaxlen);
2319
val_buffer->alloc(mlength);
2320
char *to=(char*) val_buffer->ptr();
2322
#ifdef WORDS_BIGENDIAN
2323
if (table->s->db_low_byte_first)
2330
length=(uint) cs->cset->long10_to_str(cs, to, mlength, 10,
2333
length=(uint) cs->cset->long10_to_str(cs, to, mlength,-10, (long) j);
2334
val_buffer->length(length);
2336
prepend_zeros(val_buffer);
2341
bool Field_short::send_binary(Protocol *protocol)
2343
return protocol->store_short(Field_short::val_int());
2347
int Field_short::cmp(const uchar *a_ptr, const uchar *b_ptr)
2350
#ifdef WORDS_BIGENDIAN
2351
if (table->s->db_low_byte_first)
2364
return ((unsigned short) a < (unsigned short) b) ? -1 :
2365
((unsigned short) a > (unsigned short) b) ? 1 : 0;
2366
return (a < b) ? -1 : (a > b) ? 1 : 0;
2369
void Field_short::sort_string(uchar *to,uint length __attribute__((unused)))
2371
#ifdef WORDS_BIGENDIAN
2372
if (!table->s->db_low_byte_first)
2377
to[0] = (char) (ptr[0] ^ 128); /* Revers signbit */
2386
to[0] = (char) (ptr[1] ^ 128); /* Revers signbit */
2391
void Field_short::sql_type(String &res) const
2393
CHARSET_INFO *cs=res.charset();
2394
res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
2395
"smallint(%d)",(int) field_length));
2396
add_zerofill_and_unsigned(res);
2400
/****************************************************************************
2402
****************************************************************************/
2404
int Field_long::store(const char *from,uint len,CHARSET_INFO *cs)
2410
error= get_int(cs, from, len, &rnd, UINT_MAX32, INT_MIN32, INT_MAX32);
2411
store_tmp= unsigned_flag ? (long) (uint64_t) rnd : (long) rnd;
2412
#ifdef WORDS_BIGENDIAN
2413
if (table->s->db_low_byte_first)
2415
int4store(ptr, store_tmp);
2419
longstore(ptr, store_tmp);
2424
int Field_long::store(double nr)
2436
else if (nr > (double) UINT_MAX32)
2439
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2443
res=(int32) (ulong) nr;
2447
if (nr < (double) INT_MIN32)
2449
res=(int32) INT_MIN32;
2452
else if (nr > (double) INT_MAX32)
2454
res=(int32) INT_MAX32;
2458
res=(int32) (int64_t) nr;
2461
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2463
#ifdef WORDS_BIGENDIAN
2464
if (table->s->db_low_byte_first)
2475
int Field_long::store(int64_t nr, bool unsigned_val)
2482
if (nr < 0 && !unsigned_val)
2487
else if ((uint64_t) nr >= (1LL << 32))
2489
res=(int32) (uint32) ~0L;
2493
res=(int32) (uint32) nr;
2497
if (nr < 0 && unsigned_val)
2498
nr= ((int64_t) INT_MAX32) + 1; // Generate overflow
2499
if (nr < (int64_t) INT_MIN32)
2501
res=(int32) INT_MIN32;
2504
else if (nr > (int64_t) INT_MAX32)
2506
res=(int32) INT_MAX32;
2513
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2515
#ifdef WORDS_BIGENDIAN
2516
if (table->s->db_low_byte_first)
2527
double Field_long::val_real(void)
2530
#ifdef WORDS_BIGENDIAN
2531
if (table->s->db_low_byte_first)
2536
return unsigned_flag ? (double) (uint32) j : (double) j;
2539
int64_t Field_long::val_int(void)
2542
/* See the comment in Field_long::store(long long) */
2543
assert(table->in_use == current_thd);
2544
#ifdef WORDS_BIGENDIAN
2545
if (table->s->db_low_byte_first)
2550
return unsigned_flag ? (int64_t) (uint32) j : (int64_t) j;
2553
String *Field_long::val_str(String *val_buffer,
2554
String *val_ptr __attribute__((unused)))
2556
CHARSET_INFO *cs= &my_charset_bin;
2558
uint mlength=max(field_length+1,12*cs->mbmaxlen);
2559
val_buffer->alloc(mlength);
2560
char *to=(char*) val_buffer->ptr();
2562
#ifdef WORDS_BIGENDIAN
2563
if (table->s->db_low_byte_first)
2570
length=cs->cset->long10_to_str(cs,to,mlength, 10,(long) (uint32)j);
2572
length=cs->cset->long10_to_str(cs,to,mlength,-10,(long) j);
2573
val_buffer->length(length);
2575
prepend_zeros(val_buffer);
2580
bool Field_long::send_binary(Protocol *protocol)
2582
return protocol->store_long(Field_long::val_int());
2585
int Field_long::cmp(const uchar *a_ptr, const uchar *b_ptr)
2588
#ifdef WORDS_BIGENDIAN
2589
if (table->s->db_low_byte_first)
2601
return ((uint32) a < (uint32) b) ? -1 : ((uint32) a > (uint32) b) ? 1 : 0;
2602
return (a < b) ? -1 : (a > b) ? 1 : 0;
2605
void Field_long::sort_string(uchar *to,uint length __attribute__((unused)))
2607
#ifdef WORDS_BIGENDIAN
2608
if (!table->s->db_low_byte_first)
2613
to[0] = (char) (ptr[0] ^ 128); /* Revers signbit */
2624
to[0] = (char) (ptr[3] ^ 128); /* Revers signbit */
2632
void Field_long::sql_type(String &res) const
2634
CHARSET_INFO *cs=res.charset();
2635
res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
2636
"int(%d)",(int) field_length));
2637
add_zerofill_and_unsigned(res);
2640
/****************************************************************************
2641
Field type int64_t int (8 bytes)
2642
****************************************************************************/
2644
int Field_int64_t::store(const char *from,uint len,CHARSET_INFO *cs)
2650
tmp= cs->cset->strntoull10rnd(cs,from,len,unsigned_flag,&end,&error);
2651
if (error == MY_ERRNO_ERANGE)
2653
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2656
else if (table->in_use->count_cuted_fields &&
2657
check_int(cs, from, len, end, error))
2661
#ifdef WORDS_BIGENDIAN
2662
if (table->s->db_low_byte_first)
2668
int64_tstore(ptr,tmp);
2673
int Field_int64_t::store(double nr)
2686
else if (nr >= (double) ULONGLONG_MAX)
2692
res=(int64_t) (uint64_t) nr;
2696
if (nr <= (double) LONGLONG_MIN)
2699
error= (nr < (double) LONGLONG_MIN);
2701
else if (nr >= (double) (uint64_t) LONGLONG_MAX)
2704
error= (nr > (double) LONGLONG_MAX);
2710
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2712
#ifdef WORDS_BIGENDIAN
2713
if (table->s->db_low_byte_first)
2719
int64_tstore(ptr,res);
2724
int Field_int64_t::store(int64_t nr, bool unsigned_val)
2728
if (nr < 0) // Only possible error
2731
if field is unsigned and value is signed (< 0) or
2732
if field is signed and value is unsigned we have an overflow
2734
if (unsigned_flag != unsigned_val)
2736
nr= unsigned_flag ? (uint64_t) 0 : (uint64_t) LONGLONG_MAX;
2737
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2742
#ifdef WORDS_BIGENDIAN
2743
if (table->s->db_low_byte_first)
2749
int64_tstore(ptr,nr);
2754
double Field_int64_t::val_real(void)
2757
#ifdef WORDS_BIGENDIAN
2758
if (table->s->db_low_byte_first)
2765
/* The following is open coded to avoid a bug in gcc 3.3 */
2768
uint64_t tmp= (uint64_t) j;
2769
return uint64_t2double(tmp);
2775
int64_t Field_int64_t::val_int(void)
2778
#ifdef WORDS_BIGENDIAN
2779
if (table->s->db_low_byte_first)
2788
String *Field_int64_t::val_str(String *val_buffer,
2789
String *val_ptr __attribute__((unused)))
2791
CHARSET_INFO *cs= &my_charset_bin;
2793
uint mlength=max(field_length+1,22*cs->mbmaxlen);
2794
val_buffer->alloc(mlength);
2795
char *to=(char*) val_buffer->ptr();
2797
#ifdef WORDS_BIGENDIAN
2798
if (table->s->db_low_byte_first)
2804
length=(uint) (cs->cset->int64_t10_to_str)(cs,to,mlength,
2805
unsigned_flag ? 10 : -10, j);
2806
val_buffer->length(length);
2808
prepend_zeros(val_buffer);
2813
bool Field_int64_t::send_binary(Protocol *protocol)
2815
return protocol->store_int64_t(Field_int64_t::val_int(), unsigned_flag);
2819
int Field_int64_t::cmp(const uchar *a_ptr, const uchar *b_ptr)
2822
#ifdef WORDS_BIGENDIAN
2823
if (table->s->db_low_byte_first)
2831
int64_tget(a,a_ptr);
2832
int64_tget(b,b_ptr);
2835
return ((uint64_t) a < (uint64_t) b) ? -1 :
2836
((uint64_t) a > (uint64_t) b) ? 1 : 0;
2837
return (a < b) ? -1 : (a > b) ? 1 : 0;
2840
void Field_int64_t::sort_string(uchar *to,uint length __attribute__((unused)))
2842
#ifdef WORDS_BIGENDIAN
2843
if (!table->s->db_low_byte_first)
2848
to[0] = (char) (ptr[0] ^ 128); /* Revers signbit */
2863
to[0] = (char) (ptr[7] ^ 128); /* Revers signbit */
2875
void Field_int64_t::sql_type(String &res) const
2877
CHARSET_INFO *cs=res.charset();
2878
res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
2879
"bigint(%d)",(int) field_length));
2880
add_zerofill_and_unsigned(res);
2885
Floating-point numbers
2889
Field_real::pack(uchar *to, const uchar *from,
2890
uint max_length, bool low_byte_first)
2892
assert(max_length >= pack_length());
2893
#ifdef WORDS_BIGENDIAN
2894
if (low_byte_first != table->s->db_low_byte_first)
2896
const uchar *dptr= from + pack_length();
2897
while (dptr-- > from)
2903
return(Field::pack(to, from, max_length, low_byte_first));
2907
Field_real::unpack(uchar *to, const uchar *from,
2908
uint param_data, bool low_byte_first)
2910
#ifdef WORDS_BIGENDIAN
2911
if (low_byte_first != table->s->db_low_byte_first)
2913
const uchar *dptr= from + pack_length();
2914
while (dptr-- > from)
2916
return(from + pack_length());
2920
return(Field::unpack(to, from, param_data, low_byte_first));
2923
/****************************************************************************
2924
single precision float
2925
****************************************************************************/
2927
int Field_float::store(const char *from,uint len,CHARSET_INFO *cs)
2931
double nr= my_strntod(cs,(char*) from,len,&end,&error);
2932
if (error || (!len || (((uint)(end-from) != len) && table->in_use->count_cuted_fields)))
2934
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
2935
(error ? ER_WARN_DATA_OUT_OF_RANGE : WARN_DATA_TRUNCATED), 1);
2936
error= error ? 1 : 2;
2938
Field_float::store(nr);
2943
int Field_float::store(double nr)
2945
int error= truncate(&nr, FLT_MAX);
2948
#ifdef WORDS_BIGENDIAN
2949
if (table->s->db_low_byte_first)
2955
memcpy_fixed(ptr,(uchar*) &j,sizeof(j));
2960
int Field_float::store(int64_t nr, bool unsigned_val)
2962
return Field_float::store(unsigned_val ? uint64_t2double((uint64_t) nr) :
2967
double Field_float::val_real(void)
2970
#ifdef WORDS_BIGENDIAN
2971
if (table->s->db_low_byte_first)
2977
memcpy_fixed((uchar*) &j,ptr,sizeof(j));
2978
return ((double) j);
2981
int64_t Field_float::val_int(void)
2984
#ifdef WORDS_BIGENDIAN
2985
if (table->s->db_low_byte_first)
2991
memcpy_fixed((uchar*) &j,ptr,sizeof(j));
2992
return (int64_t) rint(j);
2996
String *Field_float::val_str(String *val_buffer,
2997
String *val_ptr __attribute__((unused)))
3000
#ifdef WORDS_BIGENDIAN
3001
if (table->s->db_low_byte_first)
3007
memcpy_fixed((uchar*) &nr,ptr,sizeof(nr));
3009
uint to_length=max(field_length,70);
3010
val_buffer->alloc(to_length);
3011
char *to=(char*) val_buffer->ptr();
3014
if (dec >= NOT_FIXED_DEC)
3015
len= my_gcvt(nr, MY_GCVT_ARG_FLOAT, to_length - 1, to, NULL);
3019
We are safe here because the buffer length is >= 70, and
3020
fabs(float) < 10^39, dec < NOT_FIXED_DEC. So the resulting string
3021
will be not longer than 69 chars + terminating '\0'.
3023
len= my_fcvt(nr, dec, to, NULL);
3025
val_buffer->length((uint) len);
3027
prepend_zeros(val_buffer);
3032
int Field_float::cmp(const uchar *a_ptr, const uchar *b_ptr)
3035
#ifdef WORDS_BIGENDIAN
3036
if (table->s->db_low_byte_first)
3044
memcpy_fixed(&a,a_ptr,sizeof(float));
3045
memcpy_fixed(&b,b_ptr,sizeof(float));
3047
return (a < b) ? -1 : (a > b) ? 1 : 0;
3050
#define FLT_EXP_DIG (sizeof(float)*8-FLT_MANT_DIG)
3052
void Field_float::sort_string(uchar *to,uint length __attribute__((unused)))
3055
#ifdef WORDS_BIGENDIAN
3056
if (table->s->db_low_byte_first)
3062
memcpy_fixed(&nr,ptr,sizeof(float));
3065
if (nr == (float) 0.0)
3066
{ /* Change to zero string */
3068
bzero((char*) tmp+1,sizeof(nr)-1);
3072
#ifdef WORDS_BIGENDIAN
3073
memcpy_fixed(tmp,&nr,sizeof(nr));
3075
tmp[0]= ptr[3]; tmp[1]=ptr[2]; tmp[2]= ptr[1]; tmp[3]=ptr[0];
3077
if (tmp[0] & 128) /* Negative */
3078
{ /* make complement */
3080
for (i=0 ; i < sizeof(nr); i++)
3081
tmp[i]= (uchar) (tmp[i] ^ (uchar) 255);
3085
ushort exp_part=(((ushort) tmp[0] << 8) | (ushort) tmp[1] |
3087
exp_part+= (ushort) 1 << (16-1-FLT_EXP_DIG);
3088
tmp[0]= (uchar) (exp_part >> 8);
3089
tmp[1]= (uchar) exp_part;
3095
bool Field_float::send_binary(Protocol *protocol)
3097
return protocol->store((float) Field_float::val_real(), dec, (String*) 0);
3102
Save the field metadata for float fields.
3104
Saves the pack length in the first byte.
3106
@param metadata_ptr First byte of field metadata
3108
@returns number of bytes written to metadata_ptr
3110
int Field_float::do_save_field_metadata(uchar *metadata_ptr)
3112
*metadata_ptr= pack_length();
3117
void Field_float::sql_type(String &res) const
3119
if (dec == NOT_FIXED_DEC)
3121
res.set_ascii(STRING_WITH_LEN("float"));
3125
CHARSET_INFO *cs= res.charset();
3126
res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
3127
"float(%d,%d)",(int) field_length,dec));
3129
add_zerofill_and_unsigned(res);
3133
/****************************************************************************
3134
double precision floating point numbers
3135
****************************************************************************/
3137
int Field_double::store(const char *from,uint len,CHARSET_INFO *cs)
3141
double nr= my_strntod(cs,(char*) from, len, &end, &error);
3142
if (error || (!len || (((uint) (end-from) != len) && table->in_use->count_cuted_fields)))
3144
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3145
(error ? ER_WARN_DATA_OUT_OF_RANGE : WARN_DATA_TRUNCATED), 1);
3146
error= error ? 1 : 2;
3148
Field_double::store(nr);
3153
int Field_double::store(double nr)
3155
int error= truncate(&nr, DBL_MAX);
3157
#ifdef WORDS_BIGENDIAN
3158
if (table->s->db_low_byte_first)
3160
float8store(ptr,nr);
3164
doublestore(ptr,nr);
3169
int Field_double::store(int64_t nr, bool unsigned_val)
3171
return Field_double::store(unsigned_val ? uint64_t2double((uint64_t) nr) :
3176
If a field has fixed length, truncate the double argument pointed to by 'nr'
3178
Also ensure that the argument is within [-max_value; max_value] range.
3181
int Field_real::truncate(double *nr, double max_value)
3190
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3193
else if (unsigned_flag && res < 0)
3196
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3202
uint order= field_length - dec;
3203
uint step= array_elements(log_10) - 1;
3205
for (; order > step; order-= step)
3206
max_value*= log_10[step];
3207
max_value*= log_10[order];
3208
max_value-= 1.0 / log_10[dec];
3210
/* Check for infinity so we don't get NaN in calculations */
3213
double tmp= rint((res - floor(res)) * log_10[dec]) / log_10[dec];
3214
res= floor(res) + tmp;
3218
if (res < -max_value)
3221
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3223
else if (res > max_value)
3226
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3237
int Field_real::store_decimal(const my_decimal *dm)
3240
my_decimal2double(E_DEC_FATAL_ERROR, dm, &dbl);
3244
double Field_double::val_real(void)
3247
#ifdef WORDS_BIGENDIAN
3248
if (table->s->db_low_byte_first)
3258
int64_t Field_double::val_int(void)
3262
#ifdef WORDS_BIGENDIAN
3263
if (table->s->db_low_byte_first)
3270
/* Check whether we fit into int64_t range */
3271
if (j <= (double) LONGLONG_MIN)
3273
res= (int64_t) LONGLONG_MIN;
3276
if (j >= (double) (uint64_t) LONGLONG_MAX)
3278
res= (int64_t) LONGLONG_MAX;
3281
return (int64_t) rint(j);
3285
char buf[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
3286
String tmp(buf, sizeof(buf), &my_charset_latin1), *str;
3287
str= val_str(&tmp, 0);
3288
push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
3289
ER_TRUNCATED_WRONG_VALUE,
3290
ER(ER_TRUNCATED_WRONG_VALUE), "INTEGER",
3297
my_decimal *Field_real::val_decimal(my_decimal *decimal_value)
3299
double2my_decimal(E_DEC_FATAL_ERROR, val_real(), decimal_value);
3300
return decimal_value;
3304
String *Field_double::val_str(String *val_buffer,
3305
String *val_ptr __attribute__((unused)))
3308
#ifdef WORDS_BIGENDIAN
3309
if (table->s->db_low_byte_first)
3317
uint to_length=max(field_length, DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE);
3318
val_buffer->alloc(to_length);
3319
char *to=(char*) val_buffer->ptr();
3322
if (dec >= NOT_FIXED_DEC)
3323
len= my_gcvt(nr, MY_GCVT_ARG_DOUBLE, to_length - 1, to, NULL);
3325
len= my_fcvt(nr, dec, to, NULL);
3327
val_buffer->length((uint) len);
3329
prepend_zeros(val_buffer);
3333
bool Field_double::send_binary(Protocol *protocol)
3335
return protocol->store((double) Field_double::val_real(), dec, (String*) 0);
3339
int Field_double::cmp(const uchar *a_ptr, const uchar *b_ptr)
3342
#ifdef WORDS_BIGENDIAN
3343
if (table->s->db_low_byte_first)
3351
doubleget(a, a_ptr);
3352
doubleget(b, b_ptr);
3354
return (a < b) ? -1 : (a > b) ? 1 : 0;
3358
#define DBL_EXP_DIG (sizeof(double)*8-DBL_MANT_DIG)
3360
/* The following should work for IEEE */
3362
void Field_double::sort_string(uchar *to,uint length __attribute__((unused)))
3365
#ifdef WORDS_BIGENDIAN
3366
if (table->s->db_low_byte_first)
3373
change_double_for_sort(nr, to);
3378
Save the field metadata for double fields.
3380
Saves the pack length in the first byte of the field metadata array
3381
at index of *metadata_ptr.
3383
@param metadata_ptr First byte of field metadata
3385
@returns number of bytes written to metadata_ptr
3387
int Field_double::do_save_field_metadata(uchar *metadata_ptr)
3389
*metadata_ptr= pack_length();
3394
void Field_double::sql_type(String &res) const
3396
CHARSET_INFO *cs=res.charset();
3397
if (dec == NOT_FIXED_DEC)
3399
res.set_ascii(STRING_WITH_LEN("double"));
3403
res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
3404
"double(%d,%d)",(int) field_length,dec));
3406
add_zerofill_and_unsigned(res);
3411
TIMESTAMP type holds datetime values in range from 1970-01-01 00:00:01 UTC to
3412
2038-01-01 00:00:00 UTC stored as number of seconds since Unix
3415
Up to one of timestamps columns in the table can be automatically
3416
set on row update and/or have NOW() as default value.
3417
TABLE::timestamp_field points to Field object for such timestamp with
3418
auto-set-on-update. TABLE::time_stamp holds offset in record + 1 for this
3419
field, and is used by handler code which performs updates required.
3421
Actually SQL-99 says that we should allow niladic functions (like NOW())
3422
as defaults for any field. Current limitations (only NOW() and only
3423
for one TIMESTAMP field) are because of restricted binary .frm format
3424
and should go away in the future.
3426
Also because of this limitation of binary .frm format we use 5 different
3427
unireg_check values with TIMESTAMP field to distinguish various cases of
3428
DEFAULT or ON UPDATE values. These values are:
3430
TIMESTAMP_OLD_FIELD - old timestamp, if there was not any fields with
3431
auto-set-on-update (or now() as default) in this table before, then this
3432
field has NOW() as default and is updated when row changes, else it is
3433
field which has 0 as default value and is not automatically updated.
3434
TIMESTAMP_DN_FIELD - field with NOW() as default but not set on update
3435
automatically (TIMESTAMP DEFAULT NOW())
3436
TIMESTAMP_UN_FIELD - field which is set on update automatically but has not
3437
NOW() as default (but it may has 0 or some other const timestamp as
3438
default) (TIMESTAMP ON UPDATE NOW()).
3439
TIMESTAMP_DNUN_FIELD - field which has now() as default and is auto-set on
3440
update. (TIMESTAMP DEFAULT NOW() ON UPDATE NOW())
3441
NONE - field which is not auto-set on update with some other than NOW()
3442
default value (TIMESTAMP DEFAULT 0).
3444
Note that TIMESTAMP_OLD_FIELDs are never created explicitly now, they are
3445
left only for preserving ability to read old tables. Such fields replaced
3446
with their newer analogs in CREATE TABLE and in SHOW CREATE TABLE. This is
3447
because we want to prefer NONE unireg_check before TIMESTAMP_OLD_FIELD for
3448
"TIMESTAMP DEFAULT 'Const'" field. (Old timestamps allowed such
3449
specification too but ignored default value for first timestamp, which of
3450
course is non-standard.) In most cases user won't notice any change, only
3451
exception is different behavior of old/new timestamps during ALTER TABLE.
3454
Field_timestamp::Field_timestamp(uchar *ptr_arg,
3455
uint32 len_arg __attribute__((__unused__)),
3456
uchar *null_ptr_arg, uchar null_bit_arg,
3457
enum utype unireg_check_arg,
3458
const char *field_name_arg,
3461
:Field_str(ptr_arg, MAX_DATETIME_WIDTH, null_ptr_arg, null_bit_arg,
3462
unireg_check_arg, field_name_arg, cs)
3464
/* For 4.0 MYD and 4.0 InnoDB compatibility */
3465
flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
3466
if (!share->timestamp_field && unireg_check != NONE)
3468
/* This timestamp has auto-update */
3469
share->timestamp_field= this;
3470
flags|= TIMESTAMP_FLAG;
3471
if (unireg_check != TIMESTAMP_DN_FIELD)
3472
flags|= ON_UPDATE_NOW_FLAG;
3477
Field_timestamp::Field_timestamp(bool maybe_null_arg,
3478
const char *field_name_arg,
3480
:Field_str((uchar*) 0, MAX_DATETIME_WIDTH,
3481
maybe_null_arg ? (uchar*) "": 0, 0,
3482
NONE, field_name_arg, cs)
3484
/* For 4.0 MYD and 4.0 InnoDB compatibility */
3485
flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
3486
if (unireg_check != TIMESTAMP_DN_FIELD)
3487
flags|= ON_UPDATE_NOW_FLAG;
3492
Get auto-set type for TIMESTAMP field.
3494
Returns value indicating during which operations this TIMESTAMP field
3495
should be auto-set to current timestamp.
3497
timestamp_auto_set_type Field_timestamp::get_auto_set_type() const
3499
switch (unireg_check)
3501
case TIMESTAMP_DN_FIELD:
3502
return TIMESTAMP_AUTO_SET_ON_INSERT;
3503
case TIMESTAMP_UN_FIELD:
3504
return TIMESTAMP_AUTO_SET_ON_UPDATE;
3505
case TIMESTAMP_OLD_FIELD:
3507
Although we can have several such columns in legacy tables this
3508
function should be called only for first of them (i.e. the one
3509
having auto-set property).
3511
assert(table->timestamp_field == this);
3513
case TIMESTAMP_DNUN_FIELD:
3514
return TIMESTAMP_AUTO_SET_ON_BOTH;
3517
Normally this function should not be called for TIMESTAMPs without
3521
return TIMESTAMP_NO_AUTO_SET;
3526
int Field_timestamp::store(const char *from,
3528
CHARSET_INFO *cs __attribute__((__unused__)))
3533
bool have_smth_to_conv;
3534
bool in_dst_time_gap;
3535
THD *thd= table ? table->in_use : current_thd;
3537
/* We don't want to store invalid or fuzzy datetime values in TIMESTAMP */
3538
have_smth_to_conv= (str_to_datetime(from, len, &l_time, 1, &error) >
3539
MYSQL_TIMESTAMP_ERROR);
3541
if (error || !have_smth_to_conv)
3544
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
3545
from, len, MYSQL_TIMESTAMP_DATETIME, 1);
3548
/* Only convert a correct date (not a zero date) */
3549
if (have_smth_to_conv && l_time.month)
3551
if (!(tmp= TIME_to_timestamp(thd, &l_time, &in_dst_time_gap)))
3553
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3554
ER_WARN_DATA_OUT_OF_RANGE,
3555
from, len, MYSQL_TIMESTAMP_DATETIME, !error);
3558
else if (in_dst_time_gap)
3560
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3561
ER_WARN_INVALID_TIMESTAMP,
3562
from, len, MYSQL_TIMESTAMP_DATETIME, !error);
3566
store_timestamp(tmp);
3571
int Field_timestamp::store(double nr)
3574
if (nr < 0 || nr > 99991231235959.0)
3576
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3577
ER_WARN_DATA_OUT_OF_RANGE,
3578
nr, MYSQL_TIMESTAMP_DATETIME);
3579
nr= 0; // Avoid overflow on buff
3582
error|= Field_timestamp::store((int64_t) rint(nr), false);
3587
int Field_timestamp::store(int64_t nr,
3588
bool unsigned_val __attribute__((__unused__)))
3591
my_time_t timestamp= 0;
3593
bool in_dst_time_gap;
3594
THD *thd= table ? table->in_use : current_thd;
3596
/* We don't want to store invalid or fuzzy datetime values in TIMESTAMP */
3597
int64_t tmp= number_to_datetime(nr, &l_time, (thd->variables.sql_mode &
3598
MODE_NO_ZERO_DATE) |
3599
MODE_NO_ZERO_IN_DATE, &error);
3607
if (!(timestamp= TIME_to_timestamp(thd, &l_time, &in_dst_time_gap)))
3609
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3610
ER_WARN_DATA_OUT_OF_RANGE,
3611
nr, MYSQL_TIMESTAMP_DATETIME, 1);
3614
if (in_dst_time_gap)
3616
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3617
ER_WARN_INVALID_TIMESTAMP,
3618
nr, MYSQL_TIMESTAMP_DATETIME, 1);
3622
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3623
WARN_DATA_TRUNCATED,
3624
nr, MYSQL_TIMESTAMP_DATETIME, 1);
3626
store_timestamp(timestamp);
3630
double Field_timestamp::val_real(void)
3632
return (double) Field_timestamp::val_int();
3635
int64_t Field_timestamp::val_int(void)
3638
MYSQL_TIME time_tmp;
3639
THD *thd= table ? table->in_use : current_thd;
3641
thd->time_zone_used= 1;
3642
#ifdef WORDS_BIGENDIAN
3643
if (table && table->s->db_low_byte_first)
3644
temp=uint4korr(ptr);
3649
if (temp == 0L) // No time
3650
return(0); /* purecov: inspected */
3652
thd->variables.time_zone->gmt_sec_to_TIME(&time_tmp, (my_time_t)temp);
3654
return time_tmp.year * 10000000000LL + time_tmp.month * 100000000LL +
3655
time_tmp.day * 1000000L + time_tmp.hour * 10000L +
3656
time_tmp.minute * 100 + time_tmp.second;
3660
String *Field_timestamp::val_str(String *val_buffer, String *val_ptr)
3663
MYSQL_TIME time_tmp;
3664
THD *thd= table ? table->in_use : current_thd;
3667
val_buffer->alloc(field_length+1);
3668
to= (char*) val_buffer->ptr();
3669
val_buffer->length(field_length);
3671
thd->time_zone_used= 1;
3672
#ifdef WORDS_BIGENDIAN
3673
if (table && table->s->db_low_byte_first)
3674
temp=uint4korr(ptr);
3680
{ /* Zero time is "000000" */
3681
val_ptr->set(STRING_WITH_LEN("0000-00-00 00:00:00"), &my_charset_bin);
3684
val_buffer->set_charset(&my_charset_bin); // Safety
3686
thd->variables.time_zone->gmt_sec_to_TIME(&time_tmp,(my_time_t)temp);
3688
temp= time_tmp.year % 100;
3689
if (temp < YY_PART_YEAR - 1)
3699
temp2=temp/10; temp=temp-temp2*10;
3700
*to++= (char) ('0'+(char) (temp2));
3701
*to++= (char) ('0'+(char) (temp));
3703
temp=time_tmp.month;
3704
temp2=temp/10; temp=temp-temp2*10;
3705
*to++= (char) ('0'+(char) (temp2));
3706
*to++= (char) ('0'+(char) (temp));
3709
temp2=temp/10; temp=temp-temp2*10;
3710
*to++= (char) ('0'+(char) (temp2));
3711
*to++= (char) ('0'+(char) (temp));
3714
temp2=temp/10; temp=temp-temp2*10;
3715
*to++= (char) ('0'+(char) (temp2));
3716
*to++= (char) ('0'+(char) (temp));
3718
temp=time_tmp.minute;
3719
temp2=temp/10; temp=temp-temp2*10;
3720
*to++= (char) ('0'+(char) (temp2));
3721
*to++= (char) ('0'+(char) (temp));
3723
temp=time_tmp.second;
3724
temp2=temp/10; temp=temp-temp2*10;
3725
*to++= (char) ('0'+(char) (temp2));
3726
*to++= (char) ('0'+(char) (temp));
3732
bool Field_timestamp::get_date(MYSQL_TIME *ltime, uint fuzzydate)
3735
THD *thd= table ? table->in_use : current_thd;
3736
thd->time_zone_used= 1;
3737
#ifdef WORDS_BIGENDIAN
3738
if (table && table->s->db_low_byte_first)
3739
temp=uint4korr(ptr);
3744
{ /* Zero time is "000000" */
3745
if (fuzzydate & TIME_NO_ZERO_DATE)
3747
bzero((char*) ltime,sizeof(*ltime));
3751
thd->variables.time_zone->gmt_sec_to_TIME(ltime, (my_time_t)temp);
3756
bool Field_timestamp::get_time(MYSQL_TIME *ltime)
3758
return Field_timestamp::get_date(ltime,0);
3762
bool Field_timestamp::send_binary(Protocol *protocol)
3765
Field_timestamp::get_date(&tm, 0);
3766
return protocol->store(&tm);
3770
int Field_timestamp::cmp(const uchar *a_ptr, const uchar *b_ptr)
3773
#ifdef WORDS_BIGENDIAN
3774
if (table && table->s->db_low_byte_first)
3785
return ((uint32) a < (uint32) b) ? -1 : ((uint32) a > (uint32) b) ? 1 : 0;
3789
void Field_timestamp::sort_string(uchar *to,uint length __attribute__((unused)))
3791
#ifdef WORDS_BIGENDIAN
3792
if (!table || !table->s->db_low_byte_first)
3810
void Field_timestamp::sql_type(String &res) const
3812
res.set_ascii(STRING_WITH_LEN("timestamp"));
3816
void Field_timestamp::set_time()
3818
THD *thd= table ? table->in_use : current_thd;
3819
long tmp= (long) thd->query_start();
3821
store_timestamp(tmp);
3824
/****************************************************************************
3826
** In string context: HH:MM:SS
3827
** In number context: HHMMSS
3828
** Stored as a 3 byte unsigned int
3829
****************************************************************************/
3831
int Field_time::store(const char *from,
3833
CHARSET_INFO *cs __attribute__((__unused__)))
3840
if (str_to_time(from, len, <ime, &warning))
3844
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
3845
from, len, MYSQL_TIMESTAMP_TIME, 1);
3849
if (warning & MYSQL_TIME_WARN_TRUNCATED)
3851
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3852
WARN_DATA_TRUNCATED,
3853
from, len, MYSQL_TIMESTAMP_TIME, 1);
3856
if (warning & MYSQL_TIME_WARN_OUT_OF_RANGE)
3858
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3859
ER_WARN_DATA_OUT_OF_RANGE,
3860
from, len, MYSQL_TIMESTAMP_TIME, !error);
3865
tmp=(ltime.day*24L+ltime.hour)*10000L+(ltime.minute*100+ltime.second);
3875
int Field_time::store_time(MYSQL_TIME *ltime,
3876
timestamp_type time_type __attribute__((__unused__)))
3878
long tmp= ((ltime->month ? 0 : ltime->day * 24L) + ltime->hour) * 10000L +
3879
(ltime->minute * 100 + ltime->second);
3882
return Field_time::store((int64_t) tmp, false);
3886
int Field_time::store(double nr)
3890
if (nr > (double)TIME_MAX_VALUE)
3892
tmp= TIME_MAX_VALUE;
3893
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3894
ER_WARN_DATA_OUT_OF_RANGE, nr, MYSQL_TIMESTAMP_TIME);
3897
else if (nr < (double)-TIME_MAX_VALUE)
3899
tmp= -TIME_MAX_VALUE;
3900
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3901
ER_WARN_DATA_OUT_OF_RANGE, nr, MYSQL_TIMESTAMP_TIME);
3906
tmp=(long) floor(fabs(nr)); // Remove fractions
3909
if (tmp % 100 > 59 || tmp/100 % 100 > 59)
3912
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3913
ER_WARN_DATA_OUT_OF_RANGE, nr,
3914
MYSQL_TIMESTAMP_TIME);
3923
int Field_time::store(int64_t nr, bool unsigned_val)
3927
if (nr < (int64_t) -TIME_MAX_VALUE && !unsigned_val)
3929
tmp= -TIME_MAX_VALUE;
3930
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3931
ER_WARN_DATA_OUT_OF_RANGE, nr,
3932
MYSQL_TIMESTAMP_TIME, 1);
3935
else if (nr > (int64_t) TIME_MAX_VALUE || (nr < 0 && unsigned_val))
3937
tmp= TIME_MAX_VALUE;
3938
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3939
ER_WARN_DATA_OUT_OF_RANGE, nr,
3940
MYSQL_TIMESTAMP_TIME, 1);
3946
if (tmp % 100 > 59 || tmp/100 % 100 > 59)
3949
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3950
ER_WARN_DATA_OUT_OF_RANGE, nr,
3951
MYSQL_TIMESTAMP_TIME, 1);
3960
double Field_time::val_real(void)
3962
uint32 j= (uint32) uint3korr(ptr);
3966
int64_t Field_time::val_int(void)
3968
return (int64_t) sint3korr(ptr);
3974
This function is multi-byte safe as the result string is always of type
3978
String *Field_time::val_str(String *val_buffer,
3979
String *val_ptr __attribute__((unused)))
3982
val_buffer->alloc(MAX_DATE_STRING_REP_LENGTH);
3983
long tmp=(long) sint3korr(ptr);
3990
ltime.day= (uint) 0;
3991
ltime.hour= (uint) (tmp/10000);
3992
ltime.minute= (uint) (tmp/100 % 100);
3993
ltime.second= (uint) (tmp % 100);
3994
make_time((DATE_TIME_FORMAT*) 0, <ime, val_buffer);
4001
Normally we would not consider 'time' as a valid date, but we allow
4002
get_date() here to be able to do things like
4003
DATE_FORMAT(time, "%l.%i %p")
4006
bool Field_time::get_date(MYSQL_TIME *ltime, uint fuzzydate)
4009
THD *thd= table ? table->in_use : current_thd;
4010
if (!(fuzzydate & TIME_FUZZY_DATE))
4012
push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
4013
ER_WARN_DATA_OUT_OF_RANGE,
4014
ER(ER_WARN_DATA_OUT_OF_RANGE), field_name,
4018
tmp=(long) sint3korr(ptr);
4025
ltime->hour=tmp/10000;
4026
tmp-=ltime->hour*10000;
4027
ltime->minute= tmp/100;
4028
ltime->second= tmp % 100;
4029
ltime->year= ltime->month= ltime->day= ltime->second_part= 0;
4034
bool Field_time::get_time(MYSQL_TIME *ltime)
4036
long tmp=(long) sint3korr(ptr);
4044
ltime->hour= (int) (tmp/10000);
4045
tmp-=ltime->hour*10000;
4046
ltime->minute= (int) tmp/100;
4047
ltime->second= (int) tmp % 100;
4048
ltime->second_part=0;
4049
ltime->time_type= MYSQL_TIMESTAMP_TIME;
4054
bool Field_time::send_binary(Protocol *protocol)
4057
Field_time::get_time(&tm);
4058
tm.day= tm.hour/24; // Move hours to days
4059
tm.hour-= tm.day*24;
4060
return protocol->store_time(&tm);
4064
int Field_time::cmp(const uchar *a_ptr, const uchar *b_ptr)
4067
a=(int32) sint3korr(a_ptr);
4068
b=(int32) sint3korr(b_ptr);
4069
return (a < b) ? -1 : (a > b) ? 1 : 0;
4072
void Field_time::sort_string(uchar *to,uint length __attribute__((unused)))
4074
to[0] = (uchar) (ptr[2] ^ 128);
4079
void Field_time::sql_type(String &res) const
4081
res.set_ascii(STRING_WITH_LEN("time"));
4084
/****************************************************************************
4086
** Save in a byte the year 0, 1901->2155
4087
** Can handle 2 byte or 4 byte years!
4088
****************************************************************************/
4090
int Field_year::store(const char *from, uint len,CHARSET_INFO *cs)
4094
int64_t nr= cs->cset->strntoull10rnd(cs, from, len, 0, &end, &error);
4096
if (nr < 0 || (nr >= 100 && nr <= 1900) || nr > 2155 ||
4097
error == MY_ERRNO_ERANGE)
4100
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
4103
if (table->in_use->count_cuted_fields &&
4104
(error= check_int(cs, from, len, end, error)))
4106
if (error == 1) /* empty or incorrect string */
4114
if (nr != 0 || len != 4)
4116
if (nr < YY_PART_YEAR)
4117
nr+=100; // 2000 - 2069
4121
*ptr= (char) (uchar) nr;
4126
int Field_year::store(double nr)
4128
if (nr < 0.0 || nr >= 2155.0)
4130
(void) Field_year::store((int64_t) -1, false);
4133
return Field_year::store((int64_t) nr, false);
4137
int Field_year::store(int64_t nr,
4138
bool unsigned_val __attribute__((__unused__)))
4140
if (nr < 0 || (nr >= 100 && nr <= 1900) || nr > 2155)
4143
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
4146
if (nr != 0 || field_length != 4) // 0000 -> 0; 00 -> 2000
4148
if (nr < YY_PART_YEAR)
4149
nr+=100; // 2000 - 2069
4153
*ptr= (char) (uchar) nr;
4158
bool Field_year::send_binary(Protocol *protocol)
4160
uint64_t tmp= Field_year::val_int();
4161
return protocol->store_short(tmp);
4165
double Field_year::val_real(void)
4167
return (double) Field_year::val_int();
4171
int64_t Field_year::val_int(void)
4173
int tmp= (int) ptr[0];
4174
if (field_length != 4)
4175
tmp%=100; // Return last 2 char
4178
return (int64_t) tmp;
4182
String *Field_year::val_str(String *val_buffer,
4183
String *val_ptr __attribute__((unused)))
4185
val_buffer->alloc(5);
4186
val_buffer->length(field_length);
4187
char *to=(char*) val_buffer->ptr();
4188
sprintf(to,field_length == 2 ? "%02d" : "%04d",(int) Field_year::val_int());
4193
void Field_year::sql_type(String &res) const
4195
CHARSET_INFO *cs=res.charset();
4196
res.length(cs->cset->snprintf(cs,(char*)res.ptr(),res.alloced_length(),
4197
"year(%d)",(int) field_length));
4201
/****************************************************************************
4202
** The new date type
4203
** This is identical to the old date type, but stored on 3 bytes instead of 4
4204
** In number context: YYYYMMDD
4205
****************************************************************************/
4208
Store string into a date field
4211
Field_newdate::store()
4213
len Length of date field
4214
cs Character set (not used)
4218
1 Value was cut during conversion
4220
3 Datetime value that was cut (warning level NOTE)
4221
This is used by opt_range.cc:get_mm_leaf(). Note that there is a
4222
nearly-identical class Field_date doesn't ever return 3 from its
4226
int Field_newdate::store(const char *from,
4228
CHARSET_INFO *cs __attribute__((__unused__)))
4233
THD *thd= table ? table->in_use : current_thd;
4234
enum enum_mysql_timestamp_type ret;
4235
if ((ret= str_to_datetime(from, len, &l_time,
4237
(thd->variables.sql_mode &
4238
(MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
4239
MODE_INVALID_DATES))),
4240
&error)) <= MYSQL_TIMESTAMP_ERROR)
4247
tmp= l_time.day + l_time.month*32 + l_time.year*16*32;
4248
if (!error && (ret != MYSQL_TIMESTAMP_DATE) &&
4249
(l_time.hour || l_time.minute || l_time.second || l_time.second_part))
4250
error= 3; // Datetime was cut (note)
4254
set_datetime_warning(error == 3 ? MYSQL_ERROR::WARN_LEVEL_NOTE :
4255
MYSQL_ERROR::WARN_LEVEL_WARN,
4256
WARN_DATA_TRUNCATED,
4257
from, len, MYSQL_TIMESTAMP_DATE, 1);
4259
int3store(ptr, tmp);
4264
int Field_newdate::store(double nr)
4266
if (nr < 0.0 || nr > 99991231235959.0)
4268
int3store(ptr,(int32) 0);
4269
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4270
WARN_DATA_TRUNCATED, nr, MYSQL_TIMESTAMP_DATE);
4273
return Field_newdate::store((int64_t) rint(nr), false);
4277
int Field_newdate::store(int64_t nr,
4278
bool unsigned_val __attribute__((__unused__)))
4283
THD *thd= table ? table->in_use : current_thd;
4284
if (number_to_datetime(nr, &l_time,
4286
(thd->variables.sql_mode &
4287
(MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
4288
MODE_INVALID_DATES))),
4295
tmp= l_time.day + l_time.month*32 + l_time.year*16*32;
4297
if (!error && l_time.time_type != MYSQL_TIMESTAMP_DATE &&
4298
(l_time.hour || l_time.minute || l_time.second || l_time.second_part))
4302
set_datetime_warning(error == 3 ? MYSQL_ERROR::WARN_LEVEL_NOTE :
4303
MYSQL_ERROR::WARN_LEVEL_WARN,
4305
ER_WARN_DATA_OUT_OF_RANGE : WARN_DATA_TRUNCATED,
4306
nr,MYSQL_TIMESTAMP_DATE, 1);
4313
int Field_newdate::store_time(MYSQL_TIME *ltime,timestamp_type time_type)
4317
if (time_type == MYSQL_TIMESTAMP_DATE ||
4318
time_type == MYSQL_TIMESTAMP_DATETIME)
4320
tmp=ltime->year*16*32+ltime->month*32+ltime->day;
4321
if (check_date(ltime, tmp != 0,
4323
(current_thd->variables.sql_mode &
4324
(MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
4325
MODE_INVALID_DATES))), &error))
4327
char buff[MAX_DATE_STRING_REP_LENGTH];
4328
String str(buff, sizeof(buff), &my_charset_latin1);
4329
make_date((DATE_TIME_FORMAT *) 0, ltime, &str);
4330
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
4331
str.ptr(), str.length(), MYSQL_TIMESTAMP_DATE, 1);
4333
if (!error && ltime->time_type != MYSQL_TIMESTAMP_DATE &&
4334
(ltime->hour || ltime->minute || ltime->second || ltime->second_part))
4336
char buff[MAX_DATE_STRING_REP_LENGTH];
4337
String str(buff, sizeof(buff), &my_charset_latin1);
4338
make_datetime((DATE_TIME_FORMAT *) 0, ltime, &str);
4339
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_NOTE,
4340
WARN_DATA_TRUNCATED,
4341
str.ptr(), str.length(), MYSQL_TIMESTAMP_DATE, 1);
4349
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
4356
bool Field_newdate::send_binary(Protocol *protocol)
4359
Field_newdate::get_date(&tm,0);
4360
return protocol->store_date(&tm);
4364
double Field_newdate::val_real(void)
4366
return (double) Field_newdate::val_int();
4370
int64_t Field_newdate::val_int(void)
4372
ulong j= uint3korr(ptr);
4373
j= (j % 32L)+(j / 32L % 16L)*100L + (j/(16L*32L))*10000L;
4378
String *Field_newdate::val_str(String *val_buffer,
4379
String *val_ptr __attribute__((unused)))
4381
val_buffer->alloc(field_length);
4382
val_buffer->length(field_length);
4383
uint32 tmp=(uint32) uint3korr(ptr);
4385
char *pos=(char*) val_buffer->ptr()+10;
4387
/* Open coded to get more speed */
4388
*pos--=0; // End NULL
4389
part=(int) (tmp & 31);
4390
*pos--= (char) ('0'+part%10);
4391
*pos--= (char) ('0'+part/10);
4393
part=(int) (tmp >> 5 & 15);
4394
*pos--= (char) ('0'+part%10);
4395
*pos--= (char) ('0'+part/10);
4397
part=(int) (tmp >> 9);
4398
*pos--= (char) ('0'+part%10); part/=10;
4399
*pos--= (char) ('0'+part%10); part/=10;
4400
*pos--= (char) ('0'+part%10); part/=10;
4401
*pos= (char) ('0'+part);
4406
bool Field_newdate::get_date(MYSQL_TIME *ltime,uint fuzzydate)
4408
uint32 tmp=(uint32) uint3korr(ptr);
4409
ltime->day= tmp & 31;
4410
ltime->month= (tmp >> 5) & 15;
4411
ltime->year= (tmp >> 9);
4412
ltime->time_type= MYSQL_TIMESTAMP_DATE;
4413
ltime->hour= ltime->minute= ltime->second= ltime->second_part= ltime->neg= 0;
4414
return ((!(fuzzydate & TIME_FUZZY_DATE) && (!ltime->month || !ltime->day)) ?
4419
bool Field_newdate::get_time(MYSQL_TIME *ltime)
4421
return Field_newdate::get_date(ltime,0);
4425
int Field_newdate::cmp(const uchar *a_ptr, const uchar *b_ptr)
4428
a=(uint32) uint3korr(a_ptr);
4429
b=(uint32) uint3korr(b_ptr);
4430
return (a < b) ? -1 : (a > b) ? 1 : 0;
4434
void Field_newdate::sort_string(uchar *to,uint length __attribute__((unused)))
4442
void Field_newdate::sql_type(String &res) const
4444
res.set_ascii(STRING_WITH_LEN("date"));
4448
/****************************************************************************
4450
** In string context: YYYY-MM-DD HH:MM:DD
4451
** In number context: YYYYMMDDHHMMDD
4452
** Stored as a 8 byte unsigned int. Should sometimes be change to a 6 byte int.
4453
****************************************************************************/
4455
int Field_datetime::store(const char *from,
4457
CHARSET_INFO *cs __attribute__((__unused__)))
4459
MYSQL_TIME time_tmp;
4462
enum enum_mysql_timestamp_type func_res;
4463
THD *thd= table ? table->in_use : current_thd;
4465
func_res= str_to_datetime(from, len, &time_tmp,
4467
(thd->variables.sql_mode &
4468
(MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
4469
MODE_INVALID_DATES))),
4471
if ((int) func_res > (int) MYSQL_TIMESTAMP_ERROR)
4472
tmp= TIME_to_uint64_t_datetime(&time_tmp);
4474
error= 1; // Fix if invalid zero date
4477
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4478
ER_WARN_DATA_OUT_OF_RANGE,
4479
from, len, MYSQL_TIMESTAMP_DATETIME, 1);
4481
#ifdef WORDS_BIGENDIAN
4482
if (table && table->s->db_low_byte_first)
4488
int64_tstore(ptr,tmp);
4493
int Field_datetime::store(double nr)
4496
if (nr < 0.0 || nr > 99991231235959.0)
4498
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4499
ER_WARN_DATA_OUT_OF_RANGE,
4500
nr, MYSQL_TIMESTAMP_DATETIME);
4504
error|= Field_datetime::store((int64_t) rint(nr), false);
4509
int Field_datetime::store(int64_t nr,
4510
bool unsigned_val __attribute__((__unused__)))
4512
MYSQL_TIME not_used;
4514
int64_t initial_nr= nr;
4515
THD *thd= table ? table->in_use : current_thd;
4517
nr= number_to_datetime(nr, ¬_used, (TIME_FUZZY_DATE |
4518
(thd->variables.sql_mode &
4519
(MODE_NO_ZERO_IN_DATE |
4521
MODE_INVALID_DATES))), &error);
4530
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4531
error == 2 ? ER_WARN_DATA_OUT_OF_RANGE :
4532
WARN_DATA_TRUNCATED, initial_nr,
4533
MYSQL_TIMESTAMP_DATETIME, 1);
4535
#ifdef WORDS_BIGENDIAN
4536
if (table && table->s->db_low_byte_first)
4542
int64_tstore(ptr,nr);
4547
int Field_datetime::store_time(MYSQL_TIME *ltime,timestamp_type time_type)
4552
We don't perform range checking here since values stored in TIME
4553
structure always fit into DATETIME range.
4555
if (time_type == MYSQL_TIMESTAMP_DATE ||
4556
time_type == MYSQL_TIMESTAMP_DATETIME)
4558
tmp=((ltime->year*10000L+ltime->month*100+ltime->day)*1000000LL+
4559
(ltime->hour*10000L+ltime->minute*100+ltime->second));
4560
if (check_date(ltime, tmp != 0,
4562
(current_thd->variables.sql_mode &
4563
(MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
4564
MODE_INVALID_DATES))), &error))
4566
char buff[MAX_DATE_STRING_REP_LENGTH];
4567
String str(buff, sizeof(buff), &my_charset_latin1);
4568
make_datetime((DATE_TIME_FORMAT *) 0, ltime, &str);
4569
set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
4570
str.ptr(), str.length(), MYSQL_TIMESTAMP_DATETIME,1);
4577
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
4579
#ifdef WORDS_BIGENDIAN
4580
if (table && table->s->db_low_byte_first)
4586
int64_tstore(ptr,tmp);
4590
bool Field_datetime::send_binary(Protocol *protocol)
4593
Field_datetime::get_date(&tm, TIME_FUZZY_DATE);
4594
return protocol->store(&tm);
4598
double Field_datetime::val_real(void)
4600
return (double) Field_datetime::val_int();
4603
int64_t Field_datetime::val_int(void)
4606
#ifdef WORDS_BIGENDIAN
4607
if (table && table->s->db_low_byte_first)
4616
String *Field_datetime::val_str(String *val_buffer,
4617
String *val_ptr __attribute__((unused)))
4619
val_buffer->alloc(field_length);
4620
val_buffer->length(field_length);
4626
#ifdef WORDS_BIGENDIAN
4627
if (table && table->s->db_low_byte_first)
4631
int64_tget(tmp,ptr);
4634
Avoid problem with slow int64_t arithmetic and sprintf
4637
part1=(long) (tmp/1000000LL);
4638
part2=(long) (tmp - (uint64_t) part1*1000000LL);
4640
pos=(char*) val_buffer->ptr() + MAX_DATETIME_WIDTH;
4642
*pos--= (char) ('0'+(char) (part2%10)); part2/=10;
4643
*pos--= (char) ('0'+(char) (part2%10)); part3= (int) (part2 / 10);
4645
*pos--= (char) ('0'+(char) (part3%10)); part3/=10;
4646
*pos--= (char) ('0'+(char) (part3%10)); part3/=10;
4648
*pos--= (char) ('0'+(char) (part3%10)); part3/=10;
4649
*pos--= (char) ('0'+(char) part3);
4651
*pos--= (char) ('0'+(char) (part1%10)); part1/=10;
4652
*pos--= (char) ('0'+(char) (part1%10)); part1/=10;
4654
*pos--= (char) ('0'+(char) (part1%10)); part1/=10;
4655
*pos--= (char) ('0'+(char) (part1%10)); part3= (int) (part1/10);
4657
*pos--= (char) ('0'+(char) (part3%10)); part3/=10;
4658
*pos--= (char) ('0'+(char) (part3%10)); part3/=10;
4659
*pos--= (char) ('0'+(char) (part3%10)); part3/=10;
4660
*pos=(char) ('0'+(char) part3);
4664
bool Field_datetime::get_date(MYSQL_TIME *ltime, uint fuzzydate)
4666
int64_t tmp=Field_datetime::val_int();
4668
part1=(uint32) (tmp/1000000LL);
4669
part2=(uint32) (tmp - (uint64_t) part1*1000000LL);
4671
ltime->time_type= MYSQL_TIMESTAMP_DATETIME;
4673
ltime->second_part= 0;
4674
ltime->second= (int) (part2%100);
4675
ltime->minute= (int) (part2/100%100);
4676
ltime->hour= (int) (part2/10000);
4677
ltime->day= (int) (part1%100);
4678
ltime->month= (int) (part1/100%100);
4679
ltime->year= (int) (part1/10000);
4680
return (!(fuzzydate & TIME_FUZZY_DATE) && (!ltime->month || !ltime->day)) ? 1 : 0;
4683
bool Field_datetime::get_time(MYSQL_TIME *ltime)
4685
return Field_datetime::get_date(ltime,0);
4688
int Field_datetime::cmp(const uchar *a_ptr, const uchar *b_ptr)
4691
#ifdef WORDS_BIGENDIAN
4692
if (table && table->s->db_low_byte_first)
4700
int64_tget(a,a_ptr);
4701
int64_tget(b,b_ptr);
4703
return ((uint64_t) a < (uint64_t) b) ? -1 :
4704
((uint64_t) a > (uint64_t) b) ? 1 : 0;
4707
void Field_datetime::sort_string(uchar *to,uint length __attribute__((unused)))
4709
#ifdef WORDS_BIGENDIAN
4710
if (!table || !table->s->db_low_byte_first)
4736
void Field_datetime::sql_type(String &res) const
4738
res.set_ascii(STRING_WITH_LEN("datetime"));
4741
/****************************************************************************
4743
** A string may be varchar or binary
4744
****************************************************************************/
1168
4747
Report "not well formed" or "cannot convert" error
1242
4821
push_warning_printf(field->table->in_use,
1243
4822
field->table->in_use->abort_on_warning ?
1244
DRIZZLE_ERROR::WARN_LEVEL_ERROR :
1245
DRIZZLE_ERROR::WARN_LEVEL_WARN,
4823
MYSQL_ERROR::WARN_LEVEL_ERROR :
4824
MYSQL_ERROR::WARN_LEVEL_WARN,
1246
4825
ER_TRUNCATED_WRONG_VALUE_FOR_FIELD,
1247
4826
ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
1248
4827
"string", tmp, field->field_name,
1249
(uint32_t) field->table->in_use->row_count);
4828
(ulong) field->table->in_use->row_count);
1253
uint32_t Field::is_equal(Create_field *new_field)
4834
Check if we lost any important data and send a truncation error/warning
4837
Field_longstr::report_if_important_data()
4838
ptr - Truncated rest of string
4839
end - End of truncated string
4842
0 - None was truncated (or we don't count cut fields)
4843
2 - Some bytes was truncated
4846
Check if we lost any important data (anything in a binary string,
4847
or any non-space in others). If only trailing spaces was lost,
4848
send a truncation note, otherwise send a truncation error.
4852
Field_longstr::report_if_important_data(const char *ptr, const char *end)
4854
if ((ptr < end) && table->in_use->count_cuted_fields)
4856
if (test_if_important_data(field_charset, ptr, end))
4858
if (table->in_use->abort_on_warning)
4859
set_warning(MYSQL_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
4861
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
4863
else /* If we lost only spaces then produce a NOTE, not a WARNING */
4864
set_warning(MYSQL_ERROR::WARN_LEVEL_NOTE, WARN_DATA_TRUNCATED, 1);
4871
/* Copy a string and fill with space */
4873
int Field_string::store(const char *from,uint length,CHARSET_INFO *cs)
4876
const char *well_formed_error_pos;
4877
const char *cannot_convert_error_pos;
4878
const char *from_end_pos;
4880
/* See the comment for Field_long::store(long long) */
4881
assert(table->in_use == current_thd);
4883
copy_length= well_formed_copy_nchars(field_charset,
4884
(char*) ptr, field_length,
4886
field_length / field_charset->mbmaxlen,
4887
&well_formed_error_pos,
4888
&cannot_convert_error_pos,
4891
/* Append spaces if the string was shorter than the field. */
4892
if (copy_length < field_length)
4893
field_charset->cset->fill(field_charset,(char*) ptr+copy_length,
4894
field_length-copy_length,
4895
field_charset->pad_char);
4897
if (check_string_copy_error(this, well_formed_error_pos,
4898
cannot_convert_error_pos, from + length, cs))
4901
return report_if_important_data(from_end_pos, from + length);
4906
Store double value in Field_string or Field_varstring.
4908
Pretty prints double number into field_length characters buffer.
4913
int Field_str::store(double nr)
4915
char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
4916
uint local_char_length= field_length / charset()->mbmaxlen;
4920
length= my_gcvt(nr, MY_GCVT_ARG_DOUBLE, local_char_length, buff, &error);
4923
if (table->in_use->abort_on_warning)
4924
set_warning(MYSQL_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
4926
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
4928
return store(buff, length, charset());
4932
uint Field::is_equal(Create_field *new_field)
1255
4934
return (new_field->sql_type == real_type());
4938
/* If one of the fields is binary and the other one isn't return 1 else 0 */
4940
bool Field_str::compare_str_field_flags(Create_field *new_field, uint32 flag_arg)
4942
return (((new_field->flags & (BINCMP_FLAG | BINARY_FLAG)) &&
4943
!(flag_arg & (BINCMP_FLAG | BINARY_FLAG))) ||
4944
(!(new_field->flags & (BINCMP_FLAG | BINARY_FLAG)) &&
4945
(flag_arg & (BINCMP_FLAG | BINARY_FLAG))));
4949
uint Field_str::is_equal(Create_field *new_field)
4951
if (compare_str_field_flags(new_field, flags))
4954
return ((new_field->sql_type == real_type()) &&
4955
new_field->charset == field_charset &&
4956
new_field->length == max_display_length());
4960
int Field_string::store(int64_t nr, bool unsigned_val)
4964
CHARSET_INFO *cs=charset();
4965
l= (cs->cset->int64_t10_to_str)(cs,buff,sizeof(buff),
4966
unsigned_val ? 10 : -10, nr);
4967
return Field_string::store(buff,(uint)l,cs);
4971
int Field_longstr::store_decimal(const my_decimal *d)
4973
char buff[DECIMAL_MAX_STR_LENGTH+1];
4974
String str(buff, sizeof(buff), &my_charset_bin);
4975
my_decimal2string(E_DEC_FATAL_ERROR, d, 0, 0, 0, &str);
4976
return store(str.ptr(), str.length(), str.charset());
4979
uint32 Field_longstr::max_data_length() const
4981
return field_length + (field_length > 255 ? 2 : 1);
4985
double Field_string::val_real(void)
4989
CHARSET_INFO *cs= charset();
4992
result= my_strntod(cs,(char*) ptr,field_length,&end,&error);
4993
if (!table->in_use->no_errors &&
4994
(error || (field_length != (uint32)(end - (char*) ptr) &&
4995
!check_if_only_end_space(cs, end,
4996
(char*) ptr + field_length))))
4998
char buf[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
4999
String tmp(buf, sizeof(buf), cs);
5000
tmp.copy((char*) ptr, field_length, cs);
5001
push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
5002
ER_TRUNCATED_WRONG_VALUE,
5003
ER(ER_TRUNCATED_WRONG_VALUE),
5004
"DOUBLE", tmp.c_ptr());
5010
int64_t Field_string::val_int(void)
5014
CHARSET_INFO *cs= charset();
5017
result= my_strntoll(cs, (char*) ptr,field_length,10,&end,&error);
5018
if (!table->in_use->no_errors &&
5019
(error || (field_length != (uint32)(end - (char*) ptr) &&
5020
!check_if_only_end_space(cs, end,
5021
(char*) ptr + field_length))))
5023
char buf[LONGLONG_TO_STRING_CONVERSION_BUFFER_SIZE];
5024
String tmp(buf, sizeof(buf), cs);
5025
tmp.copy((char*) ptr, field_length, cs);
5026
push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
5027
ER_TRUNCATED_WRONG_VALUE,
5028
ER(ER_TRUNCATED_WRONG_VALUE),
5029
"INTEGER", tmp.c_ptr());
5035
String *Field_string::val_str(String *val_buffer __attribute__((unused)),
5038
/* See the comment for Field_long::store(long long) */
5039
assert(table->in_use == current_thd);
5041
if (table->in_use->variables.sql_mode &
5042
MODE_PAD_CHAR_TO_FULL_LENGTH)
5043
length= my_charpos(field_charset, ptr, ptr + field_length, field_length);
5045
length= field_charset->cset->lengthsp(field_charset, (const char*) ptr,
5047
val_ptr->set((const char*) ptr, length, field_charset);
5052
my_decimal *Field_string::val_decimal(my_decimal *decimal_value)
5054
int err= str2my_decimal(E_DEC_FATAL_ERROR, (char*) ptr, field_length,
5055
charset(), decimal_value);
5056
if (!table->in_use->no_errors && err)
5058
char buf[DECIMAL_TO_STRING_CONVERSION_BUFFER_SIZE];
5059
CHARSET_INFO *cs= charset();
5060
String tmp(buf, sizeof(buf), cs);
5061
tmp.copy((char*) ptr, field_length, cs);
5062
push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
5063
ER_TRUNCATED_WRONG_VALUE,
5064
ER(ER_TRUNCATED_WRONG_VALUE),
5065
"DECIMAL", tmp.c_ptr());
5068
return decimal_value;
5072
int Field_string::cmp(const uchar *a_ptr, const uchar *b_ptr)
5076
if (field_charset->mbmaxlen != 1)
5078
uint char_len= field_length/field_charset->mbmaxlen;
5079
a_len= my_charpos(field_charset, a_ptr, a_ptr + field_length, char_len);
5080
b_len= my_charpos(field_charset, b_ptr, b_ptr + field_length, char_len);
5083
a_len= b_len= field_length;
5085
We have to remove end space to be able to compare multi-byte-characters
5086
like in latin_de 'ae' and 0xe4
5088
return field_charset->coll->strnncollsp(field_charset,
5095
void Field_string::sort_string(uchar *to,uint length)
5097
uint tmp= my_strnxfrm(field_charset,
5100
assert(tmp == length);
5104
void Field_string::sql_type(String &res) const
5106
THD *thd= table->in_use;
5107
CHARSET_INFO *cs=res.charset();
5110
length= cs->cset->snprintf(cs,(char*) res.ptr(),
5111
res.alloced_length(), "%s(%d)",
5112
((type() == MYSQL_TYPE_VAR_STRING &&
5113
!thd->variables.new_mode) ?
5114
(has_charset() ? "varchar" : "varbinary") :
5115
(has_charset() ? "char" : "binary")),
5116
(int) field_length / charset()->mbmaxlen);
5118
if ((thd->variables.sql_mode & (MODE_MYSQL323 | MODE_MYSQL40)) &&
5119
has_charset() && (charset()->state & MY_CS_BINSORT))
5120
res.append(STRING_WITH_LEN(" binary"));
5124
uchar *Field_string::pack(uchar *to, const uchar *from,
5126
bool low_byte_first __attribute__((unused)))
5128
uint length= min(field_length,max_length);
5129
uint local_char_length= max_length/field_charset->mbmaxlen;
5130
if (length > local_char_length)
5131
local_char_length= my_charpos(field_charset, from, from+length,
5133
set_if_smaller(length, local_char_length);
5134
while (length && from[length-1] == field_charset->pad_char)
5137
// Length always stored little-endian
5138
*to++= (uchar) length;
5139
if (field_length > 255)
5140
*to++= (uchar) (length >> 8);
5142
// Store the actual bytes of the string
5143
memcpy(to, from, length);
5149
Unpack a string field from row data.
5151
This method is used to unpack a string field from a master whose size
5152
of the field is less than that of the slave. Note that there can be a
5153
variety of field types represented with this class. Certain types like
5154
ENUM or SET are processed differently. Hence, the upper byte of the
5155
@c param_data argument contains the result of field->real_type() from
5158
@param to Destination of the data
5159
@param from Source of the data
5160
@param param_data Real type (upper) and length (lower) values
5162
@return New pointer into memory based on from + length of the data
5165
Field_string::unpack(uchar *to,
5168
bool low_byte_first __attribute__((unused)))
5171
param_data ? min(param_data & 0x00ff, field_length) : field_length;
5174
if (from_length > 255)
5176
length= uint2korr(from);
5180
length= (uint) *from++;
5182
memcpy(to, from, length);
5183
// Pad the string with the pad character of the fields charset
5184
bfill(to + length, field_length - length, field_charset->pad_char);
5190
Save the field metadata for string fields.
5192
Saves the real type in the first byte and the field length in the
5193
second byte of the field metadata array at index of *metadata_ptr and
5194
*(metadata_ptr + 1).
5196
@param metadata_ptr First byte of field metadata
5198
@returns number of bytes written to metadata_ptr
5200
int Field_string::do_save_field_metadata(uchar *metadata_ptr)
5202
*metadata_ptr= real_type();
5203
*(metadata_ptr + 1)= field_length;
5209
Compare two packed keys
5216
insert_or_update 1 if this is an insert or update
5224
int Field_string::pack_cmp(const uchar *a, const uchar *b, uint length,
5225
my_bool insert_or_update)
5227
uint a_length, b_length;
5230
a_length= uint2korr(a);
5231
b_length= uint2korr(b);
5237
a_length= (uint) *a++;
5238
b_length= (uint) *b++;
5240
return field_charset->coll->strnncollsp(field_charset,
5248
Compare a packed key against row.
5250
@param key Original key
5251
@param length Key length. (May be less than field length)
5252
@param insert_or_update 1 if this is an insert or update
5262
int Field_string::pack_cmp(const uchar *key, uint length,
5263
my_bool insert_or_update)
5265
uint row_length, local_key_length;
5269
local_key_length= uint2korr(key);
5273
local_key_length= (uint) *key++;
5275
/* Only use 'length' of key, not field_length */
5277
while (end > ptr && end[-1] == ' ')
5279
row_length= (uint) (end - ptr);
5281
return field_charset->coll->strnncollsp(field_charset,
5283
key, local_key_length,
5288
uint Field_string::packed_col_length(const uchar *data_ptr, uint length)
5291
return uint2korr(data_ptr)+2;
5292
return (uint) *data_ptr + 1;
5296
uint Field_string::max_packed_col_length(uint max_length)
5298
return (max_length > 255 ? 2 : 1)+max_length;
5302
uint Field_string::get_key_image(uchar *buff,
5304
imagetype type_arg __attribute__((__unused__)))
5306
uint bytes = my_charpos(field_charset, (char*) ptr,
5307
(char*) ptr + field_length,
5308
length / field_charset->mbmaxlen);
5309
memcpy(buff, ptr, bytes);
5311
field_charset->cset->fill(field_charset, (char*) buff + bytes,
5312
length - bytes, field_charset->pad_char);
5317
Field *Field_string::new_field(MEM_ROOT *root, struct st_table *new_table,
5321
if (type() != MYSQL_TYPE_VAR_STRING || keep_type)
5322
field= Field::new_field(root, new_table, keep_type);
5323
else if ((field= new Field_varstring(field_length, maybe_null(), field_name,
5324
new_table->s, charset())))
5327
Old VARCHAR field which should be modified to a VARCHAR on copy
5328
This is done to ensure that ALTER TABLE will convert old VARCHAR fields
5329
to now VARCHAR fields.
5331
field->init(new_table);
5333
Normally orig_table is different from table only if field was created
5334
via ::new_field. Here we alter the type of field, so ::new_field is
5335
not applicable. But we still need to preserve the original field
5336
metadata for the client-server protocol.
5338
field->orig_table= orig_table;
5344
/****************************************************************************
5346
Data in field->ptr is stored as:
5347
1 or 2 bytes length-prefix-header (from Field_varstring::length_bytes)
5351
When VARCHAR is stored in a key (for handler::index_read() etc) it's always
5352
stored with a 2 byte prefix. (Just like blob keys).
5354
Normally length_bytes is calculated as (field_length < 256 : 1 ? 2)
5355
The exception is if there is a prefix key field that is part of a long
5356
VARCHAR, in which case field_length for this may be 1 but the length_bytes
5358
****************************************************************************/
5360
const uint Field_varstring::MAX_SIZE= UINT_MAX16;
5363
Save the field metadata for varstring fields.
5365
Saves the field length in the first byte. Note: may consume
5366
2 bytes. Caller must ensure second byte is contiguous with
5367
first byte (e.g. array index 0,1).
5369
@param metadata_ptr First byte of field metadata
5371
@returns number of bytes written to metadata_ptr
5373
int Field_varstring::do_save_field_metadata(uchar *metadata_ptr)
5375
char *ptr= (char *)metadata_ptr;
5376
assert(field_length <= 65535);
5377
int2store(ptr, field_length);
5381
int Field_varstring::store(const char *from,uint length,CHARSET_INFO *cs)
5384
const char *well_formed_error_pos;
5385
const char *cannot_convert_error_pos;
5386
const char *from_end_pos;
5388
copy_length= well_formed_copy_nchars(field_charset,
5389
(char*) ptr + length_bytes,
5392
field_length / field_charset->mbmaxlen,
5393
&well_formed_error_pos,
5394
&cannot_convert_error_pos,
5397
if (length_bytes == 1)
5398
*ptr= (uchar) copy_length;
5400
int2store(ptr, copy_length);
5402
if (check_string_copy_error(this, well_formed_error_pos,
5403
cannot_convert_error_pos, from + length, cs))
5406
return report_if_important_data(from_end_pos, from + length);
5410
int Field_varstring::store(int64_t nr, bool unsigned_val)
5414
length= (uint) (field_charset->cset->int64_t10_to_str)(field_charset,
5420
return Field_varstring::store(buff, length, field_charset);
5424
double Field_varstring::val_real(void)
5428
uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
5429
return my_strntod(field_charset, (char*) ptr+length_bytes, length,
5430
&end_not_used, ¬_used);
5434
int64_t Field_varstring::val_int(void)
5438
uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
5439
return my_strntoll(field_charset, (char*) ptr+length_bytes, length, 10,
5440
&end_not_used, ¬_used);
5443
String *Field_varstring::val_str(String *val_buffer __attribute__((unused)),
5446
uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
5447
val_ptr->set((const char*) ptr+length_bytes, length, field_charset);
5452
my_decimal *Field_varstring::val_decimal(my_decimal *decimal_value)
5454
uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
5455
str2my_decimal(E_DEC_FATAL_ERROR, (char*) ptr+length_bytes, length,
5456
charset(), decimal_value);
5457
return decimal_value;
5461
int Field_varstring::cmp_max(const uchar *a_ptr, const uchar *b_ptr,
5464
uint a_length, b_length;
5467
if (length_bytes == 1)
5469
a_length= (uint) *a_ptr;
5470
b_length= (uint) *b_ptr;
5474
a_length= uint2korr(a_ptr);
5475
b_length= uint2korr(b_ptr);
5477
set_if_smaller(a_length, max_len);
5478
set_if_smaller(b_length, max_len);
5479
diff= field_charset->coll->strnncollsp(field_charset,
5492
varstring and blob keys are ALWAYS stored with a 2 byte length prefix
5495
int Field_varstring::key_cmp(const uchar *key_ptr, uint max_key_length)
5497
uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
5498
uint local_char_length= max_key_length / field_charset->mbmaxlen;
5500
local_char_length= my_charpos(field_charset, ptr + length_bytes,
5501
ptr + length_bytes + length, local_char_length);
5502
set_if_smaller(length, local_char_length);
5503
return field_charset->coll->strnncollsp(field_charset,
5508
uint2korr(key_ptr), 0);
5513
Compare to key segments (always 2 byte length prefix).
5516
This is used only to compare key segments created for index_read().
5517
(keys are created and compared in key.cc)
5520
int Field_varstring::key_cmp(const uchar *a,const uchar *b)
5522
return field_charset->coll->strnncollsp(field_charset,
5523
a + HA_KEY_BLOB_LENGTH,
5525
b + HA_KEY_BLOB_LENGTH,
5531
void Field_varstring::sort_string(uchar *to,uint length)
5533
uint tot_length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
5535
if (field_charset == &my_charset_bin)
5537
/* Store length last in high-byte order to sort longer strings first */
5538
if (length_bytes == 1)
5539
to[length-1]= tot_length;
5541
mi_int2store(to+length-2, tot_length);
5542
length-= length_bytes;
5545
tot_length= my_strnxfrm(field_charset,
5546
to, length, ptr + length_bytes,
5548
assert(tot_length == length);
5552
enum ha_base_keytype Field_varstring::key_type() const
5554
enum ha_base_keytype res;
5557
res= length_bytes == 1 ? HA_KEYTYPE_VARBINARY1 : HA_KEYTYPE_VARBINARY2;
5559
res= length_bytes == 1 ? HA_KEYTYPE_VARTEXT1 : HA_KEYTYPE_VARTEXT2;
5564
void Field_varstring::sql_type(String &res) const
5566
THD *thd= table->in_use;
5567
CHARSET_INFO *cs=res.charset();
5570
length= cs->cset->snprintf(cs,(char*) res.ptr(),
5571
res.alloced_length(), "%s(%d)",
5572
(has_charset() ? "varchar" : "varbinary"),
5573
(int) field_length / charset()->mbmaxlen);
5575
if ((thd->variables.sql_mode & (MODE_MYSQL323 | MODE_MYSQL40)) &&
5576
has_charset() && (charset()->state & MY_CS_BINSORT))
5577
res.append(STRING_WITH_LEN(" binary"));
5581
uint32 Field_varstring::data_length()
5583
return length_bytes == 1 ? (uint32) *ptr : uint2korr(ptr);
5586
uint32 Field_varstring::used_length()
5588
return length_bytes == 1 ? 1 + (uint32) (uchar) *ptr : 2 + uint2korr(ptr);
5592
Functions to create a packed row.
5593
Here the number of length bytes are depending on the given max_length
5596
uchar *Field_varstring::pack(uchar *to, const uchar *from,
5598
bool low_byte_first __attribute__((unused)))
5600
uint length= length_bytes == 1 ? (uint) *from : uint2korr(from);
5601
set_if_smaller(max_length, field_length);
5602
if (length > max_length)
5605
/* Length always stored little-endian */
5606
*to++= length & 0xFF;
5607
if (max_length > 255)
5608
*to++= (length >> 8) & 0xFF;
5610
/* Store bytes of string */
5612
memcpy(to, from+length_bytes, length);
5618
Field_varstring::pack_key(uchar *to, const uchar *key, uint max_length,
5619
bool low_byte_first __attribute__((unused)))
5621
uint length= length_bytes == 1 ? (uint) *key : uint2korr(key);
5622
uint local_char_length= ((field_charset->mbmaxlen > 1) ?
5623
max_length/field_charset->mbmaxlen : max_length);
5625
if (length > local_char_length)
5627
local_char_length= my_charpos(field_charset, key, key+length,
5629
set_if_smaller(length, local_char_length);
5631
*to++= (char) (length & 255);
5632
if (max_length > 255)
5633
*to++= (char) (length >> 8);
5635
memcpy(to, key, length);
5641
Unpack a key into a record buffer.
5643
A VARCHAR key has a maximum size of 64K-1.
5644
In its packed form, the length field is one or two bytes long,
5645
depending on 'max_length'.
5647
@param to Pointer into the record buffer.
5648
@param key Pointer to the packed key.
5649
@param max_length Key length limit from key description.
5652
Pointer to end of 'key' (To the next key part if multi-segment key)
5656
Field_varstring::unpack_key(uchar *to __attribute__((__unused__)),
5657
const uchar *key, uint max_length,
5658
bool low_byte_first __attribute__((unused)))
5660
/* get length of the blob key */
5661
uint32 length= *key++;
5662
if (max_length > 255)
5663
length+= (*key++) << 8;
5665
/* put the length into the record buffer */
5666
if (length_bytes == 1)
5667
*ptr= (uchar) length;
5669
int2store(ptr, length);
5670
memcpy(ptr + length_bytes, key, length);
5671
return key + length;
5675
Create a packed key that will be used for storage in the index tree.
5677
@param to Store packed key segment here
5678
@param from Key segment (as given to index_read())
5679
@param max_length Max length of key
5686
Field_varstring::pack_key_from_key_image(uchar *to, const uchar *from, uint max_length,
5687
bool low_byte_first __attribute__((unused)))
5689
/* Key length is always stored as 2 bytes */
5690
uint length= uint2korr(from);
5691
if (length > max_length)
5693
*to++= (char) (length & 255);
5694
if (max_length > 255)
5695
*to++= (char) (length >> 8);
5697
memcpy(to, from+HA_KEY_BLOB_LENGTH, length);
5703
Unpack a varstring field from row data.
5705
This method is used to unpack a varstring field from a master
5706
whose size of the field is less than that of the slave.
5709
The string length is always packed little-endian.
5711
@param to Destination of the data
5712
@param from Source of the data
5713
@param param_data Length bytes from the master's field data
5715
@return New pointer into memory based on from + length of the data
5718
Field_varstring::unpack(uchar *to, const uchar *from,
5720
bool low_byte_first __attribute__((unused)))
5723
uint l_bytes= (param_data && (param_data < field_length)) ?
5724
(param_data <= 255) ? 1 : 2 : length_bytes;
5729
if (length_bytes == 2)
5732
else /* l_bytes == 2 */
5734
length= uint2korr(from);
5739
memcpy(to+ length_bytes, from, length);
5744
int Field_varstring::pack_cmp(const uchar *a, const uchar *b,
5745
uint key_length_arg,
5746
my_bool insert_or_update)
5748
uint a_length, b_length;
5749
if (key_length_arg > 255)
5751
a_length=uint2korr(a); a+= 2;
5752
b_length=uint2korr(b); b+= 2;
5756
a_length= (uint) *a++;
5757
b_length= (uint) *b++;
5759
return field_charset->coll->strnncollsp(field_charset,
5766
int Field_varstring::pack_cmp(const uchar *b, uint key_length_arg,
5767
my_bool insert_or_update)
5769
uchar *a= ptr+ length_bytes;
5770
uint a_length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
5772
uint local_char_length= ((field_charset->mbmaxlen > 1) ?
5773
key_length_arg / field_charset->mbmaxlen :
5776
if (key_length_arg > 255)
5778
b_length=uint2korr(b); b+= HA_KEY_BLOB_LENGTH;
5781
b_length= (uint) *b++;
5783
if (a_length > local_char_length)
5785
local_char_length= my_charpos(field_charset, a, a+a_length,
5787
set_if_smaller(a_length, local_char_length);
5790
return field_charset->coll->strnncollsp(field_charset,
5797
uint Field_varstring::packed_col_length(const uchar *data_ptr, uint length)
5800
return uint2korr(data_ptr)+2;
5801
return (uint) *data_ptr + 1;
5805
uint Field_varstring::max_packed_col_length(uint max_length)
5807
return (max_length > 255 ? 2 : 1)+max_length;
5810
uint Field_varstring::get_key_image(uchar *buff,
5812
imagetype type __attribute__((__unused__)))
5814
uint f_length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
5815
uint local_char_length= length / field_charset->mbmaxlen;
5816
uchar *pos= ptr+length_bytes;
5817
local_char_length= my_charpos(field_charset, pos, pos + f_length,
5819
set_if_smaller(f_length, local_char_length);
5820
/* Key is always stored with 2 bytes */
5821
int2store(buff,f_length);
5822
memcpy(buff+HA_KEY_BLOB_LENGTH, pos, f_length);
5823
if (f_length < length)
5826
Must clear this as we do a memcmp in opt_range.cc to detect
5829
bzero(buff+HA_KEY_BLOB_LENGTH+f_length, (length-f_length));
5831
return HA_KEY_BLOB_LENGTH+f_length;
5835
void Field_varstring::set_key_image(const uchar *buff,uint length)
5837
length= uint2korr(buff); // Real length is here
5838
(void) Field_varstring::store((const char*) buff+HA_KEY_BLOB_LENGTH, length,
5843
int Field_varstring::cmp_binary(const uchar *a_ptr, const uchar *b_ptr,
5846
uint32 a_length,b_length;
5848
if (length_bytes == 1)
5850
a_length= (uint) *a_ptr;
5851
b_length= (uint) *b_ptr;
5855
a_length= uint2korr(a_ptr);
5856
b_length= uint2korr(b_ptr);
5858
set_if_smaller(a_length, max_length);
5859
set_if_smaller(b_length, max_length);
5860
if (a_length != b_length)
5862
return memcmp(a_ptr+length_bytes, b_ptr+length_bytes, a_length);
5866
Field *Field_varstring::new_field(MEM_ROOT *root, struct st_table *new_table,
5869
Field_varstring *res= (Field_varstring*) Field::new_field(root, new_table,
5872
res->length_bytes= length_bytes;
5877
Field *Field_varstring::new_key_field(MEM_ROOT *root,
5878
struct st_table *new_table,
5879
uchar *new_ptr, uchar *new_null_ptr,
5882
Field_varstring *res;
5883
if ((res= (Field_varstring*) Field::new_key_field(root,
5889
/* Keys length prefixes are always packed with 2 bytes */
5890
res->length_bytes= 2;
5896
uint Field_varstring::is_equal(Create_field *new_field)
5898
if (new_field->sql_type == real_type() &&
5899
new_field->charset == field_charset)
5901
if (new_field->length == max_display_length())
5902
return IS_EQUAL_YES;
5903
if (new_field->length > max_display_length() &&
5904
((new_field->length <= 255 && max_display_length() <= 255) ||
5905
(new_field->length > 255 && max_display_length() > 255)))
5906
return IS_EQUAL_PACK_LENGTH; // VARCHAR, longer variable length
5912
void Field_varstring::hash(ulong *nr, ulong *nr2)
5916
*nr^= (*nr << 1) | 1;
5920
uint len= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
5921
CHARSET_INFO *cs= charset();
5922
cs->coll->hash_sort(cs, ptr + length_bytes, len, nr, nr2);
5927
/****************************************************************************
5929
** A blob is saved as a length and a pointer. The length is stored in the
5930
** packlength slot and may be from 1-4.
5931
****************************************************************************/
5933
Field_blob::Field_blob(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
5934
enum utype unireg_check_arg, const char *field_name_arg,
5935
TABLE_SHARE *share, uint blob_pack_length,
5937
:Field_longstr(ptr_arg, BLOB_PACK_LENGTH_TO_MAX_LENGH(blob_pack_length),
5938
null_ptr_arg, null_bit_arg, unireg_check_arg, field_name_arg,
5940
packlength(blob_pack_length)
5943
share->blob_fields++;
5944
/* TODO: why do not fill table->s->blob_field array here? */
5948
void Field_blob::store_length(uchar *i_ptr,
5951
bool low_byte_first __attribute__((__unused__)))
5953
switch (i_packlength) {
5955
i_ptr[0]= (uchar) i_number;
5958
#ifdef WORDS_BIGENDIAN
5961
int2store(i_ptr,(unsigned short) i_number);
5965
shortstore(i_ptr,(unsigned short) i_number);
5968
int3store(i_ptr,i_number);
5971
#ifdef WORDS_BIGENDIAN
5974
int4store(i_ptr,i_number);
5978
longstore(i_ptr,i_number);
5983
uint32 Field_blob::get_length(const uchar *pos,
5984
uint packlength_arg,
5985
bool low_byte_first __attribute__((__unused__)))
5987
switch (packlength_arg) {
5989
return (uint32) pos[0];
5993
#ifdef WORDS_BIGENDIAN
5999
return (uint32) tmp;
6002
return (uint32) uint3korr(pos);
6006
#ifdef WORDS_BIGENDIAN
6012
return (uint32) tmp;
6015
return 0; // Impossible
6020
Put a blob length field into a record buffer.
6022
Depending on the maximum length of a blob, its length field is
6023
put into 1 to 4 bytes. This is a property of the blob object,
6024
described by 'packlength'.
6026
@param pos Pointer into the record buffer.
6027
@param length The length value to put.
6030
void Field_blob::put_length(uchar *pos, uint32 length)
6032
switch (packlength) {
6034
*pos= (char) length;
6037
int2store(pos, length);
6040
int3store(pos, length);
6043
int4store(pos, length);
6049
int Field_blob::store(const char *from,uint length,CHARSET_INFO *cs)
6051
uint copy_length, new_length;
6052
const char *well_formed_error_pos;
6053
const char *cannot_convert_error_pos;
6054
const char *from_end_pos, *tmp;
6055
char buff[STRING_BUFFER_USUAL_SIZE];
6056
String tmpstr(buff,sizeof(buff), &my_charset_bin);
6060
bzero(ptr,Field_blob::pack_length());
6064
if (from == value.ptr())
6066
uint32 dummy_offset;
6067
if (!String::needs_conversion(length, cs, field_charset, &dummy_offset))
6069
Field_blob::store_length(length);
6070
bmove(ptr+packlength,(char*) &from,sizeof(char*));
6073
if (tmpstr.copy(from, length, cs))
6078
new_length= min(max_data_length(), field_charset->mbmaxlen * length);
6079
if (value.alloc(new_length))
6083
if (f_is_hex_escape(flags))
6085
copy_length= my_copy_with_hex_escaping(field_charset,
6086
(char*) value.ptr(), new_length,
6088
Field_blob::store_length(copy_length);
6090
bmove(ptr + packlength, (uchar*) &tmp, sizeof(char*));
6094
"length" is OK as "nchars" argument to well_formed_copy_nchars as this
6095
is never used to limit the length of the data. The cut of long data
6096
is done with the new_length value.
6098
copy_length= well_formed_copy_nchars(field_charset,
6099
(char*) value.ptr(), new_length,
6102
&well_formed_error_pos,
6103
&cannot_convert_error_pos,
6106
Field_blob::store_length(copy_length);
6108
bmove(ptr+packlength,(uchar*) &tmp,sizeof(char*));
6110
if (check_string_copy_error(this, well_formed_error_pos,
6111
cannot_convert_error_pos, from + length, cs))
6114
return report_if_important_data(from_end_pos, from + length);
6117
/* Fatal OOM error */
6118
bzero(ptr,Field_blob::pack_length());
6123
int Field_blob::store(double nr)
6125
CHARSET_INFO *cs=charset();
6126
value.set_real(nr, NOT_FIXED_DEC, cs);
6127
return Field_blob::store(value.ptr(),(uint) value.length(), cs);
6131
int Field_blob::store(int64_t nr, bool unsigned_val)
6133
CHARSET_INFO *cs=charset();
6134
value.set_int(nr, unsigned_val, cs);
6135
return Field_blob::store(value.ptr(), (uint) value.length(), cs);
6139
double Field_blob::val_real(void)
6142
char *end_not_used, *blob;
6146
memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
6149
length= get_length(ptr);
6151
return my_strntod(cs, blob, length, &end_not_used, ¬_used);
6155
int64_t Field_blob::val_int(void)
6159
memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
6162
uint32 length=get_length(ptr);
6163
return my_strntoll(charset(),blob,length,10,NULL,¬_used);
6166
String *Field_blob::val_str(String *val_buffer __attribute__((unused)),
6170
memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
6172
val_ptr->set("",0,charset()); // A bit safer than ->length(0)
6174
val_ptr->set((const char*) blob,get_length(ptr),charset());
6179
my_decimal *Field_blob::val_decimal(my_decimal *decimal_value)
6183
memcpy_fixed(&blob, ptr+packlength, sizeof(const uchar*));
6190
length= get_length(ptr);
6192
str2my_decimal(E_DEC_FATAL_ERROR, blob, length, charset(),
6194
return decimal_value;
6198
int Field_blob::cmp(const uchar *a,uint32 a_length, const uchar *b,
6201
return field_charset->coll->strnncollsp(field_charset,
6202
a, a_length, b, b_length,
6207
int Field_blob::cmp_max(const uchar *a_ptr, const uchar *b_ptr,
6210
uchar *blob1,*blob2;
6211
memcpy_fixed(&blob1,a_ptr+packlength,sizeof(char*));
6212
memcpy_fixed(&blob2,b_ptr+packlength,sizeof(char*));
6213
uint a_len= get_length(a_ptr), b_len= get_length(b_ptr);
6214
set_if_smaller(a_len, max_length);
6215
set_if_smaller(b_len, max_length);
6216
return Field_blob::cmp(blob1,a_len,blob2,b_len);
6220
int Field_blob::cmp_binary(const uchar *a_ptr, const uchar *b_ptr,
6225
uint32 a_length,b_length;
6226
memcpy_fixed(&a,a_ptr+packlength,sizeof(char*));
6227
memcpy_fixed(&b,b_ptr+packlength,sizeof(char*));
6228
a_length=get_length(a_ptr);
6229
if (a_length > max_length)
6230
a_length=max_length;
6231
b_length=get_length(b_ptr);
6232
if (b_length > max_length)
6233
b_length=max_length;
6234
diff=memcmp(a,b,min(a_length,b_length));
6235
return diff ? diff : (int) (a_length - b_length);
6239
/* The following is used only when comparing a key */
6241
uint Field_blob::get_key_image(uchar *buff,
6243
imagetype type_arg __attribute__((__unused__)))
6245
uint32 blob_length= get_length(ptr);
6249
uint local_char_length= length / field_charset->mbmaxlen;
6250
local_char_length= my_charpos(field_charset, blob, blob + blob_length,
6252
set_if_smaller(blob_length, local_char_length);
6254
if ((uint32) length > blob_length)
6257
Must clear this as we do a memcmp in opt_range.cc to detect
6260
bzero(buff+HA_KEY_BLOB_LENGTH+blob_length, (length-blob_length));
6261
length=(uint) blob_length;
6263
int2store(buff,length);
6264
memcpy(buff+HA_KEY_BLOB_LENGTH, blob, length);
6265
return HA_KEY_BLOB_LENGTH+length;
6269
void Field_blob::set_key_image(const uchar *buff,uint length)
6271
length= uint2korr(buff);
6272
(void) Field_blob::store((const char*) buff+HA_KEY_BLOB_LENGTH, length,
6277
int Field_blob::key_cmp(const uchar *key_ptr, uint max_key_length)
6280
uint blob_length=get_length(ptr);
6281
memcpy_fixed(&blob1,ptr+packlength,sizeof(char*));
6282
CHARSET_INFO *cs= charset();
6283
uint local_char_length= max_key_length / cs->mbmaxlen;
6284
local_char_length= my_charpos(cs, blob1, blob1+blob_length,
6286
set_if_smaller(blob_length, local_char_length);
6287
return Field_blob::cmp(blob1, blob_length,
6288
key_ptr+HA_KEY_BLOB_LENGTH,
6289
uint2korr(key_ptr));
6292
int Field_blob::key_cmp(const uchar *a,const uchar *b)
6294
return Field_blob::cmp(a+HA_KEY_BLOB_LENGTH, uint2korr(a),
6295
b+HA_KEY_BLOB_LENGTH, uint2korr(b));
6300
Save the field metadata for blob fields.
6302
Saves the pack length in the first byte of the field metadata array
6303
at index of *metadata_ptr.
6305
@param metadata_ptr First byte of field metadata
6307
@returns number of bytes written to metadata_ptr
6309
int Field_blob::do_save_field_metadata(uchar *metadata_ptr)
6311
*metadata_ptr= pack_length_no_ptr();
6316
uint32 Field_blob::sort_length() const
6318
return (uint32) (current_thd->variables.max_sort_length +
6319
(field_charset == &my_charset_bin ? 0 : packlength));
6323
void Field_blob::sort_string(uchar *to,uint length)
6326
uint blob_length=get_length();
6332
if (field_charset == &my_charset_bin)
6337
Store length of blob last in blob to shorter blobs before longer blobs
6339
length-= packlength;
6342
switch (packlength) {
6344
*pos= (char) blob_length;
6347
mi_int2store(pos, blob_length);
6350
mi_int3store(pos, blob_length);
6353
mi_int4store(pos, blob_length);
6357
memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
6359
blob_length=my_strnxfrm(field_charset,
6360
to, length, blob, blob_length);
6361
assert(blob_length == length);
6366
void Field_blob::sql_type(String &res) const
6370
switch (packlength) {
6371
default: str="tiny"; length=4; break;
6372
case 2: str=""; length=0; break;
6373
case 3: str="medium"; length= 6; break;
6374
case 4: str="long"; length=4; break;
6376
res.set_ascii(str,length);
6377
if (charset() == &my_charset_bin)
6378
res.append(STRING_WITH_LEN("blob"));
6381
res.append(STRING_WITH_LEN("text"));
6385
uchar *Field_blob::pack(uchar *to, const uchar *from,
6386
uint max_length, bool low_byte_first)
6390
uint32 length=get_length(); // Length of from string
6393
Store max length, which will occupy packlength bytes. If the max
6394
length given is smaller than the actual length of the blob, we
6395
just store the initial bytes of the blob.
6397
store_length(to, packlength, min(length, max_length), low_byte_first);
6400
Store the actual blob data, which will occupy 'length' bytes.
6404
get_ptr((uchar**) &from);
6405
memcpy(to+packlength, from,length);
6407
ptr=save; // Restore org row pointer
6408
return(to+packlength+length);
6413
Unpack a blob field from row data.
6415
This method is used to unpack a blob field from a master whose size of
6416
the field is less than that of the slave. Note: This method is included
6417
to satisfy inheritance rules, but is not needed for blob fields. It
6418
simply is used as a pass-through to the original unpack() method for
6421
@param to Destination of the data
6422
@param from Source of the data
6423
@param param_data @c true if base types should be stored in little-
6424
endian format, @c false if native format should
6427
@return New pointer into memory based on from + length of the data
6429
const uchar *Field_blob::unpack(uchar *to __attribute__((__unused__)),
6432
bool low_byte_first)
6434
uint const master_packlength=
6435
param_data > 0 ? param_data & 0xFF : packlength;
6436
uint32 const length= get_length(from, master_packlength, low_byte_first);
6437
bitmap_set_bit(table->write_set, field_index);
6438
store(reinterpret_cast<const char*>(from) + master_packlength,
6439
length, field_charset);
6440
return(from + master_packlength + length);
6443
/* Keys for blobs are like keys on varchars */
6445
int Field_blob::pack_cmp(const uchar *a, const uchar *b, uint key_length_arg,
6446
my_bool insert_or_update)
6448
uint a_length, b_length;
6449
if (key_length_arg > 255)
6451
a_length=uint2korr(a); a+=2;
6452
b_length=uint2korr(b); b+=2;
6456
a_length= (uint) *a++;
6457
b_length= (uint) *b++;
6459
return field_charset->coll->strnncollsp(field_charset,
6466
int Field_blob::pack_cmp(const uchar *b, uint key_length_arg,
6467
my_bool insert_or_update)
6470
uint a_length, b_length;
6471
memcpy_fixed(&a,ptr+packlength,sizeof(char*));
6473
return key_length_arg > 0 ? -1 : 0;
6475
a_length= get_length(ptr);
6476
if (key_length_arg > 255)
6478
b_length= uint2korr(b); b+=2;
6481
b_length= (uint) *b++;
6482
return field_charset->coll->strnncollsp(field_charset,
6488
/** Create a packed key that will be used for storage from a MySQL row. */
6491
Field_blob::pack_key(uchar *to, const uchar *from, uint max_length,
6492
bool low_byte_first __attribute__((unused)))
6496
uint32 length=get_length(); // Length of from string
6497
uint local_char_length= ((field_charset->mbmaxlen > 1) ?
6498
max_length/field_charset->mbmaxlen : max_length);
6500
get_ptr((uchar**) &from);
6501
if (length > local_char_length)
6502
local_char_length= my_charpos(field_charset, from, from+length,
6504
set_if_smaller(length, local_char_length);
6505
*to++= (uchar) length;
6506
if (max_length > 255) // 2 byte length
6507
*to++= (uchar) (length >> 8);
6508
memcpy(to, from, length);
6509
ptr=save; // Restore org row pointer
6515
Unpack a blob key into a record buffer.
6517
A blob key has a maximum size of 64K-1.
6518
In its packed form, the length field is one or two bytes long,
6519
depending on 'max_length'.
6520
Depending on the maximum length of a blob, its length field is
6521
put into 1 to 4 bytes. This is a property of the blob object,
6522
described by 'packlength'.
6523
Blobs are internally stored apart from the record buffer, which
6524
contains a pointer to the blob buffer.
6527
@param to Pointer into the record buffer.
6528
@param from Pointer to the packed key.
6529
@param max_length Key length limit from key description.
6532
Pointer into 'from' past the last byte copied from packed key.
6536
Field_blob::unpack_key(uchar *to, const uchar *from, uint max_length,
6537
bool low_byte_first __attribute__((unused)))
6539
/* get length of the blob key */
6540
uint32 length= *from++;
6541
if (max_length > 255)
6542
length+= *from++ << 8;
6544
/* put the length into the record buffer */
6545
put_length(to, length);
6547
/* put the address of the blob buffer or NULL */
6549
memcpy_fixed(to + packlength, &from, sizeof(from));
6551
bzero(to + packlength, sizeof(from));
6553
/* point to first byte of next field in 'from' */
6554
return from + length;
6558
/** Create a packed key that will be used for storage from a MySQL key. */
6561
Field_blob::pack_key_from_key_image(uchar *to, const uchar *from, uint max_length,
6562
bool low_byte_first __attribute__((unused)))
6564
uint length=uint2korr(from);
6565
if (length > max_length)
6567
*to++= (char) (length & 255);
6568
if (max_length > 255)
6569
*to++= (char) (length >> 8);
6571
memcpy(to, from+HA_KEY_BLOB_LENGTH, length);
6576
uint Field_blob::packed_col_length(const uchar *data_ptr, uint length)
6579
return uint2korr(data_ptr)+2;
6580
return (uint) *data_ptr + 1;
6584
uint Field_blob::max_packed_col_length(uint max_length)
6586
return (max_length > 255 ? 2 : 1)+max_length;
6590
uint Field_blob::is_equal(Create_field *new_field)
6592
if (compare_str_field_flags(new_field, flags))
6595
return ((new_field->sql_type == get_blob_type_from_length(max_data_length()))
6596
&& new_field->charset == field_charset &&
6597
((Field_blob *)new_field->field)->max_data_length() ==
6602
/****************************************************************************
6604
** This is a string which only can have a selection of different values.
6605
** If one uses this string in a number context one gets the type number.
6606
****************************************************************************/
6608
enum ha_base_keytype Field_enum::key_type() const
6610
switch (packlength) {
6611
default: return HA_KEYTYPE_BINARY;
6612
case 2: return HA_KEYTYPE_USHORT_INT;
6613
case 3: return HA_KEYTYPE_UINT24;
6614
case 4: return HA_KEYTYPE_ULONG_INT;
6615
case 8: return HA_KEYTYPE_ULONGLONG;
6619
void Field_enum::store_type(uint64_t value)
6621
switch (packlength) {
6622
case 1: ptr[0]= (uchar) value; break;
6624
#ifdef WORDS_BIGENDIAN
6625
if (table->s->db_low_byte_first)
6627
int2store(ptr,(unsigned short) value);
6631
shortstore(ptr,(unsigned short) value);
6633
case 3: int3store(ptr,(long) value); break;
6635
#ifdef WORDS_BIGENDIAN
6636
if (table->s->db_low_byte_first)
6638
int4store(ptr,value);
6642
longstore(ptr,(long) value);
6645
#ifdef WORDS_BIGENDIAN
6646
if (table->s->db_low_byte_first)
6648
int8store(ptr,value);
6652
int64_tstore(ptr,value); break;
6659
Storing a empty string in a enum field gives a warning
6660
(if there isn't a empty value in the enum)
6663
int Field_enum::store(const char *from,uint length,CHARSET_INFO *cs)
6667
char buff[STRING_BUFFER_USUAL_SIZE];
6668
String tmpstr(buff,sizeof(buff), &my_charset_bin);
6670
/* Convert character set if necessary */
6671
if (String::needs_conversion(length, cs, field_charset, ¬_used))
6674
tmpstr.copy(from, length, cs, field_charset, &dummy_errors);
6676
length= tmpstr.length();
6679
/* Remove end space */
6680
length= field_charset->cset->lengthsp(field_charset, from, length);
6681
uint tmp=find_type2(typelib, from, length, field_charset);
6684
if (length < 6) // Can't be more than 99999 enums
6686
/* This is for reading numbers with LOAD DATA INFILE */
6688
tmp=(uint) my_strntoul(cs,from,length,10,&end,&err);
6689
if (err || end != from+length || tmp > typelib->count)
6692
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
6694
if (!table->in_use->count_cuted_fields)
6698
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
6700
store_type((uint64_t) tmp);
6705
int Field_enum::store(double nr)
6707
return Field_enum::store((int64_t) nr, false);
6711
int Field_enum::store(int64_t nr,
6712
bool unsigned_val __attribute__((__unused__)))
6715
if ((uint64_t) nr > typelib->count || nr == 0)
6717
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
6718
if (nr != 0 || table->in_use->count_cuted_fields)
6724
store_type((uint64_t) (uint) nr);
6729
double Field_enum::val_real(void)
6731
return (double) Field_enum::val_int();
6735
int64_t Field_enum::val_int(void)
6737
switch (packlength) {
6739
return (int64_t) ptr[0];
6743
#ifdef WORDS_BIGENDIAN
6744
if (table->s->db_low_byte_first)
6749
return (int64_t) tmp;
6752
return (int64_t) uint3korr(ptr);
6756
#ifdef WORDS_BIGENDIAN
6757
if (table->s->db_low_byte_first)
6762
return (int64_t) tmp;
6767
#ifdef WORDS_BIGENDIAN
6768
if (table->s->db_low_byte_first)
6772
int64_tget(tmp,ptr);
6776
return 0; // impossible
6781
Save the field metadata for enum fields.
6783
Saves the real type in the first byte and the pack length in the
6784
second byte of the field metadata array at index of *metadata_ptr and
6785
*(metadata_ptr + 1).
6787
@param metadata_ptr First byte of field metadata
6789
@returns number of bytes written to metadata_ptr
6791
int Field_enum::do_save_field_metadata(uchar *metadata_ptr)
6793
*metadata_ptr= real_type();
6794
*(metadata_ptr + 1)= pack_length();
6799
String *Field_enum::val_str(String *val_buffer __attribute__((unused)),
6802
uint tmp=(uint) Field_enum::val_int();
6803
if (!tmp || tmp > typelib->count)
6804
val_ptr->set("", 0, field_charset);
6806
val_ptr->set((const char*) typelib->type_names[tmp-1],
6807
typelib->type_lengths[tmp-1],
6812
int Field_enum::cmp(const uchar *a_ptr, const uchar *b_ptr)
6815
ptr= (uchar*) a_ptr;
6816
uint64_t a=Field_enum::val_int();
6817
ptr= (uchar*) b_ptr;
6818
uint64_t b=Field_enum::val_int();
6820
return (a < b) ? -1 : (a > b) ? 1 : 0;
6823
void Field_enum::sort_string(uchar *to,uint length __attribute__((unused)))
6825
uint64_t value=Field_enum::val_int();
6827
for (uint i=0 ; i < packlength ; i++)
6829
*to-- = (uchar) (value & 255);
6835
void Field_enum::sql_type(String &res) const
6838
String enum_item(buffer, sizeof(buffer), res.charset());
6841
res.append(STRING_WITH_LEN("enum("));
6844
uint *len= typelib->type_lengths;
6845
for (const char **pos= typelib->type_names; *pos; pos++, len++)
6850
/* convert to res.charset() == utf8, then quote */
6851
enum_item.copy(*pos, *len, charset(), res.charset(), &dummy_errors);
6852
append_unescaped(&res, enum_item.ptr(), enum_item.length());
6859
Field *Field_enum::new_field(MEM_ROOT *root, struct st_table *new_table,
6862
Field_enum *res= (Field_enum*) Field::new_field(root, new_table, keep_type);
6864
res->typelib= copy_typelib(root, typelib);
6871
This is a string which can have a collection of different values.
6872
Each string value is separated with a ','.
6873
For example "One,two,five"
6874
If one uses this string in a number context one gets the bits as a int64_t
6879
int Field_set::store(const char *from,uint length,CHARSET_INFO *cs)
6881
bool got_warning= 0;
6885
uint32 not_used_offset;
6886
char buff[STRING_BUFFER_USUAL_SIZE];
6887
String tmpstr(buff,sizeof(buff), &my_charset_bin);
6889
/* Convert character set if necessary */
6890
if (String::needs_conversion(length, cs, field_charset, ¬_used_offset))
6893
tmpstr.copy(from, length, cs, field_charset, &dummy_errors);
6895
length= tmpstr.length();
6897
uint64_t tmp= find_set(typelib, from, length, field_charset,
6898
¬_used, ¬_used2, &got_warning);
6899
if (!tmp && length && length < 22)
6901
/* This is for reading numbers with LOAD DATA INFILE */
6903
tmp=my_strntoull(cs,from,length,10,&end,&err);
6904
if (err || end != from+length ||
6905
tmp > (uint64_t) (((int64_t) 1 << typelib->count) - (int64_t) 1))
6908
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
6911
else if (got_warning)
6912
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
6918
int Field_set::store(int64_t nr,
6919
bool unsigned_val __attribute__((__unused__)))
6922
uint64_t max_nr= set_bits(uint64_t, typelib->count);
6923
if ((uint64_t) nr > max_nr)
6926
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
6929
store_type((uint64_t) nr);
6934
String *Field_set::val_str(String *val_buffer,
6935
String *val_ptr __attribute__((unused)))
6937
uint64_t tmp=(uint64_t) Field_enum::val_int();
6940
val_buffer->length(0);
6941
val_buffer->set_charset(field_charset);
6942
while (tmp && bitnr < (uint) typelib->count)
6946
if (val_buffer->length())
6947
val_buffer->append(&field_separator, 1, &my_charset_latin1);
6948
String str(typelib->type_names[bitnr],
6949
typelib->type_lengths[bitnr],
6951
val_buffer->append(str);
6960
void Field_set::sql_type(String &res) const
6963
String set_item(buffer, sizeof(buffer), res.charset());
6966
res.append(STRING_WITH_LEN("set("));
6969
uint *len= typelib->type_lengths;
6970
for (const char **pos= typelib->type_names; *pos; pos++, len++)
6975
/* convert to res.charset() == utf8, then quote */
6976
set_item.copy(*pos, *len, charset(), res.charset(), &dummy_errors);
6977
append_unescaped(&res, set_item.ptr(), set_item.length());
1260
6985
1 if the fields are equally defined
added
removed
server/field.cc
