← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.cc

  • Committer: Brian Aker
  • Date: 2009-08-18 07:19:56 UTC
  • mfrom: (1116.1.3 stewart)
  • mto: This revision was merged to the branch mainline in revision 1118.
  • Revision ID: brian@gaz-20090818071956-nfpoe9rp3i7p50kx
Merge my branch from Stewart into one branch

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
23
22
 * @file This file implements the Field class and API
24
23
 */
25
24
 
26
 
#include <config.h>
27
 
#include <cstdio>
 
25
#include "drizzled/server_includes.h"
28
26
#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
 
#include <drizzled/table.h>
54
 
#include <drizzled/util/test.h>
55
 
#include <drizzled/session.h>
56
 
#include <drizzled/current_session.h>
57
 
#include <drizzled/display.h>
58
 
#include <drizzled/typelib.h>
59
 
 
60
 
namespace drizzled
61
 
{
 
27
#include "drizzled/sql_select.h"
 
28
#include "drizzled/error.h"
 
29
#include "drizzled/field/str.h"
 
30
#include "drizzled/field/num.h"
 
31
#include "drizzled/field/blob.h"
 
32
#include "drizzled/field/enum.h"
 
33
#include "drizzled/field/null.h"
 
34
#include "drizzled/field/date.h"
 
35
#include "drizzled/field/decimal.h"
 
36
#include "drizzled/field/real.h"
 
37
#include "drizzled/field/double.h"
 
38
#include "drizzled/field/long.h"
 
39
#include "drizzled/field/int64_t.h"
 
40
#include "drizzled/field/num.h"
 
41
#include "drizzled/field/timestamp.h"
 
42
#include "drizzled/field/datetime.h"
 
43
#include "drizzled/field/varstring.h"
62
44
 
63
45
/*****************************************************************************
64
46
  Instansiate templates and static variables
65
47
*****************************************************************************/
66
48
 
 
49
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
 
50
template class List<CreateField>;
 
51
template class List_iterator<CreateField>;
 
52
#endif
 
53
 
67
54
static enum_field_types
68
 
field_types_merge_rules [enum_field_types_size][enum_field_types_size]=
 
55
field_types_merge_rules [DRIZZLE_TYPE_MAX+1][DRIZZLE_TYPE_MAX+1]=
69
56
{
 
57
  /* DRIZZLE_TYPE_TINY -> */
 
58
  {
 
59
    //DRIZZLE_TYPE_TINY
 
60
    DRIZZLE_TYPE_TINY,
 
61
    //DRIZZLE_TYPE_LONG
 
62
    DRIZZLE_TYPE_LONG,
 
63
    //DRIZZLE_TYPE_DOUBLE
 
64
    DRIZZLE_TYPE_DOUBLE,
 
65
    //DRIZZLE_TYPE_NULL
 
66
    DRIZZLE_TYPE_TINY,
 
67
    //DRIZZLE_TYPE_TIMESTAMP
 
68
    DRIZZLE_TYPE_VARCHAR,
 
69
    //DRIZZLE_TYPE_LONGLONG
 
70
    DRIZZLE_TYPE_LONGLONG,
 
71
    //DRIZZLE_TYPE_DATETIME
 
72
    DRIZZLE_TYPE_VARCHAR,
 
73
    //DRIZZLE_TYPE_DATE
 
74
    DRIZZLE_TYPE_VARCHAR,
 
75
    //DRIZZLE_TYPE_VARCHAR
 
76
    DRIZZLE_TYPE_VARCHAR,
 
77
    //DRIZZLE_TYPE_NEWDECIMAL
 
78
    DRIZZLE_TYPE_NEWDECIMAL,
 
79
    //DRIZZLE_TYPE_ENUM
 
80
    DRIZZLE_TYPE_VARCHAR,
 
81
    //DRIZZLE_TYPE_BLOB
 
82
    DRIZZLE_TYPE_BLOB,
 
83
  },
70
84
  /* DRIZZLE_TYPE_LONG -> */
71
85
  {
 
86
    //DRIZZLE_TYPE_TINY
 
87
    DRIZZLE_TYPE_LONG,
72
88
    //DRIZZLE_TYPE_LONG
73
89
    DRIZZLE_TYPE_LONG,
74
90
    //DRIZZLE_TYPE_DOUBLE
85
101
    DRIZZLE_TYPE_VARCHAR,
86
102
    //DRIZZLE_TYPE_VARCHAR
87
103
    DRIZZLE_TYPE_VARCHAR,
88
 
    //DRIZZLE_TYPE_DECIMAL
89
 
    DRIZZLE_TYPE_DECIMAL,
 
104
    //DRIZZLE_TYPE_NEWDECIMAL
 
105
    DRIZZLE_TYPE_NEWDECIMAL,
90
106
    //DRIZZLE_TYPE_ENUM
91
107
    DRIZZLE_TYPE_VARCHAR,
92
108
    //DRIZZLE_TYPE_BLOB
93
109
    DRIZZLE_TYPE_BLOB,
94
 
    //DRIZZLE_TYPE_TIME
95
 
    DRIZZLE_TYPE_TIME,
96
 
    //DRIZZLE_TYPE_BOOLEAN
97
 
    DRIZZLE_TYPE_VARCHAR,
98
 
    //DRIZZLE_TYPE_UUID
99
 
    DRIZZLE_TYPE_VARCHAR,
100
 
    //DRIZZLE_TYPE_MICROTIME
101
 
    DRIZZLE_TYPE_VARCHAR,
102
110
  },
103
111
  /* DRIZZLE_TYPE_DOUBLE -> */
104
112
  {
 
113
    //DRIZZLE_TYPE_TINY
 
114
    DRIZZLE_TYPE_DOUBLE,
105
115
    //DRIZZLE_TYPE_LONG
106
116
    DRIZZLE_TYPE_DOUBLE,
107
117
    //DRIZZLE_TYPE_DOUBLE
118
128
    DRIZZLE_TYPE_VARCHAR,
119
129
    //DRIZZLE_TYPE_VARCHAR
120
130
    DRIZZLE_TYPE_VARCHAR,
121
 
    //DRIZZLE_TYPE_DECIMAL
 
131
    //DRIZZLE_TYPE_NEWDECIMAL
122
132
    DRIZZLE_TYPE_DOUBLE,
123
133
    //DRIZZLE_TYPE_ENUM
124
134
    DRIZZLE_TYPE_VARCHAR,
125
135
    //DRIZZLE_TYPE_BLOB
126
136
    DRIZZLE_TYPE_BLOB,
127
 
    //DRIZZLE_TYPE_TIME
128
 
    DRIZZLE_TYPE_TIME,
129
 
    //DRIZZLE_TYPE_BOOLEAN
130
 
    DRIZZLE_TYPE_VARCHAR,
131
 
    //DRIZZLE_TYPE_UUID
132
 
    DRIZZLE_TYPE_VARCHAR,
133
 
    //DRIZZLE_TYPE_MICROTIME
134
 
    DRIZZLE_TYPE_VARCHAR,
135
137
  },
136
138
  /* DRIZZLE_TYPE_NULL -> */
137
139
  {
 
140
    //DRIZZLE_TYPE_TINY
 
141
    DRIZZLE_TYPE_TINY,
138
142
    //DRIZZLE_TYPE_LONG
139
143
    DRIZZLE_TYPE_LONG,
140
144
    //DRIZZLE_TYPE_DOUBLE
151
155
    DRIZZLE_TYPE_DATE,
152
156
    //DRIZZLE_TYPE_VARCHAR
153
157
    DRIZZLE_TYPE_VARCHAR,
154
 
    //DRIZZLE_TYPE_DECIMAL
155
 
    DRIZZLE_TYPE_DECIMAL,
 
158
    //DRIZZLE_TYPE_NEWDECIMAL
 
159
    DRIZZLE_TYPE_NEWDECIMAL,
156
160
    //DRIZZLE_TYPE_ENUM
157
161
    DRIZZLE_TYPE_ENUM,
158
162
    //DRIZZLE_TYPE_BLOB
159
163
    DRIZZLE_TYPE_BLOB,
160
 
    //DRIZZLE_TYPE_TIME
161
 
    DRIZZLE_TYPE_TIME,
162
 
    //DRIZZLE_TYPE_BOOLEAN
163
 
    DRIZZLE_TYPE_BOOLEAN,
164
 
    //DRIZZLE_TYPE_UUID
165
 
    DRIZZLE_TYPE_UUID,
166
 
    //DRIZZLE_TYPE_MICROTIME
167
 
    DRIZZLE_TYPE_MICROTIME,
168
164
  },
169
165
  /* DRIZZLE_TYPE_TIMESTAMP -> */
170
166
  {
 
167
    //DRIZZLE_TYPE_TINY
 
168
    DRIZZLE_TYPE_VARCHAR,
171
169
    //DRIZZLE_TYPE_LONG
172
170
    DRIZZLE_TYPE_VARCHAR,
173
171
    //DRIZZLE_TYPE_DOUBLE
184
182
    DRIZZLE_TYPE_DATE,
185
183
    //DRIZZLE_TYPE_VARCHAR
186
184
    DRIZZLE_TYPE_VARCHAR,
187
 
    //DRIZZLE_TYPE_DECIMAL
 
185
    //DRIZZLE_TYPE_NEWDECIMAL
188
186
    DRIZZLE_TYPE_VARCHAR,
189
187
    //DRIZZLE_TYPE_ENUM
190
188
    DRIZZLE_TYPE_VARCHAR,
191
189
    //DRIZZLE_TYPE_BLOB
192
190
    DRIZZLE_TYPE_BLOB,
193
 
    //DRIZZLE_TYPE_TIME
194
 
    DRIZZLE_TYPE_TIME,
195
 
    //DRIZZLE_TYPE_BOOLEAN
196
 
    DRIZZLE_TYPE_VARCHAR,
197
 
    //DRIZZLE_TYPE_UUID
198
 
    DRIZZLE_TYPE_VARCHAR,
199
 
    //DRIZZLE_TYPE_MICROTIME
200
 
    DRIZZLE_TYPE_VARCHAR,
201
191
  },
202
192
  /* DRIZZLE_TYPE_LONGLONG -> */
203
193
  {
 
194
    //DRIZZLE_TYPE_TINY
 
195
    DRIZZLE_TYPE_LONGLONG,
204
196
    //DRIZZLE_TYPE_LONG
205
197
    DRIZZLE_TYPE_LONGLONG,
206
198
    //DRIZZLE_TYPE_DOUBLE
217
209
    DRIZZLE_TYPE_DATE,
218
210
    //DRIZZLE_TYPE_VARCHAR
219
211
    DRIZZLE_TYPE_VARCHAR,
220
 
    //DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_ENUM
221
 
    DRIZZLE_TYPE_DECIMAL,
 
212
    //DRIZZLE_TYPE_NEWDECIMAL DRIZZLE_TYPE_ENUM
 
213
    DRIZZLE_TYPE_NEWDECIMAL,
222
214
    DRIZZLE_TYPE_VARCHAR,
223
215
    //DRIZZLE_TYPE_BLOB
224
216
    DRIZZLE_TYPE_BLOB,
225
 
    //DRIZZLE_TYPE_TIME
226
 
    DRIZZLE_TYPE_TIME,
227
 
    //DRIZZLE_TYPE_BOOLEAN
228
 
    DRIZZLE_TYPE_VARCHAR,
229
 
    //DRIZZLE_TYPE_UUID
230
 
    DRIZZLE_TYPE_VARCHAR,
231
 
    //DRIZZLE_TYPE_MICROTIME
232
 
    DRIZZLE_TYPE_VARCHAR,
233
217
  },
234
218
  /* DRIZZLE_TYPE_DATETIME -> */
235
219
  {
 
220
    //DRIZZLE_TYPE_TINY
 
221
    DRIZZLE_TYPE_VARCHAR,
236
222
    //DRIZZLE_TYPE_LONG
237
223
    DRIZZLE_TYPE_VARCHAR,
238
224
    //DRIZZLE_TYPE_DOUBLE
249
235
    DRIZZLE_TYPE_DATE,
250
236
    //DRIZZLE_TYPE_VARCHAR
251
237
    DRIZZLE_TYPE_VARCHAR,
252
 
    //DRIZZLE_TYPE_DECIMAL
 
238
    //DRIZZLE_TYPE_NEWDECIMAL
253
239
    DRIZZLE_TYPE_VARCHAR,
254
240
    //DRIZZLE_TYPE_ENUM
255
241
    DRIZZLE_TYPE_VARCHAR,
256
242
    //DRIZZLE_TYPE_BLOB
257
243
    DRIZZLE_TYPE_BLOB,
258
 
    //DRIZZLE_TYPE_TIME
259
 
    DRIZZLE_TYPE_TIME,
260
 
    //DRIZZLE_TYPE_BOOLEAN
261
 
    DRIZZLE_TYPE_VARCHAR,
262
 
    //DRIZZLE_TYPE_UUID
263
 
    DRIZZLE_TYPE_VARCHAR,
264
 
    //DRIZZLE_TYPE_MICROTIME
265
 
    DRIZZLE_TYPE_VARCHAR,
266
244
  },
267
245
  /* DRIZZLE_TYPE_DATE -> */
268
246
  {
 
247
    //DRIZZLE_TYPE_TINY
 
248
    DRIZZLE_TYPE_VARCHAR,
269
249
    //DRIZZLE_TYPE_LONG
270
250
    DRIZZLE_TYPE_VARCHAR,
271
251
    //DRIZZLE_TYPE_DOUBLE
282
262
    DRIZZLE_TYPE_DATE,
283
263
    //DRIZZLE_TYPE_VARCHAR
284
264
    DRIZZLE_TYPE_VARCHAR,
285
 
    //DRIZZLE_TYPE_DECIMAL
 
265
    //DRIZZLE_TYPE_NEWDECIMAL
286
266
    DRIZZLE_TYPE_VARCHAR,
287
267
    //DRIZZLE_TYPE_ENUM
288
268
    DRIZZLE_TYPE_VARCHAR,
289
269
    //DRIZZLE_TYPE_BLOB
290
270
    DRIZZLE_TYPE_BLOB,
291
 
    //DRIZZLE_TYPE_TIME
292
 
    DRIZZLE_TYPE_TIME,
293
 
    //DRIZZLE_TYPE_BOOLEAN
294
 
    DRIZZLE_TYPE_VARCHAR,
295
 
    //DRIZZLE_TYPE_UUID
296
 
    DRIZZLE_TYPE_VARCHAR,
297
 
    //DRIZZLE_TYPE_MICROTIME
298
 
    DRIZZLE_TYPE_VARCHAR,
299
271
  },
300
272
  /* DRIZZLE_TYPE_VARCHAR -> */
301
273
  {
 
274
    //DRIZZLE_TYPE_TINY
 
275
    DRIZZLE_TYPE_VARCHAR,
302
276
    //DRIZZLE_TYPE_LONG
303
277
    DRIZZLE_TYPE_VARCHAR,
304
278
    //DRIZZLE_TYPE_DOUBLE
315
289
    DRIZZLE_TYPE_VARCHAR,
316
290
    //DRIZZLE_TYPE_VARCHAR
317
291
    DRIZZLE_TYPE_VARCHAR,
318
 
    //DRIZZLE_TYPE_DECIMAL
 
292
    //DRIZZLE_TYPE_NEWDECIMAL
319
293
    DRIZZLE_TYPE_VARCHAR,
320
294
    //DRIZZLE_TYPE_ENUM
321
295
    DRIZZLE_TYPE_VARCHAR,
322
296
    //DRIZZLE_TYPE_BLOB
323
297
    DRIZZLE_TYPE_BLOB,
324
 
    //DRIZZLE_TYPE_TIME
325
 
    DRIZZLE_TYPE_TIME,
326
 
    //DRIZZLE_TYPE_BOOLEAN
327
 
    DRIZZLE_TYPE_VARCHAR,
328
 
    //DRIZZLE_TYPE_UUID
329
 
    DRIZZLE_TYPE_VARCHAR,
330
 
    //DRIZZLE_TYPE_MICROTIME
331
 
    DRIZZLE_TYPE_VARCHAR,
332
298
  },
333
 
  /* DRIZZLE_TYPE_DECIMAL -> */
 
299
  /* DRIZZLE_TYPE_NEWDECIMAL -> */
334
300
  {
 
301
    //DRIZZLE_TYPE_TINY
 
302
    DRIZZLE_TYPE_NEWDECIMAL,
335
303
    //DRIZZLE_TYPE_LONG
336
 
    DRIZZLE_TYPE_DECIMAL,
 
304
    DRIZZLE_TYPE_NEWDECIMAL,
337
305
    //DRIZZLE_TYPE_DOUBLE
338
306
    DRIZZLE_TYPE_DOUBLE,
339
307
    //DRIZZLE_TYPE_NULL
340
 
    DRIZZLE_TYPE_DECIMAL,
 
308
    DRIZZLE_TYPE_NEWDECIMAL,
341
309
    //DRIZZLE_TYPE_TIMESTAMP
342
310
    DRIZZLE_TYPE_VARCHAR,
343
311
    //DRIZZLE_TYPE_LONGLONG
344
 
    DRIZZLE_TYPE_DECIMAL,
 
312
    DRIZZLE_TYPE_NEWDECIMAL,
345
313
    //DRIZZLE_TYPE_DATETIME
346
314
    DRIZZLE_TYPE_VARCHAR,
347
315
    //DRIZZLE_TYPE_DATE
348
316
    DRIZZLE_TYPE_VARCHAR,
349
317
    //DRIZZLE_TYPE_VARCHAR
350
318
    DRIZZLE_TYPE_VARCHAR,
351
 
    //DRIZZLE_TYPE_DECIMAL
352
 
    DRIZZLE_TYPE_DECIMAL,
 
319
    //DRIZZLE_TYPE_NEWDECIMAL
 
320
    DRIZZLE_TYPE_NEWDECIMAL,
353
321
    //DRIZZLE_TYPE_ENUM
354
322
    DRIZZLE_TYPE_VARCHAR,
355
323
    //DRIZZLE_TYPE_BLOB
356
324
    DRIZZLE_TYPE_BLOB,
357
 
    //DRIZZLE_TYPE_TIME
358
 
    DRIZZLE_TYPE_TIME,
359
 
    //DRIZZLE_TYPE_BOOLEAN
360
 
    DRIZZLE_TYPE_VARCHAR,
361
 
    //DRIZZLE_TYPE_UUID
362
 
    DRIZZLE_TYPE_VARCHAR,
363
 
    //DRIZZLE_TYPE_MICROTIME
364
 
    DRIZZLE_TYPE_VARCHAR,
365
325
  },
366
326
  /* DRIZZLE_TYPE_ENUM -> */
367
327
  {
 
328
    //DRIZZLE_TYPE_TINY
 
329
    DRIZZLE_TYPE_VARCHAR,
368
330
    //DRIZZLE_TYPE_LONG
369
331
    DRIZZLE_TYPE_VARCHAR,
370
332
    //DRIZZLE_TYPE_DOUBLE
381
343
    DRIZZLE_TYPE_VARCHAR,
382
344
    //DRIZZLE_TYPE_VARCHAR
383
345
    DRIZZLE_TYPE_VARCHAR,
384
 
    //DRIZZLE_TYPE_DECIMAL
 
346
    //DRIZZLE_TYPE_NEWDECIMAL
385
347
    DRIZZLE_TYPE_VARCHAR,
386
348
    //DRIZZLE_TYPE_ENUM
387
349
    DRIZZLE_TYPE_VARCHAR,
388
350
    //DRIZZLE_TYPE_BLOB
389
351
    DRIZZLE_TYPE_BLOB,
390
 
    //DRIZZLE_TYPE_TIME
391
 
    DRIZZLE_TYPE_TIME,
392
 
    //DRIZZLE_TYPE_BOOLEAN
393
 
    DRIZZLE_TYPE_VARCHAR,
394
 
    //DRIZZLE_TYPE_UUID
395
 
    DRIZZLE_TYPE_VARCHAR,
396
 
    //DRIZZLE_TYPE_MICROTIME
397
 
    DRIZZLE_TYPE_VARCHAR,
398
 
   },
 
352
  },
399
353
  /* DRIZZLE_TYPE_BLOB -> */
400
354
  {
 
355
    //DRIZZLE_TYPE_TINY
 
356
    DRIZZLE_TYPE_BLOB,
401
357
    //DRIZZLE_TYPE_LONG
402
358
    DRIZZLE_TYPE_BLOB,
403
359
    //DRIZZLE_TYPE_DOUBLE
414
370
    DRIZZLE_TYPE_BLOB,
415
371
    //DRIZZLE_TYPE_VARCHAR
416
372
    DRIZZLE_TYPE_BLOB,
417
 
    //DRIZZLE_TYPE_DECIMAL
 
373
    //DRIZZLE_TYPE_NEWDECIMAL
418
374
    DRIZZLE_TYPE_BLOB,
419
375
    //DRIZZLE_TYPE_ENUM
420
376
    DRIZZLE_TYPE_BLOB,
421
377
    //DRIZZLE_TYPE_BLOB
422
378
    DRIZZLE_TYPE_BLOB,
423
 
    //DRIZZLE_TYPE_TIME
424
 
    DRIZZLE_TYPE_TIME,
425
 
    //DRIZZLE_TYPE_BOOLEAN
426
 
    DRIZZLE_TYPE_VARCHAR,
427
 
    //DRIZZLE_TYPE_UUID
428
 
    DRIZZLE_TYPE_VARCHAR,
429
 
    //DRIZZLE_TYPE_MICROTIME
430
 
    DRIZZLE_TYPE_VARCHAR,
431
 
  },
432
 
  /* DRIZZLE_TYPE_TIME -> */
433
 
  {
434
 
    //DRIZZLE_TYPE_LONG
435
 
    DRIZZLE_TYPE_VARCHAR,
436
 
    //DRIZZLE_TYPE_DOUBLE
437
 
    DRIZZLE_TYPE_VARCHAR,
438
 
    //DRIZZLE_TYPE_NULL
439
 
    DRIZZLE_TYPE_TIME,
440
 
    //DRIZZLE_TYPE_TIMESTAMP
441
 
    DRIZZLE_TYPE_VARCHAR,
442
 
    //DRIZZLE_TYPE_LONGLONG
443
 
    DRIZZLE_TYPE_VARCHAR,
444
 
    //DRIZZLE_TYPE_DATETIME
445
 
    DRIZZLE_TYPE_VARCHAR,
446
 
    //DRIZZLE_TYPE_DATE
447
 
    DRIZZLE_TYPE_VARCHAR,
448
 
    //DRIZZLE_TYPE_VARCHAR
449
 
    DRIZZLE_TYPE_VARCHAR,
450
 
    //DRIZZLE_TYPE_DECIMAL
451
 
    DRIZZLE_TYPE_VARCHAR,
452
 
    //DRIZZLE_TYPE_VARCHAR,
453
 
    DRIZZLE_TYPE_VARCHAR,
454
 
    //DRIZZLE_TYPE_BLOB
455
 
    DRIZZLE_TYPE_BLOB,
456
 
    //DRIZZLE_TYPE_TIME
457
 
    DRIZZLE_TYPE_TIME,
458
 
    //DRIZZLE_TYPE_BOOLEAN
459
 
    DRIZZLE_TYPE_VARCHAR,
460
 
    //DRIZZLE_TYPE_UUID
461
 
    DRIZZLE_TYPE_UUID,
462
 
    //DRIZZLE_TYPE_MICROTIME
463
 
    DRIZZLE_TYPE_VARCHAR,
464
 
  },
465
 
  /* DRIZZLE_TYPE_BOOLEAN -> */
466
 
  {
467
 
    //DRIZZLE_TYPE_LONG
468
 
    DRIZZLE_TYPE_VARCHAR,
469
 
    //DRIZZLE_TYPE_DOUBLE
470
 
    DRIZZLE_TYPE_VARCHAR,
471
 
    //DRIZZLE_TYPE_NULL
472
 
    DRIZZLE_TYPE_BOOLEAN,
473
 
    //DRIZZLE_TYPE_TIMESTAMP
474
 
    DRIZZLE_TYPE_VARCHAR,
475
 
    //DRIZZLE_TYPE_LONGLONG
476
 
    DRIZZLE_TYPE_VARCHAR,
477
 
    //DRIZZLE_TYPE_DATETIME
478
 
    DRIZZLE_TYPE_VARCHAR,
479
 
    //DRIZZLE_TYPE_DATE
480
 
    DRIZZLE_TYPE_VARCHAR,
481
 
    //DRIZZLE_TYPE_VARCHAR
482
 
    DRIZZLE_TYPE_VARCHAR,
483
 
    //DRIZZLE_TYPE_DECIMAL
484
 
    DRIZZLE_TYPE_VARCHAR,
485
 
    //DRIZZLE_TYPE_VARCHAR,
486
 
    DRIZZLE_TYPE_VARCHAR,
487
 
    //DRIZZLE_TYPE_BLOB
488
 
    DRIZZLE_TYPE_BLOB,
489
 
    //DRIZZLE_TYPE_TIME
490
 
    DRIZZLE_TYPE_TIME,
491
 
    //DRIZZLE_TYPE_BOOLEAN
492
 
    DRIZZLE_TYPE_BOOLEAN,
493
 
    //DRIZZLE_TYPE_UUID
494
 
    DRIZZLE_TYPE_VARCHAR,
495
 
    //DRIZZLE_TYPE_MICROTIME
496
 
    DRIZZLE_TYPE_VARCHAR,
497
 
  },
498
 
  /* DRIZZLE_TYPE_UUID -> */
499
 
  {
500
 
    //DRIZZLE_TYPE_LONG
501
 
    DRIZZLE_TYPE_VARCHAR,
502
 
    //DRIZZLE_TYPE_DOUBLE
503
 
    DRIZZLE_TYPE_VARCHAR,
504
 
    //DRIZZLE_TYPE_NULL
505
 
    DRIZZLE_TYPE_UUID,
506
 
    //DRIZZLE_TYPE_TIMESTAMP
507
 
    DRIZZLE_TYPE_VARCHAR,
508
 
    //DRIZZLE_TYPE_LONGLONG
509
 
    DRIZZLE_TYPE_VARCHAR,
510
 
    //DRIZZLE_TYPE_DATETIME
511
 
    DRIZZLE_TYPE_VARCHAR,
512
 
    //DRIZZLE_TYPE_DATE
513
 
    DRIZZLE_TYPE_VARCHAR,
514
 
    //DRIZZLE_TYPE_VARCHAR
515
 
    DRIZZLE_TYPE_VARCHAR,
516
 
    //DRIZZLE_TYPE_DECIMAL
517
 
    DRIZZLE_TYPE_VARCHAR,
518
 
    //DRIZZLE_TYPE_VARCHAR,
519
 
    DRIZZLE_TYPE_VARCHAR,
520
 
    //DRIZZLE_TYPE_BLOB
521
 
    DRIZZLE_TYPE_BLOB,
522
 
    //DRIZZLE_TYPE_TIME
523
 
    DRIZZLE_TYPE_TIME,
524
 
    //DRIZZLE_TYPE_BOOLEAN
525
 
    DRIZZLE_TYPE_VARCHAR,
526
 
    //DRIZZLE_TYPE_UUID
527
 
    DRIZZLE_TYPE_UUID,
528
 
    //DRIZZLE_TYPE_MICROTIME
529
 
    DRIZZLE_TYPE_VARCHAR,
530
 
  },
531
 
  /* DRIZZLE_TYPE_MICROTIME -> */
532
 
  {
533
 
    //DRIZZLE_TYPE_LONG
534
 
    DRIZZLE_TYPE_VARCHAR,
535
 
    //DRIZZLE_TYPE_DOUBLE
536
 
    DRIZZLE_TYPE_VARCHAR,
537
 
    //DRIZZLE_TYPE_NULL
538
 
    DRIZZLE_TYPE_MICROTIME,
539
 
    //DRIZZLE_TYPE_TIMESTAMP
540
 
    DRIZZLE_TYPE_VARCHAR,
541
 
    //DRIZZLE_TYPE_LONGLONG
542
 
    DRIZZLE_TYPE_VARCHAR,
543
 
    //DRIZZLE_TYPE_DATETIME
544
 
    DRIZZLE_TYPE_VARCHAR,
545
 
    //DRIZZLE_TYPE_DATE
546
 
    DRIZZLE_TYPE_VARCHAR,
547
 
    //DRIZZLE_TYPE_VARCHAR
548
 
    DRIZZLE_TYPE_VARCHAR,
549
 
    //DRIZZLE_TYPE_DECIMAL
550
 
    DRIZZLE_TYPE_VARCHAR,
551
 
    //DRIZZLE_TYPE_VARCHAR,
552
 
    DRIZZLE_TYPE_VARCHAR,
553
 
    //DRIZZLE_TYPE_BLOB
554
 
    DRIZZLE_TYPE_BLOB,
555
 
    //DRIZZLE_TYPE_TIME
556
 
    DRIZZLE_TYPE_TIME,
557
 
    //DRIZZLE_TYPE_BOOLEAN
558
 
    DRIZZLE_TYPE_VARCHAR,
559
 
    //DRIZZLE_TYPE_UUID
560
 
    DRIZZLE_TYPE_UUID,
561
 
    //DRIZZLE_TYPE_MICROTIME
562
 
    DRIZZLE_TYPE_MICROTIME,
563
379
  },
564
380
};
565
381
 
566
 
static Item_result field_types_result_type [enum_field_types_size]=
 
382
static Item_result field_types_result_type [DRIZZLE_TYPE_MAX+1]=
567
383
{
 
384
  //DRIZZLE_TYPE_TINY
 
385
  INT_RESULT,
568
386
  //DRIZZLE_TYPE_LONG
569
387
  INT_RESULT,
570
388
  //DRIZZLE_TYPE_DOUBLE
581
399
  STRING_RESULT,
582
400
  //DRIZZLE_TYPE_VARCHAR
583
401
  STRING_RESULT,
584
 
  //DRIZZLE_TYPE_DECIMAL   
 
402
  //DRIZZLE_TYPE_NEWDECIMAL   
585
403
  DECIMAL_RESULT,           
586
404
  //DRIZZLE_TYPE_ENUM
587
405
  STRING_RESULT,
588
406
  //DRIZZLE_TYPE_BLOB
589
407
  STRING_RESULT,
590
 
  //DRIZZLE_TYPE_TIME
591
 
  STRING_RESULT,
592
 
  //DRIZZLE_TYPE_BOOLEAN
593
 
  STRING_RESULT,
594
 
  //DRIZZLE_TYPE_UUID
595
 
  STRING_RESULT,
596
 
  //DRIZZLE_TYPE_MICROTIME
597
 
  STRING_RESULT,
598
408
};
599
409
 
600
410
bool test_if_important_data(const CHARSET_INFO * const cs, 
606
416
  return (str < strend);
607
417
}
608
418
 
609
 
void *Field::operator new(size_t size)
610
 
{
611
 
  return memory::sql_alloc(size);
612
 
}
613
 
 
614
 
void *Field::operator new(size_t size, memory::Root *mem_root)
615
 
{
616
 
  return mem_root->alloc_root(static_cast<uint32_t>(size));
617
 
}
618
 
 
619
419
enum_field_types Field::field_type_merge(enum_field_types a,
620
420
                                         enum_field_types b)
621
421
{
622
 
  assert(a < enum_field_types_size);
623
 
  assert(b < enum_field_types_size);
 
422
  assert(a <= DRIZZLE_TYPE_MAX);
 
423
  assert(b <= DRIZZLE_TYPE_MAX);
624
424
  return field_types_merge_rules[a][b];
625
425
}
626
426
 
627
427
Item_result Field::result_merge_type(enum_field_types field_type)
628
428
{
629
 
  assert(field_type < enum_field_types_size);
 
429
  assert(field_type <= DRIZZLE_TYPE_MAX);
630
430
  return field_types_result_type[field_type];
631
431
}
632
432
 
646
446
  return pack_length();
647
447
}
648
448
 
 
449
uint32_t Field::pack_length_from_metadata(uint32_t field_metadata)
 
450
{
 
451
  return field_metadata;
 
452
}
 
453
 
 
454
uint32_t Field::row_pack_length()
 
455
{
 
456
  return 0;
 
457
}
 
458
 
 
459
int Field::save_field_metadata(unsigned char *first_byte)
 
460
{
 
461
  return do_save_field_metadata(first_byte);
 
462
}
 
463
 
649
464
uint32_t Field::data_length()
650
465
{
651
466
  return pack_length();
677
492
 
678
493
void Field::set_default()
679
494
{
680
 
  ptrdiff_t l_offset= (ptrdiff_t) (table->getDefaultValues() - table->getInsertRecord());
 
495
  ptrdiff_t l_offset= (ptrdiff_t) (table->getDefaultValues() - table->record[0]);
681
496
  memcpy(ptr, ptr + l_offset, pack_length());
682
497
  if (null_ptr)
683
498
    *null_ptr= ((*null_ptr & (unsigned char) ~null_bit) | (null_ptr[l_offset] & null_bit));
746
561
  return 0;
747
562
}
748
563
 
749
 
bool Field::is_null(ptrdiff_t row_offset) const
 
564
bool Field::is_null(my_ptrdiff_t row_offset)
750
565
{
751
566
  return null_ptr ?
752
567
    (null_ptr[row_offset] & null_bit ? true : false) :
753
568
    table->null_row;
754
569
}
755
570
 
756
 
bool Field::is_real_null(ptrdiff_t row_offset) const
 
571
bool Field::is_real_null(my_ptrdiff_t row_offset)
757
572
{
758
573
  return null_ptr ? (null_ptr[row_offset] & null_bit ? true : false) : false;
759
574
}
760
575
 
761
 
bool Field::is_null_in_record(const unsigned char *record) const
 
576
bool Field::is_null_in_record(const unsigned char *record)
762
577
{
763
578
  if (! null_ptr)
764
579
    return false;
765
 
  return test(record[(uint32_t) (null_ptr -table->getInsertRecord())] & null_bit);
 
580
  return test(record[(uint32_t) (null_ptr -table->record[0])] & null_bit);
766
581
}
767
582
 
768
 
bool Field::is_null_in_record_with_offset(ptrdiff_t with_offset) const
 
583
bool Field::is_null_in_record_with_offset(my_ptrdiff_t with_offset)
769
584
{
770
585
  if (! null_ptr)
771
586
    return false;
772
587
  return test(null_ptr[with_offset] & null_bit);
773
588
}
774
589
 
775
 
void Field::set_null(ptrdiff_t row_offset)
 
590
void Field::set_null(my_ptrdiff_t row_offset)
776
591
{
777
592
  if (null_ptr)
778
593
    null_ptr[row_offset]|= null_bit;
779
594
}
780
595
 
781
 
void Field::set_notnull(ptrdiff_t row_offset)
 
596
void Field::set_notnull(my_ptrdiff_t row_offset)
782
597
{
783
598
  if (null_ptr)
784
599
    null_ptr[row_offset]&= (unsigned char) ~null_bit;
785
600
}
786
601
 
787
 
bool Field::maybe_null(void) const
 
602
bool Field::maybe_null(void)
788
603
{
789
604
  return null_ptr != 0 || table->maybe_null;
790
605
}
791
606
 
792
 
bool Field::real_maybe_null(void) const
 
607
bool Field::real_maybe_null(void)
793
608
{
794
609
  return null_ptr != 0;
795
610
}
823
638
void Field::init(Table *table_arg)
824
639
{
825
640
  orig_table= table= table_arg;
 
641
  table_name= &table_arg->alias;
 
642
}
 
643
 
 
644
String *Field::val_int_as_str(String *val_buffer, bool unsigned_val)
 
645
{
 
646
  const CHARSET_INFO * const cs= &my_charset_bin;
 
647
  uint32_t length;
 
648
  int64_t value= val_int();
 
649
 
 
650
  if (val_buffer->alloc(MY_INT64_NUM_DECIMAL_DIGITS))
 
651
    return 0;
 
652
  length= (uint32_t) (*cs->cset->int64_t10_to_str)(cs, (char*) val_buffer->ptr(),
 
653
                                                MY_INT64_NUM_DECIMAL_DIGITS,
 
654
                                                unsigned_val ? 10 : -10,
 
655
                                                value);
 
656
  val_buffer->length(length);
 
657
  return val_buffer;
826
658
}
827
659
 
828
660
/// This is used as a table name when the table structure is not set up
831
663
             unsigned char *null_ptr_arg,
832
664
             unsigned char null_bit_arg,
833
665
             utype unireg_check_arg, 
834
 
             const char *field_name_arg) :
 
666
             const char *field_name_arg)
 
667
  :
835
668
    ptr(ptr_arg),
836
669
    null_ptr(null_ptr_arg),
837
670
    table(NULL),
838
671
    orig_table(NULL),
 
672
    table_name(NULL),
839
673
    field_name(field_name_arg),
840
 
    comment(NULL_LEX_STRING),
841
674
    key_start(0),
842
675
    part_of_key(0),
843
676
    part_of_key_not_clustered(0),
844
677
    part_of_sortkey(0),
845
678
    unireg_check(unireg_check_arg),
846
679
    field_length(length_arg),
847
 
    flags(null_ptr ? 0: NOT_NULL_FLAG),
848
 
    field_index(0),
849
680
    null_bit(null_bit_arg),
850
681
    is_created_from_null_item(false)
851
682
{
 
683
  flags= null_ptr ? 0: NOT_NULL_FLAG;
 
684
  comment.str= (char*) "";
 
685
  comment.length= 0;
 
686
  field_index= 0;
852
687
}
853
688
 
854
 
void Field::hash(uint32_t *nr, uint32_t *nr2) const
 
689
void Field::hash(uint32_t *nr, uint32_t *nr2)
855
690
{
856
691
  if (is_null())
857
692
  {
877
712
  }
878
713
}
879
714
 
880
 
int Field::store_and_check(enum_check_fields check_level,
881
 
                           const char *to, 
882
 
                           uint32_t length,
883
 
                           const CHARSET_INFO * const cs)
 
715
int Field::compatible_field_size(uint32_t field_metadata)
 
716
{
 
717
  uint32_t const source_size= pack_length_from_metadata(field_metadata);
 
718
  uint32_t const destination_size= row_pack_length();
 
719
  return (source_size <= destination_size);
 
720
}
884
721
 
 
722
int Field::store(const char *to, 
 
723
                 uint32_t length,
 
724
                 const CHARSET_INFO * const cs,
 
725
                 enum_check_fields check_level)
885
726
{
886
727
  int res;
887
728
  enum_check_fields old_check_level= table->in_use->count_cuted_fields;
901
742
 
902
743
unsigned char *Field::pack(unsigned char *to, const unsigned char *from)
903
744
{
904
 
  unsigned char *result= this->pack(to, from, UINT32_MAX, table->getShare()->db_low_byte_first);
 
745
  unsigned char *result= this->pack(to, from, UINT32_MAX, table->s->db_low_byte_first);
905
746
  return(result);
906
747
}
907
748
 
939
780
 
940
781
const unsigned char *Field::unpack(unsigned char* to, const unsigned char *from)
941
782
{
942
 
  const unsigned char *result= unpack(to, from, 0U, table->getShare()->db_low_byte_first);
 
783
  const unsigned char *result= unpack(to, from, 0U, table->s->db_low_byte_first);
943
784
  return(result);
944
785
}
945
786
 
946
 
type::Decimal *Field::val_decimal(type::Decimal *) const
 
787
uint32_t Field::packed_col_length(const unsigned char *, uint32_t length)
 
788
{
 
789
  return length;
 
790
}
 
791
 
 
792
int Field::pack_cmp(const unsigned char *a, const unsigned char *b,
 
793
                    uint32_t, bool)
 
794
{
 
795
  return cmp(a,b);
 
796
}
 
797
 
 
798
int Field::pack_cmp(const unsigned char *b, uint32_t, bool)
 
799
{
 
800
  return cmp(ptr,b);
 
801
}
 
802
 
 
803
my_decimal *Field::val_decimal(my_decimal *)
947
804
{
948
805
  /* This never have to be called */
949
806
  assert(0);
953
810
 
954
811
void Field::make_field(SendField *field)
955
812
{
956
 
  if (orig_table && orig_table->getShare()->getSchemaName() && *orig_table->getShare()->getSchemaName())
 
813
  if (orig_table && orig_table->s->db.str && *orig_table->s->db.str)
957
814
  {
958
 
    field->db_name= orig_table->getShare()->getSchemaName();
959
 
    field->org_table_name= orig_table->getShare()->getTableName();
 
815
    field->db_name= orig_table->s->db.str;
 
816
    field->org_table_name= orig_table->s->table_name.str;
960
817
  }
961
818
  else
962
819
    field->org_table_name= field->db_name= "";
963
820
  if (orig_table)
964
821
  {
965
 
    field->table_name= orig_table->getAlias();
 
822
    field->table_name= orig_table->alias;
966
823
    field->org_col_name= field_name;
967
824
  }
968
825
  else
978
835
  field->decimals= 0;
979
836
}
980
837
 
981
 
int64_t Field::convert_decimal2int64_t(const type::Decimal *val, bool, int *err)
 
838
int64_t Field::convert_decimal2int64_t(const my_decimal *val, bool, int *err)
982
839
{
983
840
  int64_t i;
984
 
  if (warn_if_overflow(val->val_int32(E_DEC_ERROR &
 
841
  if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
985
842
                                      ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
986
 
                                      false, &i)))
 
843
                                      val, false, &i)))
987
844
  {
988
845
    i= (val->sign() ? INT64_MIN : INT64_MAX);
989
846
    *err= 1;
991
848
  return i;
992
849
}
993
850
 
994
 
uint32_t Field::fill_cache_field(CacheField *copy)
 
851
uint32_t Field::fill_cache_field(CACHE_FIELD *copy)
995
852
{
996
853
  uint32_t store_length;
997
854
  copy->str=ptr;
1001
858
  {
1002
859
    copy->blob_field=(Field_blob*) this;
1003
860
    copy->strip=0;
1004
 
    copy->length-= table->getShare()->sizeBlobPtr();
 
861
    copy->length-= table->s->blob_ptr_size;
1005
862
    return copy->length;
1006
863
  }
1007
864
  else
1012
869
  return copy->length+ store_length;
1013
870
}
1014
871
 
1015
 
bool Field::get_date(type::Time &ltime, uint32_t fuzzydate) const
1016
 
{
1017
 
  char buff[type::Time::MAX_STRING_LENGTH];
1018
 
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
1019
 
 
1020
 
  assert(getTable() and getTable()->getSession());
1021
 
 
1022
 
  if (not (res= val_str_internal(&tmp)) or
1023
 
      str_to_datetime_with_warn(getTable()->getSession(),
1024
 
                                res->ptr(), res->length(),
1025
 
                                &ltime, fuzzydate) <= type::DRIZZLE_TIMESTAMP_ERROR)
1026
 
  {
1027
 
    return true;
1028
 
  }
1029
 
 
1030
 
  return false;
1031
 
}
1032
 
 
1033
 
bool Field::get_time(type::Time &ltime) const
1034
 
{
1035
 
  char buff[type::Time::MAX_STRING_LENGTH];
1036
 
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
1037
 
 
1038
 
  if (not (res= val_str_internal(&tmp)) or
1039
 
      str_to_time_with_warn(getTable()->getSession(), res->ptr(), res->length(), &ltime))
1040
 
  {
1041
 
    return true;
1042
 
  }
1043
 
 
1044
 
  return false;
1045
 
}
1046
 
 
1047
 
int Field::store_time(type::Time &ltime, type::timestamp_t)
1048
 
{
1049
 
  String tmp;
1050
 
 
1051
 
  ltime.convert(tmp);
1052
 
 
1053
 
  return store(tmp.ptr(), tmp.length(), &my_charset_bin);
1054
 
}
1055
 
 
1056
 
bool Field::optimize_range(uint32_t idx, uint32_t)
1057
 
{
1058
 
  return test(table->index_flags(idx) & HA_READ_RANGE);
1059
 
}
1060
 
 
1061
 
Field *Field::new_field(memory::Root *root, Table *new_table, bool)
 
872
bool Field::get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
 
873
{
 
874
  char buff[40];
 
875
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
 
876
  if (!(res=val_str(&tmp)) ||
 
877
      str_to_datetime_with_warn(res->ptr(), res->length(),
 
878
                                ltime, fuzzydate) <= DRIZZLE_TIMESTAMP_ERROR)
 
879
    return 1;
 
880
  return 0;
 
881
}
 
882
 
 
883
bool Field::get_time(DRIZZLE_TIME *ltime)
 
884
{
 
885
  char buff[40];
 
886
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
 
887
  if (!(res=val_str(&tmp)) ||
 
888
      str_to_time_with_warn(res->ptr(), res->length(), ltime))
 
889
    return 1;
 
890
  return 0;
 
891
}
 
892
 
 
893
int Field::store_time(DRIZZLE_TIME *ltime, enum enum_drizzle_timestamp_type)
 
894
{
 
895
  char buff[MAX_DATE_STRING_REP_LENGTH];
 
896
  uint32_t length= (uint32_t) my_TIME_to_str(ltime, buff);
 
897
  return store(buff, length, &my_charset_bin);
 
898
}
 
899
 
 
900
bool Field::optimize_range(uint32_t idx, uint32_t part)
 
901
{
 
902
  return test(table->file->index_flags(idx, part, 1) & HA_READ_RANGE);
 
903
}
 
904
 
 
905
Field *Field::new_field(MEM_ROOT *root, Table *new_table, bool)
1062
906
{
1063
907
  Field *tmp;
1064
 
  if (!(tmp= (Field*) root->memdup_root((char*) this,size_of())))
 
908
  if (!(tmp= (Field*) memdup_root(root,(char*) this,size_of())))
1065
909
    return 0;
1066
910
 
1067
911
  if (tmp->table->maybe_null)
1071
915
  tmp->part_of_key.reset();
1072
916
  tmp->part_of_sortkey.reset();
1073
917
  tmp->unireg_check= Field::NONE;
1074
 
  tmp->flags&= (NOT_NULL_FLAG | BLOB_FLAG | UNSIGNED_FLAG | BINARY_FLAG | ENUM_FLAG);
 
918
  tmp->flags&= (NOT_NULL_FLAG | BLOB_FLAG | UNSIGNED_FLAG | BINARY_FLAG | ENUM_FLAG | SET_FLAG);
1075
919
  tmp->reset_fields();
1076
920
  return tmp;
1077
921
}
1078
922
 
1079
 
Field *Field::new_key_field(memory::Root *root, Table *new_table,
 
923
Field *Field::new_key_field(MEM_ROOT *root, Table *new_table,
1080
924
                            unsigned char *new_ptr,
1081
925
                            unsigned char *new_null_ptr,
1082
926
                            uint32_t new_null_bit)
1091
935
  return tmp;
1092
936
}
1093
937
 
1094
 
Field *Field::clone(memory::Root *root, Table *new_table)
 
938
Field *Field::clone(MEM_ROOT *root, Table *new_table)
1095
939
{
1096
940
  Field *tmp;
1097
 
  if ((tmp= (Field*) root->memdup_root((char*) this,size_of())))
 
941
  if ((tmp= (Field*) memdup_root(root,(char*) this,size_of())))
1098
942
  {
1099
943
    tmp->init(new_table);
1100
 
    tmp->move_field_offset((ptrdiff_t) (new_table->getInsertRecord() -
1101
 
                                           new_table->getDefaultValues()));
 
944
    tmp->move_field_offset((my_ptrdiff_t) (new_table->record[0] -
 
945
                                           new_table->s->default_values));
1102
946
  }
1103
947
  return tmp;
1104
948
}
1121
965
{
1122
966
  if (!Field::eq_def(field))
1123
967
    return 0;
1124
 
 
1125
968
  TYPELIB *from_lib=((Field_enum*) field)->typelib;
1126
969
 
1127
970
  if (typelib->count < from_lib->count)
1128
971
    return 0;
1129
 
 
1130
972
  for (uint32_t i=0 ; i < from_lib->count ; i++)
1131
 
  {
1132
973
    if (my_strnncoll(field_charset,
1133
974
                     (const unsigned char*)typelib->type_names[i],
1134
975
                     strlen(typelib->type_names[i]),
1135
976
                     (const unsigned char*)from_lib->type_names[i],
1136
977
                     strlen(from_lib->type_names[i])))
1137
978
      return 0;
1138
 
  }
1139
 
 
1140
979
  return 1;
1141
980
}
1142
981
 
 
982
/*
 
983
  Make a field from the .frm file info
 
984
*/
1143
985
uint32_t calc_pack_length(enum_field_types type,uint32_t length)
1144
986
{
1145
987
  switch (type) {
1146
988
  case DRIZZLE_TYPE_VARCHAR: return (length + (length < 256 ? 1: 2));
1147
 
  case DRIZZLE_TYPE_UUID: return field::Uuid::max_string_length();
1148
 
  case DRIZZLE_TYPE_MICROTIME: return field::Microtime::max_string_length();
1149
 
  case DRIZZLE_TYPE_TIMESTAMP: return field::Epoch::max_string_length();
1150
 
  case DRIZZLE_TYPE_BOOLEAN: return field::Boolean::max_string_length();
1151
 
  case DRIZZLE_TYPE_DATE:
1152
 
  case DRIZZLE_TYPE_ENUM:
 
989
  case DRIZZLE_TYPE_TINY: return 1;
 
990
  case DRIZZLE_TYPE_DATE: return 3;
 
991
  case DRIZZLE_TYPE_TIMESTAMP:
1153
992
  case DRIZZLE_TYPE_LONG: return 4;
1154
993
  case DRIZZLE_TYPE_DOUBLE: return sizeof(double);
1155
 
  case DRIZZLE_TYPE_TIME:
1156
994
  case DRIZZLE_TYPE_DATETIME:
1157
995
  case DRIZZLE_TYPE_LONGLONG: return 8; /* Don't crash if no int64_t */
1158
996
  case DRIZZLE_TYPE_NULL: return 0;
1159
997
  case DRIZZLE_TYPE_BLOB: return 4 + portable_sizeof_char_ptr;
1160
 
  case DRIZZLE_TYPE_DECIMAL:
1161
 
                          break;
 
998
  case DRIZZLE_TYPE_ENUM:
 
999
  case DRIZZLE_TYPE_NEWDECIMAL:
 
1000
    abort();
 
1001
  default:
 
1002
    return 0;
1162
1003
  }
1163
 
 
1164
 
  assert(0);
1165
 
  abort();
1166
1004
}
1167
1005
 
1168
1006
uint32_t pack_length_to_packflag(uint32_t type)
1171
1009
    case 1: return 1 << FIELDFLAG_PACK_SHIFT;
1172
1010
    case 2: assert(1);
1173
1011
    case 3: assert(1);
1174
 
    case 4: return f_settype(DRIZZLE_TYPE_LONG);
1175
 
    case 8: return f_settype(DRIZZLE_TYPE_LONGLONG);
 
1012
    case 4: return f_settype((uint32_t) DRIZZLE_TYPE_LONG);
 
1013
    case 8: return f_settype((uint32_t) DRIZZLE_TYPE_LONGLONG);
1176
1014
  }
1177
1015
  return 0;                                     // This shouldn't happen
1178
1016
}
1179
1017
 
 
1018
Field *make_field(TableShare *share,
 
1019
                  MEM_ROOT *root,
 
1020
                  unsigned char *ptr,
 
1021
                  uint32_t field_length,
 
1022
                  unsigned char *null_pos,
 
1023
                  unsigned char null_bit,
 
1024
                  uint32_t pack_flag,
 
1025
                  enum_field_types field_type,
 
1026
                  const CHARSET_INFO * field_charset,
 
1027
                  Field::utype unireg_check,
 
1028
                  TYPELIB *interval,
 
1029
                  const char *field_name)
 
1030
{
 
1031
  if(!root)
 
1032
    root= current_mem_root();
 
1033
 
 
1034
  if (!f_maybe_null(pack_flag))
 
1035
  {
 
1036
    null_pos=0;
 
1037
    null_bit=0;
 
1038
  }
 
1039
  else
 
1040
  {
 
1041
    null_bit= ((unsigned char) 1) << null_bit;
 
1042
  }
 
1043
 
 
1044
  switch (field_type) {
 
1045
  case DRIZZLE_TYPE_DATE:
 
1046
  case DRIZZLE_TYPE_DATETIME:
 
1047
  case DRIZZLE_TYPE_TIMESTAMP:
 
1048
    field_charset= &my_charset_bin;
 
1049
  default: break;
 
1050
  }
 
1051
 
 
1052
  if (f_is_alpha(pack_flag))
 
1053
  {
 
1054
    if (!f_is_packed(pack_flag))
 
1055
    {
 
1056
      if (field_type == DRIZZLE_TYPE_VARCHAR)
 
1057
        return new (root) Field_varstring(ptr,field_length,
 
1058
                                   HA_VARCHAR_PACKLENGTH(field_length),
 
1059
                                   null_pos,null_bit,
 
1060
                                   unireg_check, field_name,
 
1061
                                   share,
 
1062
                                   field_charset);
 
1063
      return 0;                                 // Error
 
1064
    }
 
1065
 
 
1066
    uint32_t pack_length=calc_pack_length((enum_field_types)
 
1067
                                      f_packtype(pack_flag),
 
1068
                                      field_length);
 
1069
 
 
1070
    if (f_is_blob(pack_flag))
 
1071
      return new (root) Field_blob(ptr,null_pos,null_bit,
 
1072
                            unireg_check, field_name, share,
 
1073
                            pack_length, field_charset);
 
1074
    if (interval)
 
1075
    {
 
1076
      if (f_is_enum(pack_flag))
 
1077
      {
 
1078
        return new (root) Field_enum(ptr,field_length,null_pos,null_bit,
 
1079
                                  unireg_check, field_name,
 
1080
                                  get_enum_pack_length(interval->count),
 
1081
                                  interval, field_charset);
 
1082
      }
 
1083
    }
 
1084
  }
 
1085
 
 
1086
  switch (field_type) {
 
1087
  case DRIZZLE_TYPE_NEWDECIMAL:
 
1088
    return new (root) Field_new_decimal(ptr,field_length,null_pos,null_bit,
 
1089
                                 unireg_check, field_name,
 
1090
                                 f_decimals(pack_flag),
 
1091
                                 f_is_decimal_precision(pack_flag) != 0,
 
1092
                                 f_is_dec(pack_flag) == 0);
 
1093
  case DRIZZLE_TYPE_DOUBLE:
 
1094
    return new (root) Field_double(ptr,field_length,null_pos,null_bit,
 
1095
                            unireg_check, field_name,
 
1096
                            f_decimals(pack_flag),
 
1097
                            false,
 
1098
                            f_is_dec(pack_flag)== 0);
 
1099
  case DRIZZLE_TYPE_TINY:
 
1100
    assert(0);
 
1101
  case DRIZZLE_TYPE_LONG:
 
1102
    return new (root) Field_long(ptr,field_length,null_pos,null_bit,
 
1103
                           unireg_check, field_name,
 
1104
                           false,
 
1105
                           f_is_dec(pack_flag) == 0);
 
1106
  case DRIZZLE_TYPE_LONGLONG:
 
1107
    return new (root) Field_int64_t(ptr,field_length,null_pos,null_bit,
 
1108
                              unireg_check, field_name,
 
1109
                              false,
 
1110
                              f_is_dec(pack_flag) == 0);
 
1111
  case DRIZZLE_TYPE_TIMESTAMP:
 
1112
    return new (root) Field_timestamp(ptr,field_length, null_pos, null_bit,
 
1113
                               unireg_check, field_name, share,
 
1114
                               field_charset);
 
1115
  case DRIZZLE_TYPE_DATE:
 
1116
    return new (root) Field_date(ptr,null_pos,null_bit,
 
1117
                             unireg_check, field_name, field_charset);
 
1118
  case DRIZZLE_TYPE_DATETIME:
 
1119
    return new (root) Field_datetime(ptr,null_pos,null_bit,
 
1120
                              unireg_check, field_name, field_charset);
 
1121
  case DRIZZLE_TYPE_NULL:
 
1122
    return new (root) Field_null(ptr, field_length, unireg_check, field_name,
 
1123
                          field_charset);
 
1124
  default:                                      // Impossible (Wrong version)
 
1125
    break;
 
1126
  }
 
1127
  return 0;
 
1128
}
 
1129
 
1180
1130
/*****************************************************************************
1181
1131
 Warning handling
1182
1132
*****************************************************************************/
1183
1133
 
1184
1134
bool Field::set_warning(DRIZZLE_ERROR::enum_warning_level level,
1185
 
                        drizzled::error_t code,
 
1135
                        uint32_t code,
1186
1136
                        int cuted_increment)
1187
1137
{
1188
1138
  /*
1202
1152
 
1203
1153
 
1204
1154
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1205
 
                                 drizzled::error_t code,
 
1155
                                 unsigned int code,
1206
1156
                                 const char *str, 
1207
1157
                                 uint32_t str_length,
1208
 
                                 type::timestamp_t ts_type, 
 
1158
                                 enum enum_drizzle_timestamp_type ts_type, 
1209
1159
                                 int cuted_increment)
1210
1160
{
1211
 
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
1212
 
 
1213
 
  if ((session->abortOnWarning() and
 
1161
  Session *session= table ? table->in_use : current_session;
 
1162
  if ((session->really_abort_on_warning() &&
1214
1163
       level >= DRIZZLE_ERROR::WARN_LEVEL_WARN) ||
1215
1164
      set_warning(level, code, cuted_increment))
1216
1165
    make_truncated_value_warning(session, level, str, str_length, ts_type,
1218
1167
}
1219
1168
 
1220
1169
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, 
1221
 
                                 drizzled::error_t code,
 
1170
                                 uint32_t code,
1222
1171
                                 int64_t nr, 
1223
 
                                 type::timestamp_t ts_type,
 
1172
                                 enum enum_drizzle_timestamp_type ts_type,
1224
1173
                                 int cuted_increment)
1225
1174
{
1226
 
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
1227
 
 
1228
 
  if (session->abortOnWarning() or
 
1175
  Session *session= table ? table->in_use : current_session;
 
1176
  if (session->really_abort_on_warning() ||
1229
1177
      set_warning(level, code, cuted_increment))
1230
1178
  {
1231
 
    char str_nr[DECIMAL_LONGLONG_DIGITS];
1232
 
    char *str_end= internal::int64_t10_to_str(nr, str_nr, -10);
 
1179
    char str_nr[22];
 
1180
    char *str_end= int64_t10_to_str(nr, str_nr, -10);
1233
1181
    make_truncated_value_warning(session, level, str_nr, (uint32_t) (str_end - str_nr),
1234
1182
                                 ts_type, field_name);
1235
1183
  }
1236
1184
}
1237
1185
 
1238
1186
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1239
 
                                 const drizzled::error_t code,
 
1187
                                 const uint32_t code,
1240
1188
                                 double nr, 
1241
 
                                 type::timestamp_t ts_type)
 
1189
                                 enum enum_drizzle_timestamp_type ts_type)
1242
1190
{
1243
 
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
1244
 
 
1245
 
  if (session->abortOnWarning() or
 
1191
  Session *session= table ? table->in_use : current_session;
 
1192
  if (session->really_abort_on_warning() ||
1246
1193
      set_warning(level, code, 1))
1247
1194
  {
1248
1195
    /* DBL_DIG is enough to print '-[digits].E+###' */
1249
1196
    char str_nr[DBL_DIG + 8];
1250
 
    uint32_t str_len= snprintf(str_nr, sizeof(str_nr), "%g", nr);
 
1197
    uint32_t str_len= sprintf(str_nr, "%g", nr);
1251
1198
    make_truncated_value_warning(session, level, str_nr, str_len, ts_type,
1252
1199
                                 field_name);
1253
1200
  }
1254
1201
}
1255
1202
 
1256
 
bool Field::isReadSet() const 
 
1203
bool Field::isReadSet() 
1257
1204
{ 
1258
1205
  return table->isReadSet(field_index); 
1259
1206
}
1268
1215
  if (arg)
1269
1216
    table->setReadSet(field_index);
1270
1217
  else
1271
 
    table->clearReadSet(field_index);
 
1218
    assert(0); // Not completed
1272
1219
}
1273
1220
 
1274
1221
void Field::setWriteSet(bool arg)
1276
1223
  if (arg)
1277
1224
    table->setWriteSet(field_index);
1278
1225
  else
1279
 
    table->clearWriteSet(field_index);
1280
 
}
1281
 
 
1282
 
void Field::pack_num(uint64_t arg, unsigned char *destination)
1283
 
{
1284
 
  if (not destination)
1285
 
    destination= ptr;
1286
 
 
1287
 
  int64_tstore(destination, arg);
1288
 
}
1289
 
 
1290
 
void Field::pack_num(uint32_t arg, unsigned char *destination)
1291
 
{
1292
 
  if (not destination)
1293
 
    destination= ptr;
1294
 
 
1295
 
  longstore(destination, arg);
1296
 
}
1297
 
 
1298
 
uint64_t Field::unpack_num(uint64_t &destination, const unsigned char *arg) const
1299
 
{
1300
 
  if (not arg)
1301
 
    arg= ptr;
1302
 
 
1303
 
  int64_tget(destination, arg);
1304
 
 
1305
 
  return destination;
1306
 
}
1307
 
 
1308
 
uint32_t Field::unpack_num(uint32_t &destination, const unsigned char *arg) const
1309
 
{
1310
 
  if (not arg)
1311
 
    arg= ptr;
1312
 
 
1313
 
  longget(destination, arg);
1314
 
 
1315
 
  return destination;
1316
 
}
1317
 
 
1318
 
std::ostream& operator<<(std::ostream& output, const Field &field)
1319
 
{
1320
 
  output << "Field:(";
1321
 
  output <<  field.field_name;
1322
 
  output << ", ";
1323
 
  output << drizzled::display::type(field.real_type());
1324
 
  output << ", { ";
1325
 
 
1326
 
  if (field.flags & NOT_NULL_FLAG)
1327
 
    output << " NOT_NULL";
1328
 
 
1329
 
  if (field.flags & PRI_KEY_FLAG)
1330
 
    output << ", PRIMARY KEY";
1331
 
 
1332
 
  if (field.flags & UNIQUE_KEY_FLAG)
1333
 
    output << ", UNIQUE KEY";
1334
 
 
1335
 
  if (field.flags & MULTIPLE_KEY_FLAG)
1336
 
    output << ", MULTIPLE KEY";
1337
 
 
1338
 
  if (field.flags & BLOB_FLAG)
1339
 
    output << ", BLOB";
1340
 
 
1341
 
  if (field.flags & UNSIGNED_FLAG)
1342
 
    output << ", UNSIGNED";
1343
 
 
1344
 
  if (field.flags & BINARY_FLAG)
1345
 
    output << ", BINARY";
1346
 
  output << "}, ";
1347
 
  output << ")";
1348
 
 
1349
 
  return output;  // for multiple << operators.
1350
 
}
1351
 
 
1352
 
} /* namespace drizzled */
 
1226
    assert(0); // Not completed
 
1227
}