← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.cc

Moved the last of the libdrizzleclient calls into Protocol.

Show diffs side-by-side

added added

removed removed

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