← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.cc

Merged Padraig.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field.cc
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2010 Brian Aker
5
4
 *  Copyright (C) 2008 MySQL
6
5
 *
7
6
 *  This program is free software; you can redistribute it and/or modify
20
19
 */
21
20
 
22
21
/**
23
 
 * @file This file implements the Field class and API
24
 
 */
 
22
  @file
25
23
 
26
 
#include "config.h"
27
 
#include <cstdio>
 
24
  @brief
 
25
  This file implements classes defined in field.h
 
26
*/
 
27
#include <drizzled/server_includes.h>
 
28
#include "sql_select.h"
28
29
#include <errno.h>
29
 
#include <float.h>
30
 
#include "drizzled/sql_select.h"
31
 
#include "drizzled/error.h"
32
 
#include "drizzled/field/str.h"
33
 
#include "drizzled/field/num.h"
34
 
#include "drizzled/field/blob.h"
35
 
#include "drizzled/field/boolean.h"
36
 
#include "drizzled/field/enum.h"
37
 
#include "drizzled/field/null.h"
38
 
#include "drizzled/field/date.h"
39
 
#include "drizzled/field/decimal.h"
40
 
#include "drizzled/field/real.h"
41
 
#include "drizzled/field/double.h"
42
 
#include "drizzled/field/int32.h"
43
 
#include "drizzled/field/int64.h"
44
 
#include "drizzled/field/num.h"
45
 
#include "drizzled/field/time.h"
46
 
#include "drizzled/field/epoch.h"
47
 
#include "drizzled/field/datetime.h"
48
 
#include "drizzled/field/microtime.h"
49
 
#include "drizzled/field/varstring.h"
50
 
#include "drizzled/field/uuid.h"
51
 
#include "drizzled/time_functions.h"
52
 
#include "drizzled/internal/m_string.h"
53
 
 
54
 
#include "drizzled/display.h"
55
 
 
56
 
namespace drizzled
57
 
{
 
30
#include <drizzled/error.h>
 
31
#include <drizzled/virtual_column_info.h>
 
32
#include <drizzled/field/str.h>
 
33
#include <drizzled/field/longstr.h>
 
34
#include <drizzled/field/num.h>
 
35
#include <drizzled/field/blob.h>
 
36
#include <drizzled/field/enum.h>
 
37
#include <drizzled/field/null.h>
 
38
#include <drizzled/field/date.h>
 
39
#include <drizzled/field/decimal.h>
 
40
#include <drizzled/field/real.h>
 
41
#include <drizzled/field/double.h>
 
42
#include <drizzled/field/long.h>
 
43
#include <drizzled/field/int64_t.h>
 
44
#include <drizzled/field/num.h>
 
45
#include <drizzled/field/timestamp.h>
 
46
#include <drizzled/field/datetime.h>
 
47
#include <drizzled/field/varstring.h>
 
48
 
58
49
 
59
50
/*****************************************************************************
60
51
  Instansiate templates and static variables
61
52
*****************************************************************************/
62
53
 
 
54
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
 
55
template class List<Create_field>;
 
56
template class List_iterator<Create_field>;
 
57
#endif
 
58
 
 
59
 
63
60
static enum_field_types
64
 
field_types_merge_rules [enum_field_types_size][enum_field_types_size]=
 
61
field_types_merge_rules [DRIZZLE_TYPE_MAX+1][DRIZZLE_TYPE_MAX+1]=
65
62
{
 
63
  /* DRIZZLE_TYPE_TINY -> */
 
64
  {
 
65
    //DRIZZLE_TYPE_TINY
 
66
    DRIZZLE_TYPE_TINY,
 
67
    //DRIZZLE_TYPE_LONG
 
68
    DRIZZLE_TYPE_LONG,
 
69
    //DRIZZLE_TYPE_DOUBLE
 
70
    DRIZZLE_TYPE_DOUBLE,
 
71
    //DRIZZLE_TYPE_NULL
 
72
    DRIZZLE_TYPE_TINY,
 
73
    //DRIZZLE_TYPE_TIMESTAMP
 
74
    DRIZZLE_TYPE_VARCHAR,
 
75
    //DRIZZLE_TYPE_LONGLONG
 
76
    DRIZZLE_TYPE_LONGLONG,
 
77
    //DRIZZLE_TYPE_DATETIME
 
78
    DRIZZLE_TYPE_VARCHAR,
 
79
    //DRIZZLE_TYPE_DATE
 
80
    DRIZZLE_TYPE_VARCHAR,
 
81
    //DRIZZLE_TYPE_VARCHAR
 
82
    DRIZZLE_TYPE_VARCHAR,
 
83
    //DRIZZLE_TYPE_VIRTUAL
 
84
    DRIZZLE_TYPE_VIRTUAL,
 
85
    //DRIZZLE_TYPE_NEWDECIMAL
 
86
    DRIZZLE_TYPE_NEWDECIMAL,
 
87
    //DRIZZLE_TYPE_ENUM
 
88
    DRIZZLE_TYPE_VARCHAR,
 
89
    //DRIZZLE_TYPE_BLOB
 
90
    DRIZZLE_TYPE_BLOB,
 
91
  },
66
92
  /* DRIZZLE_TYPE_LONG -> */
67
93
  {
 
94
    //DRIZZLE_TYPE_TINY
 
95
    DRIZZLE_TYPE_LONG,
68
96
    //DRIZZLE_TYPE_LONG
69
97
    DRIZZLE_TYPE_LONG,
70
98
    //DRIZZLE_TYPE_DOUBLE
81
109
    DRIZZLE_TYPE_VARCHAR,
82
110
    //DRIZZLE_TYPE_VARCHAR
83
111
    DRIZZLE_TYPE_VARCHAR,
84
 
    //DRIZZLE_TYPE_DECIMAL
85
 
    DRIZZLE_TYPE_DECIMAL,
 
112
    //DRIZZLE_TYPE_VIRTUAL
 
113
    DRIZZLE_TYPE_VIRTUAL,
 
114
    //DRIZZLE_TYPE_NEWDECIMAL
 
115
    DRIZZLE_TYPE_NEWDECIMAL,
86
116
    //DRIZZLE_TYPE_ENUM
87
117
    DRIZZLE_TYPE_VARCHAR,
88
118
    //DRIZZLE_TYPE_BLOB
89
119
    DRIZZLE_TYPE_BLOB,
90
 
    //DRIZZLE_TYPE_TIME
91
 
    DRIZZLE_TYPE_TIME,
92
 
    //DRIZZLE_TYPE_BOOLEAN
93
 
    DRIZZLE_TYPE_VARCHAR,
94
 
    //DRIZZLE_TYPE_UUID
95
 
    DRIZZLE_TYPE_VARCHAR,
96
 
    //DRIZZLE_TYPE_MICROTIME
97
 
    DRIZZLE_TYPE_VARCHAR,
98
120
  },
99
121
  /* DRIZZLE_TYPE_DOUBLE -> */
100
122
  {
 
123
    //DRIZZLE_TYPE_TINY
 
124
    DRIZZLE_TYPE_DOUBLE,
101
125
    //DRIZZLE_TYPE_LONG
102
126
    DRIZZLE_TYPE_DOUBLE,
103
127
    //DRIZZLE_TYPE_DOUBLE
114
138
    DRIZZLE_TYPE_VARCHAR,
115
139
    //DRIZZLE_TYPE_VARCHAR
116
140
    DRIZZLE_TYPE_VARCHAR,
117
 
    //DRIZZLE_TYPE_DECIMAL
 
141
    //DRIZZLE_TYPE_VIRTUAL
 
142
    DRIZZLE_TYPE_VIRTUAL,
 
143
    //DRIZZLE_TYPE_NEWDECIMAL
118
144
    DRIZZLE_TYPE_DOUBLE,
119
145
    //DRIZZLE_TYPE_ENUM
120
146
    DRIZZLE_TYPE_VARCHAR,
121
147
    //DRIZZLE_TYPE_BLOB
122
148
    DRIZZLE_TYPE_BLOB,
123
 
    //DRIZZLE_TYPE_TIME
124
 
    DRIZZLE_TYPE_TIME,
125
 
    //DRIZZLE_TYPE_BOOLEAN
126
 
    DRIZZLE_TYPE_VARCHAR,
127
 
    //DRIZZLE_TYPE_UUID
128
 
    DRIZZLE_TYPE_VARCHAR,
129
 
    //DRIZZLE_TYPE_MICROTIME
130
 
    DRIZZLE_TYPE_VARCHAR,
131
149
  },
132
150
  /* DRIZZLE_TYPE_NULL -> */
133
151
  {
 
152
    //DRIZZLE_TYPE_TINY
 
153
    DRIZZLE_TYPE_TINY,
134
154
    //DRIZZLE_TYPE_LONG
135
155
    DRIZZLE_TYPE_LONG,
136
156
    //DRIZZLE_TYPE_DOUBLE
147
167
    DRIZZLE_TYPE_DATE,
148
168
    //DRIZZLE_TYPE_VARCHAR
149
169
    DRIZZLE_TYPE_VARCHAR,
150
 
    //DRIZZLE_TYPE_DECIMAL
151
 
    DRIZZLE_TYPE_DECIMAL,
 
170
    //DRIZZLE_TYPE_VIRTUAL
 
171
    DRIZZLE_TYPE_VIRTUAL,
 
172
    //DRIZZLE_TYPE_NEWDECIMAL
 
173
    DRIZZLE_TYPE_NEWDECIMAL,
152
174
    //DRIZZLE_TYPE_ENUM
153
175
    DRIZZLE_TYPE_ENUM,
154
176
    //DRIZZLE_TYPE_BLOB
155
177
    DRIZZLE_TYPE_BLOB,
156
 
    //DRIZZLE_TYPE_TIME
157
 
    DRIZZLE_TYPE_TIME,
158
 
    //DRIZZLE_TYPE_BOOLEAN
159
 
    DRIZZLE_TYPE_BOOLEAN,
160
 
    //DRIZZLE_TYPE_UUID
161
 
    DRIZZLE_TYPE_UUID,
162
 
    //DRIZZLE_TYPE_MICROTIME
163
 
    DRIZZLE_TYPE_MICROTIME,
164
178
  },
165
179
  /* DRIZZLE_TYPE_TIMESTAMP -> */
166
180
  {
 
181
    //DRIZZLE_TYPE_TINY
 
182
    DRIZZLE_TYPE_VARCHAR,
167
183
    //DRIZZLE_TYPE_LONG
168
184
    DRIZZLE_TYPE_VARCHAR,
169
185
    //DRIZZLE_TYPE_DOUBLE
180
196
    DRIZZLE_TYPE_DATE,
181
197
    //DRIZZLE_TYPE_VARCHAR
182
198
    DRIZZLE_TYPE_VARCHAR,
183
 
    //DRIZZLE_TYPE_DECIMAL
 
199
    //DRIZZLE_TYPE_VIRTUAL
 
200
    DRIZZLE_TYPE_VIRTUAL,
 
201
    //DRIZZLE_TYPE_NEWDECIMAL
184
202
    DRIZZLE_TYPE_VARCHAR,
185
203
    //DRIZZLE_TYPE_ENUM
186
204
    DRIZZLE_TYPE_VARCHAR,
187
205
    //DRIZZLE_TYPE_BLOB
188
206
    DRIZZLE_TYPE_BLOB,
189
 
    //DRIZZLE_TYPE_TIME
190
 
    DRIZZLE_TYPE_TIME,
191
 
    //DRIZZLE_TYPE_BOOLEAN
192
 
    DRIZZLE_TYPE_VARCHAR,
193
 
    //DRIZZLE_TYPE_UUID
194
 
    DRIZZLE_TYPE_VARCHAR,
195
 
    //DRIZZLE_TYPE_MICROTIME
196
 
    DRIZZLE_TYPE_VARCHAR,
197
207
  },
198
208
  /* DRIZZLE_TYPE_LONGLONG -> */
199
209
  {
 
210
    //DRIZZLE_TYPE_TINY
 
211
    DRIZZLE_TYPE_LONGLONG,
200
212
    //DRIZZLE_TYPE_LONG
201
213
    DRIZZLE_TYPE_LONGLONG,
202
214
    //DRIZZLE_TYPE_DOUBLE
213
225
    DRIZZLE_TYPE_DATE,
214
226
    //DRIZZLE_TYPE_VARCHAR
215
227
    DRIZZLE_TYPE_VARCHAR,
216
 
    //DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_ENUM
217
 
    DRIZZLE_TYPE_DECIMAL,
 
228
    //DRIZZLE_TYPE_VIRTUAL
 
229
    DRIZZLE_TYPE_VIRTUAL,
 
230
    //DRIZZLE_TYPE_NEWDECIMAL
 
231
    //DRIZZLE_TYPE_ENUM
 
232
    DRIZZLE_TYPE_NEWDECIMAL,
218
233
    DRIZZLE_TYPE_VARCHAR,
219
234
    //DRIZZLE_TYPE_BLOB
220
235
    DRIZZLE_TYPE_BLOB,
221
 
    //DRIZZLE_TYPE_TIME
222
 
    DRIZZLE_TYPE_TIME,
223
 
    //DRIZZLE_TYPE_BOOLEAN
224
 
    DRIZZLE_TYPE_VARCHAR,
225
 
    //DRIZZLE_TYPE_UUID
226
 
    DRIZZLE_TYPE_VARCHAR,
227
 
    //DRIZZLE_TYPE_MICROTIME
228
 
    DRIZZLE_TYPE_VARCHAR,
229
236
  },
230
237
  /* DRIZZLE_TYPE_DATETIME -> */
231
238
  {
 
239
    //DRIZZLE_TYPE_TINY
 
240
    DRIZZLE_TYPE_VARCHAR,
232
241
    //DRIZZLE_TYPE_LONG
233
242
    DRIZZLE_TYPE_VARCHAR,
234
243
    //DRIZZLE_TYPE_DOUBLE
245
254
    DRIZZLE_TYPE_DATE,
246
255
    //DRIZZLE_TYPE_VARCHAR
247
256
    DRIZZLE_TYPE_VARCHAR,
248
 
    //DRIZZLE_TYPE_DECIMAL
 
257
    //DRIZZLE_TYPE_VIRTUAL
 
258
    DRIZZLE_TYPE_VIRTUAL,
 
259
    //DRIZZLE_TYPE_NEWDECIMAL
249
260
    DRIZZLE_TYPE_VARCHAR,
250
261
    //DRIZZLE_TYPE_ENUM
251
262
    DRIZZLE_TYPE_VARCHAR,
252
263
    //DRIZZLE_TYPE_BLOB
253
264
    DRIZZLE_TYPE_BLOB,
254
 
    //DRIZZLE_TYPE_TIME
255
 
    DRIZZLE_TYPE_TIME,
256
 
    //DRIZZLE_TYPE_BOOLEAN
257
 
    DRIZZLE_TYPE_VARCHAR,
258
 
    //DRIZZLE_TYPE_UUID
259
 
    DRIZZLE_TYPE_VARCHAR,
260
 
    //DRIZZLE_TYPE_MICROTIME
261
 
    DRIZZLE_TYPE_VARCHAR,
262
265
  },
263
266
  /* DRIZZLE_TYPE_DATE -> */
264
267
  {
 
268
    //DRIZZLE_TYPE_TINY
 
269
    DRIZZLE_TYPE_VARCHAR,
265
270
    //DRIZZLE_TYPE_LONG
266
271
    DRIZZLE_TYPE_VARCHAR,
267
272
    //DRIZZLE_TYPE_DOUBLE
278
283
    DRIZZLE_TYPE_DATE,
279
284
    //DRIZZLE_TYPE_VARCHAR
280
285
    DRIZZLE_TYPE_VARCHAR,
281
 
    //DRIZZLE_TYPE_DECIMAL
 
286
    //DRIZZLE_TYPE_VIRTUAL
 
287
    DRIZZLE_TYPE_VIRTUAL,
 
288
    //DRIZZLE_TYPE_NEWDECIMAL
282
289
    DRIZZLE_TYPE_VARCHAR,
283
290
    //DRIZZLE_TYPE_ENUM
284
291
    DRIZZLE_TYPE_VARCHAR,
285
292
    //DRIZZLE_TYPE_BLOB
286
293
    DRIZZLE_TYPE_BLOB,
287
 
    //DRIZZLE_TYPE_TIME
288
 
    DRIZZLE_TYPE_TIME,
289
 
    //DRIZZLE_TYPE_BOOLEAN
290
 
    DRIZZLE_TYPE_VARCHAR,
291
 
    //DRIZZLE_TYPE_UUID
292
 
    DRIZZLE_TYPE_VARCHAR,
293
 
    //DRIZZLE_TYPE_MICROTIME
294
 
    DRIZZLE_TYPE_VARCHAR,
295
294
  },
296
295
  /* DRIZZLE_TYPE_VARCHAR -> */
297
296
  {
 
297
    //DRIZZLE_TYPE_TINY
 
298
    DRIZZLE_TYPE_VARCHAR,
298
299
    //DRIZZLE_TYPE_LONG
299
300
    DRIZZLE_TYPE_VARCHAR,
300
301
    //DRIZZLE_TYPE_DOUBLE
311
312
    DRIZZLE_TYPE_VARCHAR,
312
313
    //DRIZZLE_TYPE_VARCHAR
313
314
    DRIZZLE_TYPE_VARCHAR,
314
 
    //DRIZZLE_TYPE_DECIMAL
 
315
    //DRIZZLE_TYPE_VIRTUAL
 
316
    DRIZZLE_TYPE_VIRTUAL,
 
317
    //DRIZZLE_TYPE_NEWDECIMAL
315
318
    DRIZZLE_TYPE_VARCHAR,
316
319
    //DRIZZLE_TYPE_ENUM
317
320
    DRIZZLE_TYPE_VARCHAR,
318
321
    //DRIZZLE_TYPE_BLOB
319
322
    DRIZZLE_TYPE_BLOB,
320
 
    //DRIZZLE_TYPE_TIME
321
 
    DRIZZLE_TYPE_TIME,
322
 
    //DRIZZLE_TYPE_BOOLEAN
323
 
    DRIZZLE_TYPE_VARCHAR,
324
 
    //DRIZZLE_TYPE_UUID
325
 
    DRIZZLE_TYPE_VARCHAR,
326
 
    //DRIZZLE_TYPE_MICROTIME
327
 
    DRIZZLE_TYPE_VARCHAR,
328
 
  },
329
 
  /* DRIZZLE_TYPE_DECIMAL -> */
330
 
  {
331
 
    //DRIZZLE_TYPE_LONG
332
 
    DRIZZLE_TYPE_DECIMAL,
 
323
  },
 
324
  /* DRIZZLE_TYPE_VIRTUAL -> */
 
325
  {
 
326
    //DRIZZLE_TYPE_TINY
 
327
    DRIZZLE_TYPE_VIRTUAL,
 
328
    //DRIZZLE_TYPE_LONG
 
329
    DRIZZLE_TYPE_VIRTUAL,
 
330
    //DRIZZLE_TYPE_DOUBLE
 
331
    DRIZZLE_TYPE_VIRTUAL,
 
332
    //DRIZZLE_TYPE_NULL
 
333
    DRIZZLE_TYPE_VIRTUAL,
 
334
    //DRIZZLE_TYPE_TIMESTAMP
 
335
    DRIZZLE_TYPE_VIRTUAL,
 
336
    //DRIZZLE_TYPE_LONGLONG
 
337
    DRIZZLE_TYPE_VIRTUAL,
 
338
    //DRIZZLE_TYPE_DATETIME
 
339
    DRIZZLE_TYPE_VIRTUAL,
 
340
    //DRIZZLE_TYPE_DATE
 
341
    DRIZZLE_TYPE_VIRTUAL,
 
342
    //DRIZZLE_TYPE_VARCHAR
 
343
    DRIZZLE_TYPE_VIRTUAL,
 
344
    //DRIZZLE_TYPE_VIRTUAL
 
345
    DRIZZLE_TYPE_VIRTUAL,
 
346
    //DRIZZLE_TYPE_NEWDECIMAL
 
347
    DRIZZLE_TYPE_VIRTUAL,
 
348
    //DRIZZLE_TYPE_ENUM
 
349
    DRIZZLE_TYPE_VIRTUAL,
 
350
    //DRIZZLE_TYPE_BLOB
 
351
    DRIZZLE_TYPE_VIRTUAL,
 
352
  },
 
353
  /* DRIZZLE_TYPE_NEWDECIMAL -> */
 
354
  {
 
355
    //DRIZZLE_TYPE_TINY
 
356
    DRIZZLE_TYPE_NEWDECIMAL,
 
357
    //DRIZZLE_TYPE_LONG
 
358
    DRIZZLE_TYPE_NEWDECIMAL,
333
359
    //DRIZZLE_TYPE_DOUBLE
334
360
    DRIZZLE_TYPE_DOUBLE,
335
361
    //DRIZZLE_TYPE_NULL
336
 
    DRIZZLE_TYPE_DECIMAL,
 
362
    DRIZZLE_TYPE_NEWDECIMAL,
337
363
    //DRIZZLE_TYPE_TIMESTAMP
338
364
    DRIZZLE_TYPE_VARCHAR,
339
365
    //DRIZZLE_TYPE_LONGLONG
340
 
    DRIZZLE_TYPE_DECIMAL,
 
366
    DRIZZLE_TYPE_NEWDECIMAL,
341
367
    //DRIZZLE_TYPE_DATETIME
342
368
    DRIZZLE_TYPE_VARCHAR,
343
369
    //DRIZZLE_TYPE_DATE
344
370
    DRIZZLE_TYPE_VARCHAR,
345
371
    //DRIZZLE_TYPE_VARCHAR
346
372
    DRIZZLE_TYPE_VARCHAR,
347
 
    //DRIZZLE_TYPE_DECIMAL
348
 
    DRIZZLE_TYPE_DECIMAL,
 
373
    //DRIZZLE_TYPE_VIRTUAL
 
374
    DRIZZLE_TYPE_VIRTUAL,
 
375
    //DRIZZLE_TYPE_NEWDECIMAL
 
376
    DRIZZLE_TYPE_NEWDECIMAL,
349
377
    //DRIZZLE_TYPE_ENUM
350
378
    DRIZZLE_TYPE_VARCHAR,
351
379
    //DRIZZLE_TYPE_BLOB
352
380
    DRIZZLE_TYPE_BLOB,
353
 
    //DRIZZLE_TYPE_TIME
354
 
    DRIZZLE_TYPE_TIME,
355
 
    //DRIZZLE_TYPE_BOOLEAN
356
 
    DRIZZLE_TYPE_VARCHAR,
357
 
    //DRIZZLE_TYPE_UUID
358
 
    DRIZZLE_TYPE_VARCHAR,
359
 
    //DRIZZLE_TYPE_MICROTIME
360
 
    DRIZZLE_TYPE_VARCHAR,
361
381
  },
362
382
  /* DRIZZLE_TYPE_ENUM -> */
363
383
  {
 
384
    //DRIZZLE_TYPE_TINY
 
385
    DRIZZLE_TYPE_VARCHAR,
364
386
    //DRIZZLE_TYPE_LONG
365
387
    DRIZZLE_TYPE_VARCHAR,
366
388
    //DRIZZLE_TYPE_DOUBLE
377
399
    DRIZZLE_TYPE_VARCHAR,
378
400
    //DRIZZLE_TYPE_VARCHAR
379
401
    DRIZZLE_TYPE_VARCHAR,
380
 
    //DRIZZLE_TYPE_DECIMAL
 
402
    //DRIZZLE_TYPE_VIRTUAL
 
403
    DRIZZLE_TYPE_VIRTUAL,
 
404
    //DRIZZLE_TYPE_NEWDECIMAL
381
405
    DRIZZLE_TYPE_VARCHAR,
382
406
    //DRIZZLE_TYPE_ENUM
383
407
    DRIZZLE_TYPE_VARCHAR,
384
408
    //DRIZZLE_TYPE_BLOB
385
409
    DRIZZLE_TYPE_BLOB,
386
 
    //DRIZZLE_TYPE_TIME
387
 
    DRIZZLE_TYPE_TIME,
388
 
    //DRIZZLE_TYPE_BOOLEAN
389
 
    DRIZZLE_TYPE_VARCHAR,
390
 
    //DRIZZLE_TYPE_UUID
391
 
    DRIZZLE_TYPE_VARCHAR,
392
 
    //DRIZZLE_TYPE_MICROTIME
393
 
    DRIZZLE_TYPE_VARCHAR,
394
 
   },
 
410
  },
395
411
  /* DRIZZLE_TYPE_BLOB -> */
396
412
  {
 
413
    //DRIZZLE_TYPE_TINY
 
414
    DRIZZLE_TYPE_BLOB,
397
415
    //DRIZZLE_TYPE_LONG
398
416
    DRIZZLE_TYPE_BLOB,
399
417
    //DRIZZLE_TYPE_DOUBLE
410
428
    DRIZZLE_TYPE_BLOB,
411
429
    //DRIZZLE_TYPE_VARCHAR
412
430
    DRIZZLE_TYPE_BLOB,
413
 
    //DRIZZLE_TYPE_DECIMAL
 
431
    //DRIZZLE_TYPE_VIRTUAL
 
432
    DRIZZLE_TYPE_VIRTUAL,
 
433
    //DRIZZLE_TYPE_NEWDECIMAL
414
434
    DRIZZLE_TYPE_BLOB,
415
435
    //DRIZZLE_TYPE_ENUM
416
436
    DRIZZLE_TYPE_BLOB,
417
437
    //DRIZZLE_TYPE_BLOB
418
438
    DRIZZLE_TYPE_BLOB,
419
 
    //DRIZZLE_TYPE_TIME
420
 
    DRIZZLE_TYPE_TIME,
421
 
    //DRIZZLE_TYPE_BOOLEAN
422
 
    DRIZZLE_TYPE_VARCHAR,
423
 
    //DRIZZLE_TYPE_UUID
424
 
    DRIZZLE_TYPE_VARCHAR,
425
 
    //DRIZZLE_TYPE_MICROTIME
426
 
    DRIZZLE_TYPE_VARCHAR,
427
 
  },
428
 
  /* DRIZZLE_TYPE_TIME -> */
429
 
  {
430
 
    //DRIZZLE_TYPE_LONG
431
 
    DRIZZLE_TYPE_VARCHAR,
432
 
    //DRIZZLE_TYPE_DOUBLE
433
 
    DRIZZLE_TYPE_VARCHAR,
434
 
    //DRIZZLE_TYPE_NULL
435
 
    DRIZZLE_TYPE_TIME,
436
 
    //DRIZZLE_TYPE_TIMESTAMP
437
 
    DRIZZLE_TYPE_VARCHAR,
438
 
    //DRIZZLE_TYPE_LONGLONG
439
 
    DRIZZLE_TYPE_VARCHAR,
440
 
    //DRIZZLE_TYPE_DATETIME
441
 
    DRIZZLE_TYPE_VARCHAR,
442
 
    //DRIZZLE_TYPE_DATE
443
 
    DRIZZLE_TYPE_VARCHAR,
444
 
    //DRIZZLE_TYPE_VARCHAR
445
 
    DRIZZLE_TYPE_VARCHAR,
446
 
    //DRIZZLE_TYPE_DECIMAL
447
 
    DRIZZLE_TYPE_VARCHAR,
448
 
    //DRIZZLE_TYPE_VARCHAR,
449
 
    DRIZZLE_TYPE_VARCHAR,
450
 
    //DRIZZLE_TYPE_BLOB
451
 
    DRIZZLE_TYPE_BLOB,
452
 
    //DRIZZLE_TYPE_TIME
453
 
    DRIZZLE_TYPE_TIME,
454
 
    //DRIZZLE_TYPE_BOOLEAN
455
 
    DRIZZLE_TYPE_VARCHAR,
456
 
    //DRIZZLE_TYPE_UUID
457
 
    DRIZZLE_TYPE_UUID,
458
 
    //DRIZZLE_TYPE_MICROTIME
459
 
    DRIZZLE_TYPE_VARCHAR,
460
 
  },
461
 
  /* DRIZZLE_TYPE_BOOLEAN -> */
462
 
  {
463
 
    //DRIZZLE_TYPE_LONG
464
 
    DRIZZLE_TYPE_VARCHAR,
465
 
    //DRIZZLE_TYPE_DOUBLE
466
 
    DRIZZLE_TYPE_VARCHAR,
467
 
    //DRIZZLE_TYPE_NULL
468
 
    DRIZZLE_TYPE_BOOLEAN,
469
 
    //DRIZZLE_TYPE_TIMESTAMP
470
 
    DRIZZLE_TYPE_VARCHAR,
471
 
    //DRIZZLE_TYPE_LONGLONG
472
 
    DRIZZLE_TYPE_VARCHAR,
473
 
    //DRIZZLE_TYPE_DATETIME
474
 
    DRIZZLE_TYPE_VARCHAR,
475
 
    //DRIZZLE_TYPE_DATE
476
 
    DRIZZLE_TYPE_VARCHAR,
477
 
    //DRIZZLE_TYPE_VARCHAR
478
 
    DRIZZLE_TYPE_VARCHAR,
479
 
    //DRIZZLE_TYPE_DECIMAL
480
 
    DRIZZLE_TYPE_VARCHAR,
481
 
    //DRIZZLE_TYPE_VARCHAR,
482
 
    DRIZZLE_TYPE_VARCHAR,
483
 
    //DRIZZLE_TYPE_BLOB
484
 
    DRIZZLE_TYPE_BLOB,
485
 
    //DRIZZLE_TYPE_TIME
486
 
    DRIZZLE_TYPE_TIME,
487
 
    //DRIZZLE_TYPE_BOOLEAN
488
 
    DRIZZLE_TYPE_BOOLEAN,
489
 
    //DRIZZLE_TYPE_UUID
490
 
    DRIZZLE_TYPE_VARCHAR,
491
 
    //DRIZZLE_TYPE_MICROTIME
492
 
    DRIZZLE_TYPE_VARCHAR,
493
 
  },
494
 
  /* DRIZZLE_TYPE_UUID -> */
495
 
  {
496
 
    //DRIZZLE_TYPE_LONG
497
 
    DRIZZLE_TYPE_VARCHAR,
498
 
    //DRIZZLE_TYPE_DOUBLE
499
 
    DRIZZLE_TYPE_VARCHAR,
500
 
    //DRIZZLE_TYPE_NULL
501
 
    DRIZZLE_TYPE_UUID,
502
 
    //DRIZZLE_TYPE_TIMESTAMP
503
 
    DRIZZLE_TYPE_VARCHAR,
504
 
    //DRIZZLE_TYPE_LONGLONG
505
 
    DRIZZLE_TYPE_VARCHAR,
506
 
    //DRIZZLE_TYPE_DATETIME
507
 
    DRIZZLE_TYPE_VARCHAR,
508
 
    //DRIZZLE_TYPE_DATE
509
 
    DRIZZLE_TYPE_VARCHAR,
510
 
    //DRIZZLE_TYPE_VARCHAR
511
 
    DRIZZLE_TYPE_VARCHAR,
512
 
    //DRIZZLE_TYPE_DECIMAL
513
 
    DRIZZLE_TYPE_VARCHAR,
514
 
    //DRIZZLE_TYPE_VARCHAR,
515
 
    DRIZZLE_TYPE_VARCHAR,
516
 
    //DRIZZLE_TYPE_BLOB
517
 
    DRIZZLE_TYPE_BLOB,
518
 
    //DRIZZLE_TYPE_TIME
519
 
    DRIZZLE_TYPE_TIME,
520
 
    //DRIZZLE_TYPE_BOOLEAN
521
 
    DRIZZLE_TYPE_VARCHAR,
522
 
    //DRIZZLE_TYPE_UUID
523
 
    DRIZZLE_TYPE_UUID,
524
 
    //DRIZZLE_TYPE_MICROTIME
525
 
    DRIZZLE_TYPE_VARCHAR,
526
 
  },
527
 
  /* DRIZZLE_TYPE_MICROTIME -> */
528
 
  {
529
 
    //DRIZZLE_TYPE_LONG
530
 
    DRIZZLE_TYPE_VARCHAR,
531
 
    //DRIZZLE_TYPE_DOUBLE
532
 
    DRIZZLE_TYPE_VARCHAR,
533
 
    //DRIZZLE_TYPE_NULL
534
 
    DRIZZLE_TYPE_MICROTIME,
535
 
    //DRIZZLE_TYPE_TIMESTAMP
536
 
    DRIZZLE_TYPE_VARCHAR,
537
 
    //DRIZZLE_TYPE_LONGLONG
538
 
    DRIZZLE_TYPE_VARCHAR,
539
 
    //DRIZZLE_TYPE_DATETIME
540
 
    DRIZZLE_TYPE_VARCHAR,
541
 
    //DRIZZLE_TYPE_DATE
542
 
    DRIZZLE_TYPE_VARCHAR,
543
 
    //DRIZZLE_TYPE_VARCHAR
544
 
    DRIZZLE_TYPE_VARCHAR,
545
 
    //DRIZZLE_TYPE_DECIMAL
546
 
    DRIZZLE_TYPE_VARCHAR,
547
 
    //DRIZZLE_TYPE_VARCHAR,
548
 
    DRIZZLE_TYPE_VARCHAR,
549
 
    //DRIZZLE_TYPE_BLOB
550
 
    DRIZZLE_TYPE_BLOB,
551
 
    //DRIZZLE_TYPE_TIME
552
 
    DRIZZLE_TYPE_TIME,
553
 
    //DRIZZLE_TYPE_BOOLEAN
554
 
    DRIZZLE_TYPE_VARCHAR,
555
 
    //DRIZZLE_TYPE_UUID
556
 
    DRIZZLE_TYPE_UUID,
557
 
    //DRIZZLE_TYPE_MICROTIME
558
 
    DRIZZLE_TYPE_MICROTIME,
559
439
  },
560
440
};
561
441
 
562
 
static Item_result field_types_result_type [enum_field_types_size]=
563
 
{
 
442
/**
 
443
  Return type of which can carry value of both given types in UNION result.
 
444
 
 
445
  @param a  type for merging
 
446
  @param b  type for merging
 
447
 
 
448
  @return
 
449
    type of field
 
450
*/
 
451
 
 
452
enum_field_types Field::field_type_merge(enum_field_types a,
 
453
                                         enum_field_types b)
 
454
{
 
455
  assert(a <= DRIZZLE_TYPE_MAX);
 
456
  assert(b <= DRIZZLE_TYPE_MAX);
 
457
  return field_types_merge_rules[a][b];
 
458
}
 
459
 
 
460
 
 
461
static Item_result field_types_result_type [DRIZZLE_TYPE_MAX+1]=
 
462
{
 
463
  //DRIZZLE_TYPE_TINY
 
464
  INT_RESULT,
564
465
  //DRIZZLE_TYPE_LONG
565
466
  INT_RESULT,
566
467
  //DRIZZLE_TYPE_DOUBLE
577
478
  STRING_RESULT,
578
479
  //DRIZZLE_TYPE_VARCHAR
579
480
  STRING_RESULT,
580
 
  //DRIZZLE_TYPE_DECIMAL   
 
481
  //DRIZZLE_TYPE_VIRTUAL
 
482
  STRING_RESULT,
 
483
  //DRIZZLE_TYPE_NEWDECIMAL   
581
484
  DECIMAL_RESULT,           
582
485
  //DRIZZLE_TYPE_ENUM
583
486
  STRING_RESULT,
584
487
  //DRIZZLE_TYPE_BLOB
585
488
  STRING_RESULT,
586
 
  //DRIZZLE_TYPE_TIME
587
 
  STRING_RESULT,
588
 
  //DRIZZLE_TYPE_BOOLEAN
589
 
  STRING_RESULT,
590
 
  //DRIZZLE_TYPE_UUID
591
 
  STRING_RESULT,
592
 
  //DRIZZLE_TYPE_MICROTIME
593
 
  STRING_RESULT,
594
489
};
595
490
 
596
 
bool test_if_important_data(const CHARSET_INFO * const cs, 
597
 
                            const char *str,
598
 
                            const char *strend)
 
491
 
 
492
/*
 
493
  Test if the given string contains important data:
 
494
  not spaces for character string,
 
495
  or any data for binary string.
 
496
 
 
497
  SYNOPSIS
 
498
    test_if_important_data()
 
499
    cs          Character set
 
500
    str         String to test
 
501
    strend      String end
 
502
 
 
503
  RETURN
 
504
    false - If string does not have important data
 
505
    true  - If string has some important data
 
506
*/
 
507
 
 
508
bool
 
509
test_if_important_data(const CHARSET_INFO * const cs, const char *str,
 
510
                       const char *strend)
599
511
{
600
512
  if (cs != &my_charset_bin)
601
513
    str+= cs->cset->scan(cs, str, strend, MY_SEQ_SPACES);
602
514
  return (str < strend);
603
515
}
604
516
 
605
 
void *Field::operator new(size_t size)
606
 
{
607
 
  return memory::sql_alloc(size);
608
 
}
609
 
 
610
 
void *Field::operator new(size_t size, memory::Root *mem_root)
611
 
{
612
 
  return mem_root->alloc_root(static_cast<uint32_t>(size));
613
 
}
614
 
 
615
 
enum_field_types Field::field_type_merge(enum_field_types a,
616
 
                                         enum_field_types b)
617
 
{
618
 
  assert(a < enum_field_types_size);
619
 
  assert(b < enum_field_types_size);
620
 
  return field_types_merge_rules[a][b];
621
 
}
622
517
 
623
518
Item_result Field::result_merge_type(enum_field_types field_type)
624
519
{
625
 
  assert(field_type < enum_field_types_size);
 
520
  assert(field_type <= DRIZZLE_TYPE_MAX);
626
521
  return field_types_result_type[field_type];
627
522
}
628
523
 
 
524
 
629
525
bool Field::eq(Field *field)
630
526
{
631
527
  return (ptr == field->ptr && null_ptr == field->null_ptr &&
632
528
          null_bit == field->null_bit);
633
529
}
634
530
 
 
531
 
635
532
uint32_t Field::pack_length() const
636
533
{
637
534
  return field_length;
638
535
}
639
536
 
 
537
 
640
538
uint32_t Field::pack_length_in_rec() const
641
539
{
642
540
  return pack_length();
643
541
}
644
542
 
 
543
 
 
544
uint32_t Field::pack_length_from_metadata(uint32_t field_metadata)
 
545
{
 
546
  return field_metadata;
 
547
}
 
548
 
 
549
 
 
550
uint32_t Field::row_pack_length()
 
551
{
 
552
  return 0;
 
553
}
 
554
 
 
555
 
 
556
int Field::save_field_metadata(unsigned char *first_byte)
 
557
{
 
558
  return do_save_field_metadata(first_byte);
 
559
}
 
560
 
 
561
 
645
562
uint32_t Field::data_length()
646
563
{
647
564
  return pack_length();
648
565
}
649
566
 
 
567
 
650
568
uint32_t Field::used_length()
651
569
{
652
570
  return pack_length();
653
571
}
654
572
 
 
573
 
655
574
uint32_t Field::sort_length() const
656
575
{
657
576
  return pack_length();
658
577
}
659
578
 
 
579
 
660
580
uint32_t Field::max_data_length() const
661
581
{
662
582
  return pack_length();
663
583
}
664
584
 
 
585
 
665
586
int Field::reset(void)
666
587
{
667
588
  memset(ptr, 0, pack_length());
668
589
  return 0;
669
590
}
670
591
 
 
592
 
671
593
void Field::reset_fields()
672
594
{}
673
595
 
 
596
 
674
597
void Field::set_default()
675
598
{
676
 
  ptrdiff_t l_offset= (ptrdiff_t) (table->getDefaultValues() - table->getInsertRecord());
 
599
  my_ptrdiff_t l_offset= (my_ptrdiff_t) (table->getDefaultValues() - table->record[0]);
677
600
  memcpy(ptr, ptr + l_offset, pack_length());
678
601
  if (null_ptr)
679
602
    *null_ptr= ((*null_ptr & (unsigned char) ~null_bit) | (null_ptr[l_offset] & null_bit));
680
 
 
681
 
  if (this == table->next_number_field)
682
 
    table->auto_increment_field_not_null= false;
683
603
}
684
604
 
 
605
 
685
606
bool Field::binary() const
686
607
{
687
 
  return true;
 
608
  return 1;
688
609
}
689
610
 
 
611
 
690
612
bool Field::zero_pack() const
691
613
{
692
 
  return true;
 
614
  return 1;
693
615
}
694
616
 
 
617
 
695
618
enum ha_base_keytype Field::key_type() const
696
619
{
697
620
  return HA_KEYTYPE_BINARY;
698
621
}
699
622
 
 
623
 
700
624
uint32_t Field::key_length() const
701
625
{
702
626
  return pack_length();
703
627
}
704
628
 
 
629
 
705
630
enum_field_types Field::real_type() const
706
631
{
707
632
  return type();
708
633
}
709
634
 
 
635
 
710
636
int Field::cmp_max(const unsigned char *a, const unsigned char *b, uint32_t)
711
637
{
712
638
  return cmp(a, b);
713
639
}
714
640
 
 
641
 
715
642
int Field::cmp_binary(const unsigned char *a,const unsigned char *b, uint32_t)
716
643
{
717
644
  return memcmp(a,b,pack_length());
718
645
}
719
646
 
 
647
 
720
648
int Field::cmp_offset(uint32_t row_offset)
721
649
{
722
650
  return cmp(ptr,ptr+row_offset);
723
651
}
724
652
 
 
653
 
725
654
int Field::cmp_binary_offset(uint32_t row_offset)
726
655
{
727
656
  return cmp_binary(ptr, ptr+row_offset);
728
657
}
729
658
 
 
659
 
730
660
int Field::key_cmp(const unsigned char *a,const unsigned char *b)
731
661
{
732
662
  return cmp(a, b);
733
663
}
734
664
 
 
665
 
735
666
int Field::key_cmp(const unsigned char *str, uint32_t)
736
667
{
737
668
  return cmp(ptr,str);
738
669
}
739
670
 
 
671
 
740
672
uint32_t Field::decimals() const
741
673
{
742
674
  return 0;
743
675
}
744
676
 
745
 
bool Field::is_null(ptrdiff_t row_offset)
 
677
 
 
678
bool Field::is_null(my_ptrdiff_t row_offset)
746
679
{
747
680
  return null_ptr ?
748
681
    (null_ptr[row_offset] & null_bit ? true : false) :
749
682
    table->null_row;
750
683
}
751
684
 
752
 
bool Field::is_real_null(ptrdiff_t row_offset)
 
685
 
 
686
bool Field::is_real_null(my_ptrdiff_t row_offset)
753
687
{
754
688
  return null_ptr ? (null_ptr[row_offset] & null_bit ? true : false) : false;
755
689
}
756
690
 
 
691
 
757
692
bool Field::is_null_in_record(const unsigned char *record)
758
693
{
759
 
  if (! null_ptr)
 
694
  if (!null_ptr)
760
695
    return false;
761
 
  return test(record[(uint32_t) (null_ptr -table->getInsertRecord())] & null_bit);
 
696
  return test(record[(uint32_t) (null_ptr -table->record[0])] &
 
697
              null_bit);
762
698
}
763
699
 
764
 
bool Field::is_null_in_record_with_offset(ptrdiff_t with_offset)
 
700
 
 
701
bool Field::is_null_in_record_with_offset(my_ptrdiff_t with_offset)
765
702
{
766
 
  if (! null_ptr)
 
703
  if (!null_ptr)
767
704
    return false;
768
705
  return test(null_ptr[with_offset] & null_bit);
769
706
}
770
707
 
771
 
void Field::set_null(ptrdiff_t row_offset)
 
708
 
 
709
void Field::set_null(my_ptrdiff_t row_offset)
772
710
{
773
711
  if (null_ptr)
774
712
    null_ptr[row_offset]|= null_bit;
775
713
}
776
714
 
777
 
void Field::set_notnull(ptrdiff_t row_offset)
 
715
 
 
716
void Field::set_notnull(my_ptrdiff_t row_offset)
778
717
{
779
718
  if (null_ptr)
780
719
    null_ptr[row_offset]&= (unsigned char) ~null_bit;
781
720
}
782
721
 
 
722
 
783
723
bool Field::maybe_null(void)
784
724
{
785
725
  return null_ptr != 0 || table->maybe_null;
786
726
}
787
727
 
 
728
 
788
729
bool Field::real_maybe_null(void)
789
730
{
790
731
  return null_ptr != 0;
791
732
}
792
733
 
 
734
 
 
735
size_t Field::last_null_byte() const
 
736
{
 
737
  size_t bytes= do_last_null_byte();
 
738
  assert(bytes <= table->getNullBytes());
 
739
  return bytes;
 
740
}
 
741
 
 
742
 
 
743
/*****************************************************************************
 
744
  Static help functions
 
745
*****************************************************************************/
 
746
 
793
747
bool Field::type_can_have_key_part(enum enum_field_types type)
794
748
{
795
749
  switch (type) {
801
755
  }
802
756
}
803
757
 
 
758
 
 
759
/**
 
760
  Process decimal library return codes and issue warnings for overflow and
 
761
  truncation.
 
762
 
 
763
  @param op_result  decimal library return code (E_DEC_* see include/decimal.h)
 
764
 
 
765
  @retval
 
766
    E_DEC_OVERFLOW   there was overflow
 
767
    E_DEC_TRUNCATED  there was truncation
 
768
  @retval
 
769
    0  no error or there was some other error except overflow or truncation
 
770
*/
 
771
 
804
772
int Field::warn_if_overflow(int op_result)
805
773
{
806
774
  if (op_result == E_DEC_OVERFLOW)
816
784
  return 0;
817
785
}
818
786
 
 
787
 
819
788
void Field::init(Table *table_arg)
820
789
{
821
790
  orig_table= table= table_arg;
822
 
}
 
791
  table_name= &table_arg->alias;
 
792
}
 
793
 
 
794
 
 
795
#ifdef NOT_USED
 
796
static bool test_if_real(const char *str,int length, const CHARSET_INFO * const cs)
 
797
{
 
798
  cs= system_charset_info; // QQ move test_if_real into CHARSET_INFO struct
 
799
 
 
800
  while (length && my_isspace(cs,*str))
 
801
  {                                             // Allow start space
 
802
    length--; str++;
 
803
  }
 
804
  if (!length)
 
805
    return 0;
 
806
  if (*str == '+' || *str == '-')
 
807
  {
 
808
    length--; str++;
 
809
    if (!length || !(my_isdigit(cs,*str) || *str == '.'))
 
810
      return 0;
 
811
  }
 
812
  while (length && my_isdigit(cs,*str))
 
813
  {
 
814
    length--; str++;
 
815
  }
 
816
  if (!length)
 
817
    return 1;
 
818
  if (*str == '.')
 
819
  {
 
820
    length--; str++;
 
821
    while (length && my_isdigit(cs,*str))
 
822
    {
 
823
      length--; str++;
 
824
    }
 
825
  }
 
826
  if (!length)
 
827
    return 1;
 
828
  if (*str == 'E' || *str == 'e')
 
829
  {
 
830
    if (length < 3 || (str[1] != '+' && str[1] != '-') ||
 
831
        !my_isdigit(cs,str[2]))
 
832
      return 0;
 
833
    length-=3;
 
834
    str+=3;
 
835
    while (length && my_isdigit(cs,*str))
 
836
    {
 
837
      length--; str++;
 
838
    }
 
839
  }
 
840
  for (; length ; length--, str++)
 
841
  {                                             // Allow end space
 
842
    if (!my_isspace(cs,*str))
 
843
      return 0;
 
844
  }
 
845
  return 1;
 
846
}
 
847
#endif
 
848
 
 
849
 
 
850
/**
 
851
  Interpret field value as an integer but return the result as a string.
 
852
 
 
853
  This is used for printing bit_fields as numbers while debugging.
 
854
*/
 
855
 
 
856
String *Field::val_int_as_str(String *val_buffer, bool unsigned_val)
 
857
{
 
858
  const CHARSET_INFO * const cs= &my_charset_bin;
 
859
  uint32_t length;
 
860
  int64_t value= val_int();
 
861
 
 
862
  if (val_buffer->alloc(MY_INT64_NUM_DECIMAL_DIGITS))
 
863
    return 0;
 
864
  length= (uint32_t) (*cs->cset->int64_t10_to_str)(cs, (char*) val_buffer->ptr(),
 
865
                                                MY_INT64_NUM_DECIMAL_DIGITS,
 
866
                                                unsigned_val ? 10 : -10,
 
867
                                                value);
 
868
  val_buffer->length(length);
 
869
  return val_buffer;
 
870
}
 
871
 
823
872
 
824
873
/// This is used as a table name when the table structure is not set up
825
 
Field::Field(unsigned char *ptr_arg,
826
 
             uint32_t length_arg,
827
 
             unsigned char *null_ptr_arg,
 
874
Field::Field(unsigned char *ptr_arg,uint32_t length_arg,unsigned char *null_ptr_arg,
828
875
             unsigned char null_bit_arg,
829
 
             utype unireg_check_arg, 
830
 
             const char *field_name_arg) :
831
 
    ptr(ptr_arg),
832
 
    null_ptr(null_ptr_arg),
833
 
    table(NULL),
834
 
    orig_table(NULL),
835
 
    field_name(field_name_arg),
836
 
    comment(NULL_LEX_STRING),
837
 
    key_start(0),
838
 
    part_of_key(0),
839
 
    part_of_key_not_clustered(0),
840
 
    part_of_sortkey(0),
841
 
    unireg_check(unireg_check_arg),
842
 
    field_length(length_arg),
843
 
    flags(null_ptr ? 0: NOT_NULL_FLAG),
844
 
    field_index(0),
845
 
    null_bit(null_bit_arg),
846
 
    is_created_from_null_item(false)
 
876
             utype unireg_check_arg, const char *field_name_arg)
 
877
  :ptr(ptr_arg), null_ptr(null_ptr_arg),
 
878
   table(0), orig_table(0), table_name(0),
 
879
   field_name(field_name_arg),
 
880
   key_start(0), part_of_key(0), part_of_key_not_clustered(0),
 
881
   part_of_sortkey(0), unireg_check(unireg_check_arg),
 
882
   field_length(length_arg), null_bit(null_bit_arg),
 
883
   is_created_from_null_item(false),
 
884
   vcol_info(NULL), is_stored(true)
847
885
{
 
886
  flags=null_ptr ? 0: NOT_NULL_FLAG;
 
887
  comment.str= (char*) "";
 
888
  comment.length=0;
 
889
  field_index= 0;
848
890
}
849
891
 
 
892
 
850
893
void Field::hash(uint32_t *nr, uint32_t *nr2)
851
894
{
852
895
  if (is_null())
861
904
  }
862
905
}
863
906
 
 
907
size_t
 
908
Field::do_last_null_byte() const
 
909
{
 
910
  assert(null_ptr == NULL || null_ptr >= table->record[0]);
 
911
  if (null_ptr)
 
912
    return (size_t) (null_ptr - table->record[0]) + 1;
 
913
  return LAST_NULL_BYTE_UNDEF;
 
914
}
 
915
 
 
916
 
864
917
void Field::copy_from_tmp(int row_offset)
865
918
{
866
919
  memcpy(ptr,ptr+row_offset,pack_length());
873
926
  }
874
927
}
875
928
 
876
 
int Field::store_and_check(enum_check_fields check_level,
877
 
                           const char *to, 
878
 
                           uint32_t length,
879
 
                           const CHARSET_INFO * const cs)
880
 
 
 
929
/**
 
930
   Check to see if field size is compatible with destination.
 
931
 
 
932
   This method is used in row-based replication to verify that the slave's
 
933
   field size is less than or equal to the master's field size. The
 
934
   encoded field metadata (from the master or source) is decoded and compared
 
935
   to the size of this field (the slave or destination).
 
936
 
 
937
   @param   field_metadata   Encoded size in field metadata
 
938
 
 
939
   @retval 0 if this field's size is < the source field's size
 
940
   @retval 1 if this field's size is >= the source field's size
 
941
*/
 
942
int Field::compatible_field_size(uint32_t field_metadata)
 
943
{
 
944
  uint32_t const source_size= pack_length_from_metadata(field_metadata);
 
945
  uint32_t const destination_size= row_pack_length();
 
946
  return (source_size <= destination_size);
 
947
}
 
948
 
 
949
 
 
950
int Field::store(const char *to, uint32_t length,
 
951
                 const CHARSET_INFO * const cs,
 
952
                 enum_check_fields check_level)
881
953
{
882
954
  int res;
883
955
  enum_check_fields old_check_level= table->in_use->count_cuted_fields;
887
959
  return res;
888
960
}
889
961
 
890
 
unsigned char *Field::pack(unsigned char *to, const unsigned char *from, uint32_t max_length, bool)
 
962
 
 
963
/**
 
964
   Pack the field into a format suitable for storage and transfer.
 
965
 
 
966
   To implement packing functionality, only the virtual function
 
967
   should be overridden. The other functions are just convenience
 
968
   functions and hence should not be overridden.
 
969
 
 
970
   The value of <code>low_byte_first</code> is dependent on how the
 
971
   packed data is going to be used: for local use, e.g., temporary
 
972
   store on disk or in memory, use the native format since that is
 
973
   faster. For data that is going to be transfered to other machines
 
974
   (e.g., when writing data to the binary log), data should always be
 
975
   stored in little-endian format.
 
976
 
 
977
   @note The default method for packing fields just copy the raw bytes
 
978
   of the record into the destination, but never more than
 
979
   <code>max_length</code> characters.
 
980
 
 
981
   @param to
 
982
   Pointer to memory area where representation of field should be put.
 
983
 
 
984
   @param from
 
985
   Pointer to memory area where record representation of field is
 
986
   stored.
 
987
 
 
988
   @param max_length
 
989
   Maximum length of the field, as given in the column definition. For
 
990
   example, for <code>CHAR(1000)</code>, the <code>max_length</code>
 
991
   is 1000. This information is sometimes needed to decide how to pack
 
992
   the data.
 
993
 
 
994
   @param low_byte_first
 
995
   @c true if integers should be stored little-endian, @c false if
 
996
   native format should be used. Note that for little-endian machines,
 
997
   the value of this flag is a moot point since the native format is
 
998
   little-endian.
 
999
*/
 
1000
unsigned char *
 
1001
Field::pack(unsigned char *to, const unsigned char *from, uint32_t max_length,
 
1002
            bool)
891
1003
{
892
1004
  uint32_t length= pack_length();
893
1005
  set_if_smaller(length, max_length);
895
1007
  return to+length;
896
1008
}
897
1009
 
 
1010
 
898
1011
unsigned char *Field::pack(unsigned char *to, const unsigned char *from)
899
1012
{
900
 
  unsigned char *result= this->pack(to, from, UINT32_MAX, table->getShare()->db_low_byte_first);
 
1013
  unsigned char *result= this->pack(to, from, UINT32_MAX,
 
1014
                                    table->s->db_low_byte_first);
901
1015
  return(result);
902
1016
}
903
1017
 
904
 
const unsigned char *Field::unpack(unsigned char* to,
905
 
                                   const unsigned char *from, 
906
 
                                   uint32_t param_data,
907
 
                                   bool)
 
1018
 
 
1019
/**
 
1020
   Unpack a field from row data.
 
1021
 
 
1022
   This method is used to unpack a field from a master whose size of
 
1023
   the field is less than that of the slave.
 
1024
 
 
1025
   The <code>param_data</code> parameter is a two-byte integer (stored
 
1026
   in the least significant 16 bits of the unsigned integer) usually
 
1027
   consisting of two parts: the real type in the most significant byte
 
1028
   and a original pack length in the least significant byte.
 
1029
 
 
1030
   The exact layout of the <code>param_data</code> field is given by
 
1031
   the <code>Table_map_log_event::save_field_metadata()</code>.
 
1032
 
 
1033
   This is the default method for unpacking a field. It just copies
 
1034
   the memory block in byte order (of original pack length bytes or
 
1035
   length of field, whichever is smaller).
 
1036
 
 
1037
   @param   to         Destination of the data
 
1038
   @param   from       Source of the data
 
1039
   @param   param_data Real type and original pack length of the field
 
1040
                       data
 
1041
 
 
1042
   @param low_byte_first
 
1043
   If this flag is @c true, all composite entities (e.g., lengths)
 
1044
   should be unpacked in little-endian format; otherwise, the entities
 
1045
   are unpacked in native order.
 
1046
 
 
1047
   @return  New pointer into memory based on from + length of the data
 
1048
*/
 
1049
const unsigned char *
 
1050
Field::unpack(unsigned char* to, const unsigned char *from, uint32_t param_data,
 
1051
              bool)
908
1052
{
909
1053
  uint32_t length=pack_length();
910
1054
  int from_type= 0;
930
1074
            param_data : length;
931
1075
 
932
1076
  memcpy(to, from, param_data > length ? length : len);
933
 
  return (from + len);
 
1077
  return from+len;
934
1078
}
935
1079
 
936
 
const unsigned char *Field::unpack(unsigned char* to, const unsigned char *from)
 
1080
 
 
1081
const unsigned char *Field::unpack(unsigned char* to,
 
1082
                                   const unsigned char *from)
937
1083
{
938
 
  const unsigned char *result= unpack(to, from, 0U, table->getShare()->db_low_byte_first);
 
1084
  const unsigned char *result= unpack(to, from, 0U,
 
1085
                                      table->s->db_low_byte_first);
939
1086
  return(result);
940
1087
}
941
1088
 
942
 
type::Decimal *Field::val_decimal(type::Decimal *)
 
1089
 
 
1090
uint32_t Field::packed_col_length(const unsigned char *, uint32_t length)
 
1091
{
 
1092
  return length;
 
1093
}
 
1094
 
 
1095
 
 
1096
int Field::pack_cmp(const unsigned char *a, const unsigned char *b,
 
1097
                    uint32_t, bool)
 
1098
{
 
1099
  return cmp(a,b);
 
1100
}
 
1101
 
 
1102
 
 
1103
int Field::pack_cmp(const unsigned char *b, uint32_t, bool)
 
1104
{
 
1105
  return cmp(ptr,b);
 
1106
}
 
1107
 
 
1108
 
 
1109
my_decimal *Field::val_decimal(my_decimal *)
943
1110
{
944
1111
  /* This never have to be called */
945
1112
  assert(0);
947
1114
}
948
1115
 
949
1116
 
950
 
void Field::make_field(SendField *field)
 
1117
void Field::make_field(Send_field *field)
951
1118
{
952
 
  if (orig_table && orig_table->getShare()->getSchemaName() && *orig_table->getShare()->getSchemaName())
 
1119
  if (orig_table && orig_table->s->db.str && *orig_table->s->db.str)
953
1120
  {
954
 
    field->db_name= orig_table->getShare()->getSchemaName();
955
 
    field->org_table_name= orig_table->getShare()->getTableName();
 
1121
    field->db_name= orig_table->s->db.str;
 
1122
    field->org_table_name= orig_table->s->table_name.str;
956
1123
  }
957
1124
  else
958
1125
    field->org_table_name= field->db_name= "";
959
1126
  if (orig_table)
960
1127
  {
961
 
    field->table_name= orig_table->getAlias();
 
1128
    field->table_name= orig_table->alias;
962
1129
    field->org_col_name= field_name;
963
1130
  }
964
1131
  else
968
1135
  }
969
1136
  field->col_name= field_name;
970
1137
  field->charsetnr= charset()->number;
971
 
  field->length= field_length;
972
 
  field->type= type();
973
 
  field->flags= table->maybe_null ? (flags & ~NOT_NULL_FLAG) : flags;
 
1138
  field->length=field_length;
 
1139
  field->type=type();
 
1140
  field->flags=table->maybe_null ? (flags & ~NOT_NULL_FLAG) : flags;
974
1141
  field->decimals= 0;
975
1142
}
976
1143
 
977
 
int64_t Field::convert_decimal2int64_t(const type::Decimal *val, bool, int *err)
 
1144
 
 
1145
/**
 
1146
  Conversion from decimal to int64_t with checking overflow and
 
1147
  setting correct value (min/max) in case of overflow.
 
1148
 
 
1149
  @param val             value which have to be converted
 
1150
  @param unsigned_flag   type of integer in which we convert val
 
1151
  @param err             variable to pass error code
 
1152
 
 
1153
  @return
 
1154
    value converted from val
 
1155
*/
 
1156
int64_t Field::convert_decimal2int64_t(const my_decimal *val, bool, int *err)
978
1157
{
979
1158
  int64_t i;
980
 
  if (warn_if_overflow(val->val_int32(E_DEC_ERROR &
 
1159
  if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
981
1160
                                      ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
982
 
                                      false, &i)))
 
1161
                                      val, false, &i)))
983
1162
  {
984
1163
    i= (val->sign() ? INT64_MIN : INT64_MAX);
985
1164
    *err= 1;
987
1166
  return i;
988
1167
}
989
1168
 
990
 
uint32_t Field::fill_cache_field(CacheField *copy)
 
1169
uint32_t Field::fill_cache_field(CACHE_FIELD *copy)
991
1170
{
992
1171
  uint32_t store_length;
993
1172
  copy->str=ptr;
997
1176
  {
998
1177
    copy->blob_field=(Field_blob*) this;
999
1178
    copy->strip=0;
1000
 
    copy->length-= table->getShare()->sizeBlobPtr();
 
1179
    copy->length-= table->s->blob_ptr_size;
1001
1180
    return copy->length;
1002
1181
  }
1003
1182
  else
1008
1187
  return copy->length+ store_length;
1009
1188
}
1010
1189
 
1011
 
bool Field::get_date(type::Time &ltime, uint32_t fuzzydate)
1012
 
{
1013
 
  char buff[type::Time::MAX_STRING_LENGTH];
1014
 
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
1015
 
 
1016
 
  assert(getTable() and getTable()->getSession());
1017
 
 
1018
 
  if (not (res=val_str_internal(&tmp)) or
1019
 
      str_to_datetime_with_warn(getTable()->getSession(),
1020
 
                                res->ptr(), res->length(),
1021
 
                                &ltime, fuzzydate) <= type::DRIZZLE_TIMESTAMP_ERROR)
1022
 
  {
1023
 
    return true;
1024
 
  }
1025
 
 
1026
 
  return false;
1027
 
}
1028
 
 
1029
 
bool Field::get_time(type::Time &ltime)
1030
 
{
1031
 
  char buff[type::Time::MAX_STRING_LENGTH];
1032
 
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
1033
 
 
1034
 
  if (not (res= val_str_internal(&tmp)) or
1035
 
      str_to_time_with_warn(getTable()->getSession(), res->ptr(), res->length(), &ltime))
1036
 
  {
1037
 
    return true;
1038
 
  }
1039
 
 
1040
 
  return false;
1041
 
}
1042
 
 
1043
 
int Field::store_time(type::Time &ltime, type::timestamp_t)
1044
 
{
1045
 
  String tmp;
1046
 
 
1047
 
  ltime.convert(tmp);
1048
 
 
1049
 
  return store(tmp.ptr(), tmp.length(), &my_charset_bin);
1050
 
}
1051
 
 
1052
 
bool Field::optimize_range(uint32_t idx, uint32_t)
1053
 
{
1054
 
  return test(table->index_flags(idx) & HA_READ_RANGE);
1055
 
}
1056
 
 
1057
 
Field *Field::new_field(memory::Root *root, Table *new_table, bool)
 
1190
 
 
1191
bool Field::get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
 
1192
{
 
1193
  char buff[40];
 
1194
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
 
1195
  if (!(res=val_str(&tmp)) ||
 
1196
      str_to_datetime_with_warn(res->ptr(), res->length(),
 
1197
                                ltime, fuzzydate) <= DRIZZLE_TIMESTAMP_ERROR)
 
1198
    return 1;
 
1199
  return 0;
 
1200
}
 
1201
 
 
1202
bool Field::get_time(DRIZZLE_TIME *ltime)
 
1203
{
 
1204
  char buff[40];
 
1205
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
 
1206
  if (!(res=val_str(&tmp)) ||
 
1207
      str_to_time_with_warn(res->ptr(), res->length(), ltime))
 
1208
    return 1;
 
1209
  return 0;
 
1210
}
 
1211
 
 
1212
/**
 
1213
  This is called when storing a date in a string.
 
1214
 
 
1215
  @note
 
1216
    Needs to be changed if/when we want to support different time formats.
 
1217
*/
 
1218
 
 
1219
int Field::store_time(DRIZZLE_TIME *ltime, enum enum_drizzle_timestamp_type)
 
1220
{
 
1221
  char buff[MAX_DATE_STRING_REP_LENGTH];
 
1222
  uint32_t length= (uint32_t) my_TIME_to_str(ltime, buff);
 
1223
  return store(buff, length, &my_charset_bin);
 
1224
}
 
1225
 
 
1226
 
 
1227
bool Field::optimize_range(uint32_t idx, uint32_t part)
 
1228
{
 
1229
  return test(table->file->index_flags(idx, part, 1) & HA_READ_RANGE);
 
1230
}
 
1231
 
 
1232
 
 
1233
Field *Field::new_field(MEM_ROOT *root, Table *new_table, bool)
1058
1234
{
1059
1235
  Field *tmp;
1060
 
  if (!(tmp= (Field*) root->memdup_root((char*) this,size_of())))
 
1236
  if (!(tmp= (Field*) memdup_root(root,(char*) this,size_of())))
1061
1237
    return 0;
1062
1238
 
1063
1239
  if (tmp->table->maybe_null)
1064
1240
    tmp->flags&= ~NOT_NULL_FLAG;
1065
1241
  tmp->table= new_table;
1066
 
  tmp->key_start.reset();
1067
 
  tmp->part_of_key.reset();
1068
 
  tmp->part_of_sortkey.reset();
 
1242
  tmp->key_start.init(0);
 
1243
  tmp->part_of_key.init(0);
 
1244
  tmp->part_of_sortkey.init(0);
1069
1245
  tmp->unireg_check= Field::NONE;
1070
 
  tmp->flags&= (NOT_NULL_FLAG | BLOB_FLAG | UNSIGNED_FLAG | BINARY_FLAG | ENUM_FLAG);
 
1246
  tmp->flags&= (NOT_NULL_FLAG | BLOB_FLAG | UNSIGNED_FLAG | BINARY_FLAG | ENUM_FLAG | SET_FLAG);
1071
1247
  tmp->reset_fields();
1072
1248
  return tmp;
1073
1249
}
1074
1250
 
1075
 
Field *Field::new_key_field(memory::Root *root, Table *new_table,
1076
 
                            unsigned char *new_ptr,
1077
 
                            unsigned char *new_null_ptr,
 
1251
 
 
1252
Field *Field::new_key_field(MEM_ROOT *root, Table *new_table,
 
1253
                            unsigned char *new_ptr, unsigned char *new_null_ptr,
1078
1254
                            uint32_t new_null_bit)
1079
1255
{
1080
1256
  Field *tmp;
1081
1257
  if ((tmp= new_field(root, new_table, table == new_table)))
1082
1258
  {
1083
 
    tmp->ptr= new_ptr;
 
1259
    tmp->ptr=      new_ptr;
1084
1260
    tmp->null_ptr= new_null_ptr;
1085
1261
    tmp->null_bit= new_null_bit;
1086
1262
  }
1087
1263
  return tmp;
1088
1264
}
1089
1265
 
1090
 
Field *Field::clone(memory::Root *root, Table *new_table)
 
1266
 
 
1267
/* This is used to generate a field in Table from TABLE_SHARE */
 
1268
 
 
1269
Field *Field::clone(MEM_ROOT *root, Table *new_table)
1091
1270
{
1092
1271
  Field *tmp;
1093
 
  if ((tmp= (Field*) root->memdup_root((char*) this,size_of())))
 
1272
  if ((tmp= (Field*) memdup_root(root,(char*) this,size_of())))
1094
1273
  {
1095
1274
    tmp->init(new_table);
1096
 
    tmp->move_field_offset((ptrdiff_t) (new_table->getInsertRecord() -
1097
 
                                           new_table->getDefaultValues()));
 
1275
    tmp->move_field_offset((my_ptrdiff_t) (new_table->record[0] -
 
1276
                                           new_table->s->default_values));
1098
1277
  }
1099
1278
  return tmp;
1100
1279
}
1101
1280
 
1102
1281
 
1103
 
uint32_t Field::is_equal(CreateField *new_field_ptr)
 
1282
uint32_t Field::is_equal(Create_field *new_field_ptr)
1104
1283
{
1105
1284
  return (new_field_ptr->sql_type == real_type());
1106
1285
}
1107
1286
 
 
1287
/**
 
1288
  @retval
 
1289
    1  if the fields are equally defined
 
1290
  @retval
 
1291
    0  if the fields are unequally defined
 
1292
*/
 
1293
 
1108
1294
bool Field::eq_def(Field *field)
1109
1295
{
1110
1296
  if (real_type() != field->real_type() || charset() != field->charset() ||
1113
1299
  return 1;
1114
1300
}
1115
1301
 
 
1302
/**
 
1303
  @return
 
1304
  returns 1 if the fields are equally defined
 
1305
*/
1116
1306
bool Field_enum::eq_def(Field *field)
1117
1307
{
1118
1308
  if (!Field::eq_def(field))
1119
1309
    return 0;
1120
 
 
1121
1310
  TYPELIB *from_lib=((Field_enum*) field)->typelib;
1122
1311
 
1123
1312
  if (typelib->count < from_lib->count)
1124
1313
    return 0;
1125
 
 
1126
1314
  for (uint32_t i=0 ; i < from_lib->count ; i++)
1127
 
  {
1128
1315
    if (my_strnncoll(field_charset,
1129
1316
                     (const unsigned char*)typelib->type_names[i],
1130
1317
                     strlen(typelib->type_names[i]),
1131
1318
                     (const unsigned char*)from_lib->type_names[i],
1132
1319
                     strlen(from_lib->type_names[i])))
1133
1320
      return 0;
1134
 
  }
1135
 
 
1136
1321
  return 1;
1137
1322
}
1138
1323
 
 
1324
/*****************************************************************************
 
1325
  Handling of field and Create_field
 
1326
*****************************************************************************/
 
1327
 
 
1328
/**
 
1329
  Convert create_field::length from number of characters to number of bytes.
 
1330
*/
 
1331
 
 
1332
void Create_field::create_length_to_internal_length(void)
 
1333
{
 
1334
  switch (sql_type) {
 
1335
  case DRIZZLE_TYPE_BLOB:
 
1336
  case DRIZZLE_TYPE_VARCHAR:
 
1337
    length*= charset->mbmaxlen;
 
1338
    key_length= length;
 
1339
    pack_length= calc_pack_length(sql_type, length);
 
1340
    break;
 
1341
  case DRIZZLE_TYPE_ENUM:
 
1342
    /* Pack_length already calculated in ::init() */
 
1343
    length*= charset->mbmaxlen;
 
1344
    key_length= pack_length;
 
1345
    break;
 
1346
  case DRIZZLE_TYPE_NEWDECIMAL:
 
1347
    key_length= pack_length=
 
1348
      my_decimal_get_binary_size(my_decimal_length_to_precision(length,
 
1349
                                                                decimals,
 
1350
                                                                flags &
 
1351
                                                                UNSIGNED_FLAG),
 
1352
                                 decimals);
 
1353
    break;
 
1354
  default:
 
1355
    key_length= pack_length= calc_pack_length(sql_type, length);
 
1356
    break;
 
1357
  }
 
1358
}
 
1359
 
 
1360
 
 
1361
/**
 
1362
  Init for a tmp table field. To be extended if need be.
 
1363
*/
 
1364
void Create_field::init_for_tmp_table(enum_field_types sql_type_arg,
 
1365
                                      uint32_t length_arg, uint32_t decimals_arg,
 
1366
                                      bool maybe_null, bool is_unsigned)
 
1367
{
 
1368
  field_name= "";
 
1369
  sql_type= sql_type_arg;
 
1370
  char_length= length= length_arg;;
 
1371
  unireg_check= Field::NONE;
 
1372
  interval= 0;
 
1373
  charset= &my_charset_bin;
 
1374
  pack_flag= (FIELDFLAG_NUMBER |
 
1375
              ((decimals_arg & FIELDFLAG_MAX_DEC) << FIELDFLAG_DEC_SHIFT) |
 
1376
              (maybe_null ? FIELDFLAG_MAYBE_NULL : 0) |
 
1377
              (is_unsigned ? 0 : FIELDFLAG_DECIMAL));
 
1378
  vcol_info= NULL;
 
1379
  is_stored= true;
 
1380
}
 
1381
 
 
1382
 
 
1383
/**
 
1384
  Initialize field definition for create.
 
1385
 
 
1386
  @param session                   Thread handle
 
1387
  @param fld_name              Field name
 
1388
  @param fld_type              Field type
 
1389
  @param fld_length            Field length
 
1390
  @param fld_decimals          Decimal (if any)
 
1391
  @param fld_type_modifier     Additional type information
 
1392
  @param fld_default_value     Field default value (if any)
 
1393
  @param fld_on_update_value   The value of ON UPDATE clause
 
1394
  @param fld_comment           Field comment
 
1395
  @param fld_change            Field change
 
1396
  @param fld_interval_list     Interval list (if any)
 
1397
  @param fld_charset           Field charset
 
1398
  @param fld_vcol_info         Virtual column data
 
1399
 
 
1400
  @retval
 
1401
    false on success
 
1402
  @retval
 
1403
    true  on error
 
1404
*/
 
1405
 
 
1406
bool Create_field::init(Session *, char *fld_name, enum_field_types fld_type,
 
1407
                        char *fld_length, char *fld_decimals,
 
1408
                        uint32_t fld_type_modifier, Item *fld_default_value,
 
1409
                        Item *fld_on_update_value, LEX_STRING *fld_comment,
 
1410
                        char *fld_change, List<String> *fld_interval_list,
 
1411
                        const CHARSET_INFO * const fld_charset,
 
1412
                        uint32_t, enum column_format_type column_format_in,
 
1413
                        virtual_column_info *fld_vcol_info)
 
1414
{
 
1415
  uint32_t sign_len, allowed_type_modifier= 0;
 
1416
  uint32_t max_field_charlength= MAX_FIELD_CHARLENGTH;
 
1417
 
 
1418
  field= 0;
 
1419
  field_name= fld_name;
 
1420
  def= fld_default_value;
 
1421
  flags= fld_type_modifier;
 
1422
  flags|= (((uint32_t)column_format_in & COLUMN_FORMAT_MASK) << COLUMN_FORMAT_FLAGS);
 
1423
  unireg_check= (fld_type_modifier & AUTO_INCREMENT_FLAG ?
 
1424
                 Field::NEXT_NUMBER : Field::NONE);
 
1425
  decimals= fld_decimals ? (uint32_t)atoi(fld_decimals) : 0;
 
1426
  if (decimals >= NOT_FIXED_DEC)
 
1427
  {
 
1428
    my_error(ER_TOO_BIG_SCALE, MYF(0), decimals, fld_name,
 
1429
             NOT_FIXED_DEC-1);
 
1430
    return(true);
 
1431
  }
 
1432
 
 
1433
  sql_type= fld_type;
 
1434
  length= 0;
 
1435
  change= fld_change;
 
1436
  interval= 0;
 
1437
  pack_length= key_length= 0;
 
1438
  charset= fld_charset;
 
1439
  interval_list.empty();
 
1440
 
 
1441
  comment= *fld_comment;
 
1442
  vcol_info= fld_vcol_info;
 
1443
  is_stored= true;
 
1444
 
 
1445
  /* Initialize data for a virtual field */
 
1446
  if (fld_type == DRIZZLE_TYPE_VIRTUAL)
 
1447
  {
 
1448
    assert(vcol_info && vcol_info->expr_item);
 
1449
    is_stored= vcol_info->get_field_stored();
 
1450
    /*
 
1451
      Perform per item-type checks to determine if the expression is
 
1452
      allowed for a virtual column.
 
1453
      Note that validation of the specific function is done later in
 
1454
      procedures open_table_from_share and fix_fields_vcol_func
 
1455
    */
 
1456
    switch (vcol_info->expr_item->type()) {
 
1457
    case Item::FUNC_ITEM:
 
1458
         if (((Item_func *)vcol_info->expr_item)->functype() == Item_func::FUNC_SP)
 
1459
         {
 
1460
           my_error(ER_VIRTUAL_COLUMN_FUNCTION_IS_NOT_ALLOWED, MYF(0), field_name);
 
1461
           return(true);
 
1462
         }
 
1463
         break;
 
1464
    case Item::COPY_STR_ITEM:
 
1465
    case Item::FIELD_AVG_ITEM:
 
1466
    case Item::PROC_ITEM:
 
1467
    case Item::REF_ITEM:
 
1468
    case Item::FIELD_STD_ITEM:
 
1469
    case Item::FIELD_VARIANCE_ITEM:
 
1470
    case Item::INSERT_VALUE_ITEM:
 
1471
    case Item::SUBSELECT_ITEM:
 
1472
    case Item::CACHE_ITEM:
 
1473
    case Item::TYPE_HOLDER:
 
1474
    case Item::PARAM_ITEM:
 
1475
         my_error(ER_VIRTUAL_COLUMN_FUNCTION_IS_NOT_ALLOWED, MYF(0), field_name);
 
1476
         return true;
 
1477
    default:
 
1478
      // Continue with the field creation
 
1479
      break;
 
1480
    }
 
1481
    /*
 
1482
      Make a field created for the real type.
 
1483
      Note that "real" and virtual fields differ from each other
 
1484
      only by Field::vcol_info, which is always 0 for normal columns.
 
1485
      vcol_info is updated for fields later in procedure open_binary_frm.
 
1486
    */
 
1487
    sql_type= fld_type= vcol_info->get_real_type();
 
1488
  }
 
1489
 
 
1490
  /*
 
1491
    Set NO_DEFAULT_VALUE_FLAG if this field doesn't have a default value and
 
1492
    it is NOT NULL, not an AUTO_INCREMENT field and not a TIMESTAMP.
 
1493
  */
 
1494
  if (!fld_default_value && !(fld_type_modifier & AUTO_INCREMENT_FLAG) &&
 
1495
      (fld_type_modifier & NOT_NULL_FLAG) && fld_type != DRIZZLE_TYPE_TIMESTAMP)
 
1496
    flags|= NO_DEFAULT_VALUE_FLAG;
 
1497
 
 
1498
  if (fld_length && !(length= (uint32_t) atoi(fld_length)))
 
1499
    fld_length= 0; /* purecov: inspected */
 
1500
  sign_len= fld_type_modifier & UNSIGNED_FLAG ? 0 : 1;
 
1501
 
 
1502
  switch (fld_type) {
 
1503
  case DRIZZLE_TYPE_TINY:
 
1504
    if (!fld_length)
 
1505
      length= MAX_TINYINT_WIDTH+sign_len;
 
1506
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
 
1507
    break;
 
1508
  case DRIZZLE_TYPE_LONG:
 
1509
    if (!fld_length)
 
1510
      length= MAX_INT_WIDTH+sign_len;
 
1511
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
 
1512
    break;
 
1513
  case DRIZZLE_TYPE_LONGLONG:
 
1514
    if (!fld_length)
 
1515
      length= MAX_BIGINT_WIDTH;
 
1516
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
 
1517
    break;
 
1518
  case DRIZZLE_TYPE_NULL:
 
1519
    break;
 
1520
  case DRIZZLE_TYPE_NEWDECIMAL:
 
1521
    my_decimal_trim(&length, &decimals);
 
1522
    if (length > DECIMAL_MAX_PRECISION)
 
1523
    {
 
1524
      my_error(ER_TOO_BIG_PRECISION, MYF(0), length, fld_name,
 
1525
               DECIMAL_MAX_PRECISION);
 
1526
      return(true);
 
1527
    }
 
1528
    if (length < decimals)
 
1529
    {
 
1530
      my_error(ER_M_BIGGER_THAN_D, MYF(0), fld_name);
 
1531
      return(true);
 
1532
    }
 
1533
    length=
 
1534
      my_decimal_precision_to_length(length, decimals,
 
1535
                                     fld_type_modifier & UNSIGNED_FLAG);
 
1536
    pack_length=
 
1537
      my_decimal_get_binary_size(length, decimals);
 
1538
    break;
 
1539
  case DRIZZLE_TYPE_VARCHAR:
 
1540
    /*
 
1541
      Long VARCHAR's are automaticly converted to blobs in mysql_prepare_table
 
1542
      if they don't have a default value
 
1543
    */
 
1544
    max_field_charlength= MAX_FIELD_VARCHARLENGTH;
 
1545
    break;
 
1546
  case DRIZZLE_TYPE_BLOB:
 
1547
    if (fld_default_value)
 
1548
    {
 
1549
      /* Allow empty as default value. */
 
1550
      String str,*res;
 
1551
      res= fld_default_value->val_str(&str);
 
1552
      if (res->length())
 
1553
      {
 
1554
        my_error(ER_BLOB_CANT_HAVE_DEFAULT, MYF(0),
 
1555
                 fld_name);
 
1556
        return(true);
 
1557
      }
 
1558
 
 
1559
    }
 
1560
    flags|= BLOB_FLAG;
 
1561
    break;
 
1562
  case DRIZZLE_TYPE_DOUBLE:
 
1563
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
 
1564
    if (!fld_length && !fld_decimals)
 
1565
    {
 
1566
      length= DBL_DIG+7;
 
1567
      decimals= NOT_FIXED_DEC;
 
1568
    }
 
1569
    if (length < decimals &&
 
1570
        decimals != NOT_FIXED_DEC)
 
1571
    {
 
1572
      my_error(ER_M_BIGGER_THAN_D, MYF(0), fld_name);
 
1573
      return(true);
 
1574
    }
 
1575
    break;
 
1576
  case DRIZZLE_TYPE_TIMESTAMP:
 
1577
    if (!fld_length)
 
1578
    {
 
1579
      /* Compressed date YYYYMMDDHHMMSS */
 
1580
      length= MAX_DATETIME_COMPRESSED_WIDTH;
 
1581
    }
 
1582
    else if (length != MAX_DATETIME_WIDTH)
 
1583
    {
 
1584
      /*
 
1585
        We support only even TIMESTAMP lengths less or equal than 14
 
1586
        and 19 as length of 4.1 compatible representation.
 
1587
      */
 
1588
      length= ((length+1)/2)*2; /* purecov: inspected */
 
1589
      length= cmin(length, (uint32_t)MAX_DATETIME_COMPRESSED_WIDTH); /* purecov: inspected */
 
1590
    }
 
1591
    flags|= UNSIGNED_FLAG;
 
1592
    if (fld_default_value)
 
1593
    {
 
1594
      /* Grammar allows only NOW() value for ON UPDATE clause */
 
1595
      if (fld_default_value->type() == Item::FUNC_ITEM &&
 
1596
          ((Item_func*)fld_default_value)->functype() == Item_func::NOW_FUNC)
 
1597
      {
 
1598
        unireg_check= (fld_on_update_value ? Field::TIMESTAMP_DNUN_FIELD:
 
1599
                                             Field::TIMESTAMP_DN_FIELD);
 
1600
        /*
 
1601
          We don't need default value any longer moreover it is dangerous.
 
1602
          Everything handled by unireg_check further.
 
1603
        */
 
1604
        def= 0;
 
1605
      }
 
1606
      else
 
1607
        unireg_check= (fld_on_update_value ? Field::TIMESTAMP_UN_FIELD:
 
1608
                                             Field::NONE);
 
1609
    }
 
1610
    else
 
1611
    {
 
1612
      /*
 
1613
        If we have default TIMESTAMP NOT NULL column without explicit DEFAULT
 
1614
        or ON UPDATE values then for the sake of compatiblity we should treat
 
1615
        this column as having DEFAULT NOW() ON UPDATE NOW() (when we don't
 
1616
        have another TIMESTAMP column with auto-set option before this one)
 
1617
        or DEFAULT 0 (in other cases).
 
1618
        So here we are setting TIMESTAMP_OLD_FIELD only temporary, and will
 
1619
        replace this value by TIMESTAMP_DNUN_FIELD or NONE later when
 
1620
        information about all TIMESTAMP fields in table will be availiable.
 
1621
 
 
1622
        If we have TIMESTAMP NULL column without explicit DEFAULT value
 
1623
        we treat it as having DEFAULT NULL attribute.
 
1624
      */
 
1625
      unireg_check= (fld_on_update_value ? Field::TIMESTAMP_UN_FIELD :
 
1626
                     (flags & NOT_NULL_FLAG ? Field::TIMESTAMP_OLD_FIELD :
 
1627
                                              Field::NONE));
 
1628
    }
 
1629
    break;
 
1630
  case DRIZZLE_TYPE_DATE:
 
1631
    length= 10;
 
1632
    break;
 
1633
  case DRIZZLE_TYPE_DATETIME:
 
1634
    length= MAX_DATETIME_WIDTH;
 
1635
    break;
 
1636
  case DRIZZLE_TYPE_ENUM:
 
1637
    {
 
1638
      /* Should be safe. */
 
1639
      pack_length= get_enum_pack_length(fld_interval_list->elements);
 
1640
 
 
1641
      List_iterator<String> it(*fld_interval_list);
 
1642
      String *tmp;
 
1643
      while ((tmp= it++))
 
1644
        interval_list.push_back(tmp);
 
1645
      length= 1; /* See comment for DRIZZLE_TYPE_SET above. */
 
1646
      break;
 
1647
   }
 
1648
  case DRIZZLE_TYPE_VIRTUAL: // Must not happen
 
1649
    assert(0);
 
1650
  }
 
1651
  /* Remember the value of length */
 
1652
  char_length= length;
 
1653
 
 
1654
  if (!(flags & BLOB_FLAG) &&
 
1655
      ((length > max_field_charlength &&
 
1656
        fld_type != DRIZZLE_TYPE_ENUM &&
 
1657
        (fld_type != DRIZZLE_TYPE_VARCHAR || fld_default_value)) ||
 
1658
       (!length && fld_type != DRIZZLE_TYPE_VARCHAR)))
 
1659
  {
 
1660
    my_error((fld_type == DRIZZLE_TYPE_VARCHAR) ?  ER_TOO_BIG_FIELDLENGTH : ER_TOO_BIG_DISPLAYWIDTH,
 
1661
              MYF(0),
 
1662
              fld_name, max_field_charlength); /* purecov: inspected */
 
1663
    return(true);
 
1664
  }
 
1665
  fld_type_modifier&= AUTO_INCREMENT_FLAG;
 
1666
  if ((~allowed_type_modifier) & fld_type_modifier)
 
1667
  {
 
1668
    my_error(ER_WRONG_FIELD_SPEC, MYF(0), fld_name);
 
1669
    return(true);
 
1670
  }
 
1671
 
 
1672
  return(false); /* success */
 
1673
}
 
1674
 
 
1675
 
 
1676
enum_field_types get_blob_type_from_length(uint32_t)
 
1677
{
 
1678
  enum_field_types type;
 
1679
 
 
1680
  type= DRIZZLE_TYPE_BLOB;
 
1681
 
 
1682
  return type;
 
1683
}
 
1684
 
 
1685
 
 
1686
/*
 
1687
  Make a field from the .frm file info
 
1688
*/
 
1689
 
1139
1690
uint32_t calc_pack_length(enum_field_types type,uint32_t length)
1140
1691
{
1141
1692
  switch (type) {
1142
 
  case DRIZZLE_TYPE_VARCHAR: return (length + (length < 256 ? 1: 2));
1143
 
  case DRIZZLE_TYPE_UUID: return field::Uuid::max_string_length();
1144
 
  case DRIZZLE_TYPE_MICROTIME: return field::Microtime::max_string_length();
1145
 
  case DRIZZLE_TYPE_TIMESTAMP: return field::Epoch::max_string_length();
1146
 
  case DRIZZLE_TYPE_BOOLEAN: return field::Boolean::max_string_length();
1147
 
  case DRIZZLE_TYPE_DATE:
1148
 
  case DRIZZLE_TYPE_ENUM:
1149
 
  case DRIZZLE_TYPE_LONG: return 4;
 
1693
  case DRIZZLE_TYPE_VARCHAR:     return (length + (length < 256 ? 1: 2));
 
1694
  case DRIZZLE_TYPE_TINY        : return 1;
 
1695
  case DRIZZLE_TYPE_DATE: return 3;
 
1696
  case DRIZZLE_TYPE_TIMESTAMP:
 
1697
  case DRIZZLE_TYPE_LONG        : return 4;
1150
1698
  case DRIZZLE_TYPE_DOUBLE: return sizeof(double);
1151
 
  case DRIZZLE_TYPE_TIME:
1152
1699
  case DRIZZLE_TYPE_DATETIME:
1153
1700
  case DRIZZLE_TYPE_LONGLONG: return 8; /* Don't crash if no int64_t */
1154
 
  case DRIZZLE_TYPE_NULL: return 0;
1155
 
  case DRIZZLE_TYPE_BLOB: return 4 + portable_sizeof_char_ptr;
1156
 
  case DRIZZLE_TYPE_DECIMAL:
1157
 
                          break;
 
1701
  case DRIZZLE_TYPE_NULL        : return 0;
 
1702
  case DRIZZLE_TYPE_BLOB:               return 4+portable_sizeof_char_ptr;
 
1703
  case DRIZZLE_TYPE_ENUM:
 
1704
  case DRIZZLE_TYPE_NEWDECIMAL:
 
1705
    abort();
 
1706
  default:
 
1707
    return 0;
1158
1708
  }
1159
 
 
1160
 
  assert(0);
1161
 
  abort();
1162
1709
}
1163
1710
 
 
1711
 
1164
1712
uint32_t pack_length_to_packflag(uint32_t type)
1165
1713
{
1166
1714
  switch (type) {
1167
1715
    case 1: return 1 << FIELDFLAG_PACK_SHIFT;
1168
1716
    case 2: assert(1);
1169
1717
    case 3: assert(1);
1170
 
    case 4: return f_settype(DRIZZLE_TYPE_LONG);
1171
 
    case 8: return f_settype(DRIZZLE_TYPE_LONGLONG);
 
1718
    case 4: return f_settype((uint32_t) DRIZZLE_TYPE_LONG);
 
1719
    case 8: return f_settype((uint32_t) DRIZZLE_TYPE_LONGLONG);
1172
1720
  }
1173
1721
  return 0;                                     // This shouldn't happen
1174
1722
}
1175
1723
 
 
1724
 
 
1725
Field *make_field(TABLE_SHARE *share, MEM_ROOT *root,
 
1726
                  unsigned char *ptr, uint32_t field_length,
 
1727
                  unsigned char *null_pos, unsigned char null_bit,
 
1728
                  uint32_t pack_flag,
 
1729
                  enum_field_types field_type,
 
1730
                  const CHARSET_INFO * field_charset,
 
1731
                  Field::utype unireg_check,
 
1732
                  TYPELIB *interval,
 
1733
                  const char *field_name)
 
1734
{
 
1735
  if(!root)
 
1736
    root= current_mem_root();
 
1737
 
 
1738
  if (!f_maybe_null(pack_flag))
 
1739
  {
 
1740
    null_pos=0;
 
1741
    null_bit=0;
 
1742
  }
 
1743
  else
 
1744
  {
 
1745
    null_bit= ((unsigned char) 1) << null_bit;
 
1746
  }
 
1747
 
 
1748
  switch (field_type) {
 
1749
  case DRIZZLE_TYPE_DATE:
 
1750
  case DRIZZLE_TYPE_DATETIME:
 
1751
  case DRIZZLE_TYPE_TIMESTAMP:
 
1752
    field_charset= &my_charset_bin;
 
1753
  default: break;
 
1754
  }
 
1755
 
 
1756
  if (f_is_alpha(pack_flag))
 
1757
  {
 
1758
    if (!f_is_packed(pack_flag))
 
1759
    {
 
1760
      if (field_type == DRIZZLE_TYPE_VARCHAR)
 
1761
        return new (root) Field_varstring(ptr,field_length,
 
1762
                                   HA_VARCHAR_PACKLENGTH(field_length),
 
1763
                                   null_pos,null_bit,
 
1764
                                   unireg_check, field_name,
 
1765
                                   share,
 
1766
                                   field_charset);
 
1767
      return 0;                                 // Error
 
1768
    }
 
1769
 
 
1770
    uint32_t pack_length=calc_pack_length((enum_field_types)
 
1771
                                      f_packtype(pack_flag),
 
1772
                                      field_length);
 
1773
 
 
1774
    if (f_is_blob(pack_flag))
 
1775
      return new (root) Field_blob(ptr,null_pos,null_bit,
 
1776
                            unireg_check, field_name, share,
 
1777
                            pack_length, field_charset);
 
1778
    if (interval)
 
1779
    {
 
1780
      if (f_is_enum(pack_flag))
 
1781
      {
 
1782
        return new (root) Field_enum(ptr,field_length,null_pos,null_bit,
 
1783
                                  unireg_check, field_name,
 
1784
                                  get_enum_pack_length(interval->count),
 
1785
                                  interval, field_charset);
 
1786
      }
 
1787
    }
 
1788
  }
 
1789
 
 
1790
  switch (field_type) {
 
1791
  case DRIZZLE_TYPE_NEWDECIMAL:
 
1792
    return new (root) Field_new_decimal(ptr,field_length,null_pos,null_bit,
 
1793
                                 unireg_check, field_name,
 
1794
                                 f_decimals(pack_flag),
 
1795
                                 f_is_decimal_precision(pack_flag) != 0,
 
1796
                                 f_is_dec(pack_flag) == 0);
 
1797
  case DRIZZLE_TYPE_DOUBLE:
 
1798
    return new (root) Field_double(ptr,field_length,null_pos,null_bit,
 
1799
                            unireg_check, field_name,
 
1800
                            f_decimals(pack_flag),
 
1801
                            false,
 
1802
                            f_is_dec(pack_flag)== 0);
 
1803
  case DRIZZLE_TYPE_TINY:
 
1804
    assert(0);
 
1805
  case DRIZZLE_TYPE_LONG:
 
1806
    return new (root) Field_long(ptr,field_length,null_pos,null_bit,
 
1807
                           unireg_check, field_name,
 
1808
                           false,
 
1809
                           f_is_dec(pack_flag) == 0);
 
1810
  case DRIZZLE_TYPE_LONGLONG:
 
1811
    return new (root) Field_int64_t(ptr,field_length,null_pos,null_bit,
 
1812
                              unireg_check, field_name,
 
1813
                              false,
 
1814
                              f_is_dec(pack_flag) == 0);
 
1815
  case DRIZZLE_TYPE_TIMESTAMP:
 
1816
    return new (root) Field_timestamp(ptr,field_length, null_pos, null_bit,
 
1817
                               unireg_check, field_name, share,
 
1818
                               field_charset);
 
1819
  case DRIZZLE_TYPE_DATE:
 
1820
    return new (root) Field_date(ptr,null_pos,null_bit,
 
1821
                             unireg_check, field_name, field_charset);
 
1822
  case DRIZZLE_TYPE_DATETIME:
 
1823
    return new (root) Field_datetime(ptr,null_pos,null_bit,
 
1824
                              unireg_check, field_name, field_charset);
 
1825
  case DRIZZLE_TYPE_NULL:
 
1826
    return new (root) Field_null(ptr, field_length, unireg_check, field_name,
 
1827
                          field_charset);
 
1828
  case DRIZZLE_TYPE_VIRTUAL:                    // Must not happen
 
1829
    assert(0);
 
1830
  default:                                      // Impossible (Wrong version)
 
1831
    break;
 
1832
  }
 
1833
  return 0;
 
1834
}
 
1835
 
 
1836
 
 
1837
/** Create a field suitable for create of table. */
 
1838
 
 
1839
Create_field::Create_field(Field *old_field,Field *orig_field)
 
1840
{
 
1841
  field=      old_field;
 
1842
  field_name=change=old_field->field_name;
 
1843
  length=     old_field->field_length;
 
1844
  flags=      old_field->flags;
 
1845
  unireg_check=old_field->unireg_check;
 
1846
  pack_length=old_field->pack_length();
 
1847
  key_length= old_field->key_length();
 
1848
  sql_type=   old_field->real_type();
 
1849
  charset=    old_field->charset();             // May be NULL ptr
 
1850
  comment=    old_field->comment;
 
1851
  decimals=   old_field->decimals();
 
1852
  vcol_info=  old_field->vcol_info;
 
1853
  is_stored= old_field->is_stored;
 
1854
 
 
1855
  /* Fix if the original table had 4 byte pointer blobs */
 
1856
  if (flags & BLOB_FLAG)
 
1857
    pack_length= (pack_length- old_field->table->s->blob_ptr_size +
 
1858
                  portable_sizeof_char_ptr);
 
1859
 
 
1860
  switch (sql_type) {
 
1861
  case DRIZZLE_TYPE_BLOB:
 
1862
    sql_type= DRIZZLE_TYPE_BLOB;
 
1863
    length/= charset->mbmaxlen;
 
1864
    key_length/= charset->mbmaxlen;
 
1865
    break;
 
1866
    /* Change CHAR -> VARCHAR if dynamic record length */
 
1867
  case DRIZZLE_TYPE_ENUM:
 
1868
  case DRIZZLE_TYPE_VARCHAR:
 
1869
    /* This is corrected in create_length_to_internal_length */
 
1870
    length= (length+charset->mbmaxlen-1) / charset->mbmaxlen;
 
1871
    break;
 
1872
  default:
 
1873
    break;
 
1874
  }
 
1875
 
 
1876
  if (flags & (ENUM_FLAG | SET_FLAG))
 
1877
    interval= ((Field_enum*) old_field)->typelib;
 
1878
  else
 
1879
    interval=0;
 
1880
  def=0;
 
1881
  char_length= length;
 
1882
 
 
1883
  if (!(flags & (NO_DEFAULT_VALUE_FLAG )) &&
 
1884
      old_field->ptr && orig_field &&
 
1885
      (sql_type != DRIZZLE_TYPE_TIMESTAMP ||                /* set def only if */
 
1886
       old_field->table->timestamp_field != old_field ||  /* timestamp field */
 
1887
       unireg_check == Field::TIMESTAMP_UN_FIELD))        /* has default val */
 
1888
  {
 
1889
    my_ptrdiff_t diff;
 
1890
 
 
1891
    /* Get the value from default_values */
 
1892
    diff= (my_ptrdiff_t) (orig_field->table->s->default_values-
 
1893
                          orig_field->table->record[0]);
 
1894
    orig_field->move_field_offset(diff);        // Points now at default_values
 
1895
    if (!orig_field->is_real_null())
 
1896
    {
 
1897
      char buff[MAX_FIELD_WIDTH], *pos;
 
1898
      String tmp(buff, sizeof(buff), charset), *res;
 
1899
      res= orig_field->val_str(&tmp);
 
1900
      pos= (char*) sql_strmake(res->ptr(), res->length());
 
1901
      def= new Item_string(pos, res->length(), charset);
 
1902
    }
 
1903
    orig_field->move_field_offset(-diff);       // Back to record[0]
 
1904
  }
 
1905
}
 
1906
 
 
1907
 
1176
1908
/*****************************************************************************
1177
1909
 Warning handling
1178
1910
*****************************************************************************/
1179
1911
 
1180
 
bool Field::set_warning(DRIZZLE_ERROR::enum_warning_level level,
1181
 
                        drizzled::error_t code,
1182
 
                        int cuted_increment)
 
1912
/**
 
1913
  Produce warning or note about data saved into field.
 
1914
 
 
1915
  @param level            - level of message (Note/Warning/Error)
 
1916
  @param code             - error code of message to be produced
 
1917
  @param cuted_increment  - whenever we should increase cut fields count or not
 
1918
 
 
1919
  @note
 
1920
    This function won't produce warning and increase cut fields counter
 
1921
    if count_cuted_fields == CHECK_FIELD_IGNORE for current thread.
 
1922
 
 
1923
    if count_cuted_fields == CHECK_FIELD_IGNORE then we ignore notes.
 
1924
    This allows us to avoid notes in optimisation, like convert_constant_item().
 
1925
 
 
1926
  @retval
 
1927
    1 if count_cuted_fields == CHECK_FIELD_IGNORE and error level is not NOTE
 
1928
  @retval
 
1929
    0 otherwise
 
1930
*/
 
1931
 
 
1932
bool
 
1933
Field::set_warning(DRIZZLE_ERROR::enum_warning_level level, uint32_t code,
 
1934
                   int cuted_increment)
1183
1935
{
1184
1936
  /*
1185
1937
    If this field was created only for type conversion purposes it
1197
1949
}
1198
1950
 
1199
1951
 
1200
 
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1201
 
                                 drizzled::error_t code,
1202
 
                                 const char *str, 
1203
 
                                 uint32_t str_length,
1204
 
                                 type::timestamp_t ts_type, 
1205
 
                                 int cuted_increment)
 
1952
/**
 
1953
  Produce warning or note about datetime string data saved into field.
 
1954
 
 
1955
  @param level            level of message (Note/Warning/Error)
 
1956
  @param code             error code of message to be produced
 
1957
  @param str              string value which we tried to save
 
1958
  @param str_length       length of string which we tried to save
 
1959
  @param ts_type          type of datetime value (datetime/date/time)
 
1960
  @param cuted_increment  whenever we should increase cut fields count or not
 
1961
 
 
1962
  @note
 
1963
    This function will always produce some warning but won't increase cut
 
1964
    fields counter if count_cuted_fields ==FIELD_CHECK_IGNORE for current
 
1965
    thread.
 
1966
*/
 
1967
 
 
1968
void
 
1969
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
 
1970
                            unsigned int code,
 
1971
                            const char *str, uint32_t str_length,
 
1972
                            enum enum_drizzle_timestamp_type ts_type, int cuted_increment)
1206
1973
{
1207
 
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
1208
 
 
1209
 
  if ((session->abortOnWarning() and
 
1974
  Session *session= table ? table->in_use : current_session;
 
1975
  if ((session->really_abort_on_warning() &&
1210
1976
       level >= DRIZZLE_ERROR::WARN_LEVEL_WARN) ||
1211
1977
      set_warning(level, code, cuted_increment))
1212
1978
    make_truncated_value_warning(session, level, str, str_length, ts_type,
1213
1979
                                 field_name);
1214
1980
}
1215
1981
 
1216
 
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, 
1217
 
                                 drizzled::error_t code,
1218
 
                                 int64_t nr, 
1219
 
                                 type::timestamp_t ts_type,
1220
 
                                 int cuted_increment)
 
1982
 
 
1983
/**
 
1984
  Produce warning or note about integer datetime value saved into field.
 
1985
 
 
1986
  @param level            level of message (Note/Warning/Error)
 
1987
  @param code             error code of message to be produced
 
1988
  @param nr               numeric value which we tried to save
 
1989
  @param ts_type          type of datetime value (datetime/date/time)
 
1990
  @param cuted_increment  whenever we should increase cut fields count or not
 
1991
 
 
1992
  @note
 
1993
    This function will always produce some warning but won't increase cut
 
1994
    fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current
 
1995
    thread.
 
1996
*/
 
1997
 
 
1998
void
 
1999
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, uint32_t code,
 
2000
                            int64_t nr, enum enum_drizzle_timestamp_type ts_type,
 
2001
                            int cuted_increment)
1221
2002
{
1222
 
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
1223
 
 
1224
 
  if (session->abortOnWarning() or
 
2003
  Session *session= table ? table->in_use : current_session;
 
2004
  if (session->really_abort_on_warning() ||
1225
2005
      set_warning(level, code, cuted_increment))
1226
2006
  {
1227
 
    char str_nr[DECIMAL_LONGLONG_DIGITS];
1228
 
    char *str_end= internal::int64_t10_to_str(nr, str_nr, -10);
 
2007
    char str_nr[22];
 
2008
    char *str_end= int64_t10_to_str(nr, str_nr, -10);
1229
2009
    make_truncated_value_warning(session, level, str_nr, (uint32_t) (str_end - str_nr),
1230
2010
                                 ts_type, field_name);
1231
2011
  }
1232
2012
}
1233
2013
 
1234
 
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1235
 
                                 const drizzled::error_t code,
1236
 
                                 double nr, 
1237
 
                                 type::timestamp_t ts_type)
 
2014
 
 
2015
/**
 
2016
  Produce warning or note about double datetime data saved into field.
 
2017
 
 
2018
  @param level            level of message (Note/Warning/Error)
 
2019
  @param code             error code of message to be produced
 
2020
  @param nr               double value which we tried to save
 
2021
  @param ts_type          type of datetime value (datetime/date/time)
 
2022
 
 
2023
  @note
 
2024
    This function will always produce some warning but won't increase cut
 
2025
    fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current
 
2026
    thread.
 
2027
*/
 
2028
 
 
2029
void
 
2030
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, const uint32_t code,
 
2031
                            double nr, enum enum_drizzle_timestamp_type ts_type)
1238
2032
{
1239
 
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
1240
 
 
1241
 
  if (session->abortOnWarning() or
 
2033
  Session *session= table ? table->in_use : current_session;
 
2034
  if (session->really_abort_on_warning() ||
1242
2035
      set_warning(level, code, 1))
1243
2036
  {
1244
2037
    /* DBL_DIG is enough to print '-[digits].E+###' */
1245
2038
    char str_nr[DBL_DIG + 8];
1246
 
    uint32_t str_len= snprintf(str_nr, sizeof(str_nr), "%g", nr);
 
2039
    uint32_t str_len= sprintf(str_nr, "%g", nr);
1247
2040
    make_truncated_value_warning(session, level, str_nr, str_len, ts_type,
1248
2041
                                 field_name);
1249
2042
  }
1250
2043
}
1251
2044
 
1252
 
bool Field::isReadSet() 
1253
 
{ 
1254
 
  return table->isReadSet(field_index); 
1255
 
}
1256
 
 
1257
 
bool Field::isWriteSet()
1258
 
{ 
1259
 
  return table->isWriteSet(field_index); 
1260
 
}
1261
 
 
1262
 
void Field::setReadSet(bool arg)
1263
 
{
1264
 
  if (arg)
1265
 
    table->setReadSet(field_index);
1266
 
  else
1267
 
    table->clearReadSet(field_index);
1268
 
}
1269
 
 
1270
 
void Field::setWriteSet(bool arg)
1271
 
{
1272
 
  if (arg)
1273
 
    table->setWriteSet(field_index);
1274
 
  else
1275
 
    table->clearWriteSet(field_index);
1276
 
}
1277
 
 
1278
 
void Field::pack_num(uint64_t arg, unsigned char *destination)
1279
 
{
1280
 
  if (not destination)
1281
 
    destination= ptr;
1282
 
 
1283
 
  int64_tstore(destination, arg);
1284
 
}
1285
 
 
1286
 
void Field::pack_num(uint32_t arg, unsigned char *destination)
1287
 
{
1288
 
  if (not destination)
1289
 
    destination= ptr;
1290
 
 
1291
 
  longstore(destination, arg);
1292
 
}
1293
 
 
1294
 
uint64_t Field::unpack_num(uint64_t &destination, const unsigned char *arg) const
1295
 
{
1296
 
  if (not arg)
1297
 
    arg= ptr;
1298
 
 
1299
 
  int64_tget(destination, arg);
1300
 
 
1301
 
  return destination;
1302
 
}
1303
 
 
1304
 
uint32_t Field::unpack_num(uint32_t &destination, const unsigned char *arg) const
1305
 
{
1306
 
  if (not arg)
1307
 
    arg= ptr;
1308
 
 
1309
 
  longget(destination, arg);
1310
 
 
1311
 
  return destination;
1312
 
}
1313
 
 
1314
 
std::ostream& operator<<(std::ostream& output, const Field &field)
1315
 
{
1316
 
  output << "Field:(";
1317
 
  output <<  field.field_name;
1318
 
  output << ", ";
1319
 
  output << drizzled::display::type(field.real_type());
1320
 
  output << ", { ";
1321
 
 
1322
 
  if (field.flags & NOT_NULL_FLAG)
1323
 
    output << " NOT_NULL";
1324
 
 
1325
 
  if (field.flags & PRI_KEY_FLAG)
1326
 
    output << ", PRIMARY KEY";
1327
 
 
1328
 
  if (field.flags & UNIQUE_KEY_FLAG)
1329
 
    output << ", UNIQUE KEY";
1330
 
 
1331
 
  if (field.flags & MULTIPLE_KEY_FLAG)
1332
 
    output << ", MULTIPLE KEY";
1333
 
 
1334
 
  if (field.flags & BLOB_FLAG)
1335
 
    output << ", BLOB";
1336
 
 
1337
 
  if (field.flags & UNSIGNED_FLAG)
1338
 
    output << ", UNSIGNED";
1339
 
 
1340
 
  if (field.flags & BINARY_FLAG)
1341
 
    output << ", BINARY";
1342
 
  output << "}, ";
1343
 
  output << ")";
1344
 
 
1345
 
  return output;  // for multiple << operators.
1346
 
}
1347
 
 
1348
 
} /* namespace drizzled */