← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.cc

  • Committer: Stewart Smith
  • Date: 2009-06-16 06:55:11 UTC
  • mto: This revision was merged to the branch mainline in revision 1094.
  • Revision ID: stewart@flamingspork.com-20090616065511-ps3ewfxj7918lwy3
rollback.test for MyISAM temp only.
- rename to myisam_rollback to reflect what it's testing
- just use create temporary table

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field.cc
22
22
 * @file This file implements the Field class and API
23
23
 */
24
24
 
25
 
#include "config.h"
26
 
#include <cstdio>
 
25
#include "drizzled/server_includes.h"
27
26
#include <errno.h>
28
 
#include <float.h>
29
27
#include "drizzled/sql_select.h"
30
28
#include "drizzled/error.h"
31
29
#include "drizzled/field/str.h"
37
35
#include "drizzled/field/decimal.h"
38
36
#include "drizzled/field/real.h"
39
37
#include "drizzled/field/double.h"
40
 
#include "drizzled/field/int32.h"
41
 
#include "drizzled/field/int64.h"
 
38
#include "drizzled/field/long.h"
 
39
#include "drizzled/field/int64_t.h"
42
40
#include "drizzled/field/num.h"
43
41
#include "drizzled/field/timestamp.h"
44
42
#include "drizzled/field/datetime.h"
45
43
#include "drizzled/field/varstring.h"
46
 
#include "drizzled/field/uuid.h"
47
 
#include "drizzled/time_functions.h"
48
 
#include "drizzled/internal/m_string.h"
49
 
 
50
 
#include "drizzled/display.h"
51
 
 
52
 
namespace drizzled
53
 
{
54
44
 
55
45
/*****************************************************************************
56
46
  Instansiate templates and static variables
57
47
*****************************************************************************/
58
48
 
 
49
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
 
50
template class List<CreateField>;
 
51
template class List_iterator<CreateField>;
 
52
#endif
 
53
 
59
54
static enum_field_types
60
 
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]=
61
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
  },
62
84
  /* DRIZZLE_TYPE_LONG -> */
63
85
  {
 
86
    //DRIZZLE_TYPE_TINY
 
87
    DRIZZLE_TYPE_LONG,
64
88
    //DRIZZLE_TYPE_LONG
65
89
    DRIZZLE_TYPE_LONG,
66
90
    //DRIZZLE_TYPE_DOUBLE
77
101
    DRIZZLE_TYPE_VARCHAR,
78
102
    //DRIZZLE_TYPE_VARCHAR
79
103
    DRIZZLE_TYPE_VARCHAR,
80
 
    //DRIZZLE_TYPE_DECIMAL
81
 
    DRIZZLE_TYPE_DECIMAL,
 
104
    //DRIZZLE_TYPE_NEWDECIMAL
 
105
    DRIZZLE_TYPE_NEWDECIMAL,
82
106
    //DRIZZLE_TYPE_ENUM
83
107
    DRIZZLE_TYPE_VARCHAR,
84
108
    //DRIZZLE_TYPE_BLOB
85
109
    DRIZZLE_TYPE_BLOB,
86
 
    //DRIZZLE_TYPE_UUID
87
 
    DRIZZLE_TYPE_VARCHAR,
88
110
  },
89
111
  /* DRIZZLE_TYPE_DOUBLE -> */
90
112
  {
 
113
    //DRIZZLE_TYPE_TINY
 
114
    DRIZZLE_TYPE_DOUBLE,
91
115
    //DRIZZLE_TYPE_LONG
92
116
    DRIZZLE_TYPE_DOUBLE,
93
117
    //DRIZZLE_TYPE_DOUBLE
104
128
    DRIZZLE_TYPE_VARCHAR,
105
129
    //DRIZZLE_TYPE_VARCHAR
106
130
    DRIZZLE_TYPE_VARCHAR,
107
 
    //DRIZZLE_TYPE_DECIMAL
 
131
    //DRIZZLE_TYPE_NEWDECIMAL
108
132
    DRIZZLE_TYPE_DOUBLE,
109
133
    //DRIZZLE_TYPE_ENUM
110
134
    DRIZZLE_TYPE_VARCHAR,
111
135
    //DRIZZLE_TYPE_BLOB
112
136
    DRIZZLE_TYPE_BLOB,
113
 
    //DRIZZLE_TYPE_UUID
114
 
    DRIZZLE_TYPE_VARCHAR,
115
137
  },
116
138
  /* DRIZZLE_TYPE_NULL -> */
117
139
  {
 
140
    //DRIZZLE_TYPE_TINY
 
141
    DRIZZLE_TYPE_TINY,
118
142
    //DRIZZLE_TYPE_LONG
119
143
    DRIZZLE_TYPE_LONG,
120
144
    //DRIZZLE_TYPE_DOUBLE
131
155
    DRIZZLE_TYPE_DATE,
132
156
    //DRIZZLE_TYPE_VARCHAR
133
157
    DRIZZLE_TYPE_VARCHAR,
134
 
    //DRIZZLE_TYPE_DECIMAL
135
 
    DRIZZLE_TYPE_DECIMAL,
 
158
    //DRIZZLE_TYPE_NEWDECIMAL
 
159
    DRIZZLE_TYPE_NEWDECIMAL,
136
160
    //DRIZZLE_TYPE_ENUM
137
161
    DRIZZLE_TYPE_ENUM,
138
162
    //DRIZZLE_TYPE_BLOB
139
163
    DRIZZLE_TYPE_BLOB,
140
 
    //DRIZZLE_TYPE_UUID
141
 
    DRIZZLE_TYPE_UUID,
142
164
  },
143
165
  /* DRIZZLE_TYPE_TIMESTAMP -> */
144
166
  {
 
167
    //DRIZZLE_TYPE_TINY
 
168
    DRIZZLE_TYPE_VARCHAR,
145
169
    //DRIZZLE_TYPE_LONG
146
170
    DRIZZLE_TYPE_VARCHAR,
147
171
    //DRIZZLE_TYPE_DOUBLE
158
182
    DRIZZLE_TYPE_DATE,
159
183
    //DRIZZLE_TYPE_VARCHAR
160
184
    DRIZZLE_TYPE_VARCHAR,
161
 
    //DRIZZLE_TYPE_DECIMAL
 
185
    //DRIZZLE_TYPE_NEWDECIMAL
162
186
    DRIZZLE_TYPE_VARCHAR,
163
187
    //DRIZZLE_TYPE_ENUM
164
188
    DRIZZLE_TYPE_VARCHAR,
165
189
    //DRIZZLE_TYPE_BLOB
166
190
    DRIZZLE_TYPE_BLOB,
167
 
    //DRIZZLE_TYPE_UUID
168
 
    DRIZZLE_TYPE_VARCHAR,
169
191
  },
170
192
  /* DRIZZLE_TYPE_LONGLONG -> */
171
193
  {
 
194
    //DRIZZLE_TYPE_TINY
 
195
    DRIZZLE_TYPE_LONGLONG,
172
196
    //DRIZZLE_TYPE_LONG
173
197
    DRIZZLE_TYPE_LONGLONG,
174
198
    //DRIZZLE_TYPE_DOUBLE
185
209
    DRIZZLE_TYPE_DATE,
186
210
    //DRIZZLE_TYPE_VARCHAR
187
211
    DRIZZLE_TYPE_VARCHAR,
188
 
    //DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_ENUM
189
 
    DRIZZLE_TYPE_DECIMAL,
 
212
    //DRIZZLE_TYPE_NEWDECIMAL DRIZZLE_TYPE_ENUM
 
213
    DRIZZLE_TYPE_NEWDECIMAL,
190
214
    DRIZZLE_TYPE_VARCHAR,
191
215
    //DRIZZLE_TYPE_BLOB
192
216
    DRIZZLE_TYPE_BLOB,
193
 
    //DRIZZLE_TYPE_UUID
194
 
    DRIZZLE_TYPE_VARCHAR,
195
217
  },
196
218
  /* DRIZZLE_TYPE_DATETIME -> */
197
219
  {
 
220
    //DRIZZLE_TYPE_TINY
 
221
    DRIZZLE_TYPE_VARCHAR,
198
222
    //DRIZZLE_TYPE_LONG
199
223
    DRIZZLE_TYPE_VARCHAR,
200
224
    //DRIZZLE_TYPE_DOUBLE
211
235
    DRIZZLE_TYPE_DATE,
212
236
    //DRIZZLE_TYPE_VARCHAR
213
237
    DRIZZLE_TYPE_VARCHAR,
214
 
    //DRIZZLE_TYPE_DECIMAL
 
238
    //DRIZZLE_TYPE_NEWDECIMAL
215
239
    DRIZZLE_TYPE_VARCHAR,
216
240
    //DRIZZLE_TYPE_ENUM
217
241
    DRIZZLE_TYPE_VARCHAR,
218
242
    //DRIZZLE_TYPE_BLOB
219
243
    DRIZZLE_TYPE_BLOB,
220
 
    //DRIZZLE_TYPE_UUID
221
 
    DRIZZLE_TYPE_VARCHAR,
222
244
  },
223
245
  /* DRIZZLE_TYPE_DATE -> */
224
246
  {
 
247
    //DRIZZLE_TYPE_TINY
 
248
    DRIZZLE_TYPE_VARCHAR,
225
249
    //DRIZZLE_TYPE_LONG
226
250
    DRIZZLE_TYPE_VARCHAR,
227
251
    //DRIZZLE_TYPE_DOUBLE
238
262
    DRIZZLE_TYPE_DATE,
239
263
    //DRIZZLE_TYPE_VARCHAR
240
264
    DRIZZLE_TYPE_VARCHAR,
241
 
    //DRIZZLE_TYPE_DECIMAL
 
265
    //DRIZZLE_TYPE_NEWDECIMAL
242
266
    DRIZZLE_TYPE_VARCHAR,
243
267
    //DRIZZLE_TYPE_ENUM
244
268
    DRIZZLE_TYPE_VARCHAR,
245
269
    //DRIZZLE_TYPE_BLOB
246
270
    DRIZZLE_TYPE_BLOB,
247
 
    //DRIZZLE_TYPE_UUID
248
 
    DRIZZLE_TYPE_VARCHAR,
249
271
  },
250
272
  /* DRIZZLE_TYPE_VARCHAR -> */
251
273
  {
 
274
    //DRIZZLE_TYPE_TINY
 
275
    DRIZZLE_TYPE_VARCHAR,
252
276
    //DRIZZLE_TYPE_LONG
253
277
    DRIZZLE_TYPE_VARCHAR,
254
278
    //DRIZZLE_TYPE_DOUBLE
265
289
    DRIZZLE_TYPE_VARCHAR,
266
290
    //DRIZZLE_TYPE_VARCHAR
267
291
    DRIZZLE_TYPE_VARCHAR,
268
 
    //DRIZZLE_TYPE_DECIMAL
 
292
    //DRIZZLE_TYPE_NEWDECIMAL
269
293
    DRIZZLE_TYPE_VARCHAR,
270
294
    //DRIZZLE_TYPE_ENUM
271
295
    DRIZZLE_TYPE_VARCHAR,
272
296
    //DRIZZLE_TYPE_BLOB
273
297
    DRIZZLE_TYPE_BLOB,
274
 
    //DRIZZLE_TYPE_UUID
275
 
    DRIZZLE_TYPE_VARCHAR,
276
298
  },
277
 
  /* DRIZZLE_TYPE_DECIMAL -> */
 
299
  /* DRIZZLE_TYPE_NEWDECIMAL -> */
278
300
  {
 
301
    //DRIZZLE_TYPE_TINY
 
302
    DRIZZLE_TYPE_NEWDECIMAL,
279
303
    //DRIZZLE_TYPE_LONG
280
 
    DRIZZLE_TYPE_DECIMAL,
 
304
    DRIZZLE_TYPE_NEWDECIMAL,
281
305
    //DRIZZLE_TYPE_DOUBLE
282
306
    DRIZZLE_TYPE_DOUBLE,
283
307
    //DRIZZLE_TYPE_NULL
284
 
    DRIZZLE_TYPE_DECIMAL,
 
308
    DRIZZLE_TYPE_NEWDECIMAL,
285
309
    //DRIZZLE_TYPE_TIMESTAMP
286
310
    DRIZZLE_TYPE_VARCHAR,
287
311
    //DRIZZLE_TYPE_LONGLONG
288
 
    DRIZZLE_TYPE_DECIMAL,
 
312
    DRIZZLE_TYPE_NEWDECIMAL,
289
313
    //DRIZZLE_TYPE_DATETIME
290
314
    DRIZZLE_TYPE_VARCHAR,
291
315
    //DRIZZLE_TYPE_DATE
292
316
    DRIZZLE_TYPE_VARCHAR,
293
317
    //DRIZZLE_TYPE_VARCHAR
294
318
    DRIZZLE_TYPE_VARCHAR,
295
 
    //DRIZZLE_TYPE_DECIMAL
296
 
    DRIZZLE_TYPE_DECIMAL,
 
319
    //DRIZZLE_TYPE_NEWDECIMAL
 
320
    DRIZZLE_TYPE_NEWDECIMAL,
297
321
    //DRIZZLE_TYPE_ENUM
298
322
    DRIZZLE_TYPE_VARCHAR,
299
323
    //DRIZZLE_TYPE_BLOB
300
324
    DRIZZLE_TYPE_BLOB,
301
 
    //DRIZZLE_TYPE_UUID
302
 
    DRIZZLE_TYPE_VARCHAR,
303
325
  },
304
326
  /* DRIZZLE_TYPE_ENUM -> */
305
327
  {
 
328
    //DRIZZLE_TYPE_TINY
 
329
    DRIZZLE_TYPE_VARCHAR,
306
330
    //DRIZZLE_TYPE_LONG
307
331
    DRIZZLE_TYPE_VARCHAR,
308
332
    //DRIZZLE_TYPE_DOUBLE
319
343
    DRIZZLE_TYPE_VARCHAR,
320
344
    //DRIZZLE_TYPE_VARCHAR
321
345
    DRIZZLE_TYPE_VARCHAR,
322
 
    //DRIZZLE_TYPE_DECIMAL
 
346
    //DRIZZLE_TYPE_NEWDECIMAL
323
347
    DRIZZLE_TYPE_VARCHAR,
324
348
    //DRIZZLE_TYPE_ENUM
325
349
    DRIZZLE_TYPE_VARCHAR,
326
350
    //DRIZZLE_TYPE_BLOB
327
351
    DRIZZLE_TYPE_BLOB,
328
 
    //DRIZZLE_TYPE_UUID
329
 
    DRIZZLE_TYPE_VARCHAR,
330
 
   },
 
352
  },
331
353
  /* DRIZZLE_TYPE_BLOB -> */
332
354
  {
 
355
    //DRIZZLE_TYPE_TINY
 
356
    DRIZZLE_TYPE_BLOB,
333
357
    //DRIZZLE_TYPE_LONG
334
358
    DRIZZLE_TYPE_BLOB,
335
359
    //DRIZZLE_TYPE_DOUBLE
346
370
    DRIZZLE_TYPE_BLOB,
347
371
    //DRIZZLE_TYPE_VARCHAR
348
372
    DRIZZLE_TYPE_BLOB,
349
 
    //DRIZZLE_TYPE_DECIMAL
 
373
    //DRIZZLE_TYPE_NEWDECIMAL
350
374
    DRIZZLE_TYPE_BLOB,
351
375
    //DRIZZLE_TYPE_ENUM
352
376
    DRIZZLE_TYPE_BLOB,
353
377
    //DRIZZLE_TYPE_BLOB
354
378
    DRIZZLE_TYPE_BLOB,
355
 
    //DRIZZLE_TYPE_UUID
356
 
    DRIZZLE_TYPE_VARCHAR,
357
 
  },
358
 
  /* DRIZZLE_TYPE_UUID -> */
359
 
  {
360
 
    //DRIZZLE_TYPE_LONG
361
 
    DRIZZLE_TYPE_VARCHAR,
362
 
    //DRIZZLE_TYPE_DOUBLE
363
 
    DRIZZLE_TYPE_VARCHAR,
364
 
    //DRIZZLE_TYPE_NULL
365
 
    DRIZZLE_TYPE_UUID,
366
 
    //DRIZZLE_TYPE_TIMESTAMP
367
 
    DRIZZLE_TYPE_VARCHAR,
368
 
    //DRIZZLE_TYPE_LONGLONG
369
 
    DRIZZLE_TYPE_VARCHAR,
370
 
    //DRIZZLE_TYPE_DATETIME
371
 
    DRIZZLE_TYPE_VARCHAR,
372
 
    //DRIZZLE_TYPE_DATE
373
 
    DRIZZLE_TYPE_VARCHAR,
374
 
    //DRIZZLE_TYPE_VARCHAR
375
 
    DRIZZLE_TYPE_VARCHAR,
376
 
    //DRIZZLE_TYPE_DECIMAL
377
 
    DRIZZLE_TYPE_VARCHAR,
378
 
    //DRIZZLE_TYPE_VARCHAR,
379
 
    DRIZZLE_TYPE_VARCHAR,
380
 
    //DRIZZLE_TYPE_BLOB
381
 
    DRIZZLE_TYPE_BLOB,
382
 
    //DRIZZLE_TYPE_UUID
383
 
    DRIZZLE_TYPE_UUID,
384
379
  },
385
380
};
386
381
 
387
 
static Item_result field_types_result_type [enum_field_types_size]=
 
382
static Item_result field_types_result_type [DRIZZLE_TYPE_MAX+1]=
388
383
{
 
384
  //DRIZZLE_TYPE_TINY
 
385
  INT_RESULT,
389
386
  //DRIZZLE_TYPE_LONG
390
387
  INT_RESULT,
391
388
  //DRIZZLE_TYPE_DOUBLE
402
399
  STRING_RESULT,
403
400
  //DRIZZLE_TYPE_VARCHAR
404
401
  STRING_RESULT,
405
 
  //DRIZZLE_TYPE_DECIMAL   
 
402
  //DRIZZLE_TYPE_NEWDECIMAL   
406
403
  DECIMAL_RESULT,           
407
404
  //DRIZZLE_TYPE_ENUM
408
405
  STRING_RESULT,
409
406
  //DRIZZLE_TYPE_BLOB
410
407
  STRING_RESULT,
411
 
  //DRIZZLE_TYPE_UUID
412
 
  STRING_RESULT,
413
408
};
414
409
 
415
410
bool test_if_important_data(const CHARSET_INFO * const cs, 
421
416
  return (str < strend);
422
417
}
423
418
 
424
 
void *Field::operator new(size_t size)
425
 
{
426
 
  return memory::sql_alloc(size);
427
 
}
428
 
 
429
 
void *Field::operator new(size_t size, memory::Root *mem_root)
430
 
{
431
 
  return mem_root->alloc_root(static_cast<uint32_t>(size));
432
 
}
433
 
 
434
419
enum_field_types Field::field_type_merge(enum_field_types a,
435
420
                                         enum_field_types b)
436
421
{
437
 
  assert(a < enum_field_types_size);
438
 
  assert(b < enum_field_types_size);
 
422
  assert(a <= DRIZZLE_TYPE_MAX);
 
423
  assert(b <= DRIZZLE_TYPE_MAX);
439
424
  return field_types_merge_rules[a][b];
440
425
}
441
426
 
442
427
Item_result Field::result_merge_type(enum_field_types field_type)
443
428
{
444
 
  assert(field_type < enum_field_types_size);
 
429
  assert(field_type <= DRIZZLE_TYPE_MAX);
445
430
  return field_types_result_type[field_type];
446
431
}
447
432
 
461
446
  return pack_length();
462
447
}
463
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
 
464
464
uint32_t Field::data_length()
465
465
{
466
466
  return pack_length();
492
492
 
493
493
void Field::set_default()
494
494
{
495
 
  ptrdiff_t l_offset= (ptrdiff_t) (table->getDefaultValues() - table->getInsertRecord());
 
495
  ptrdiff_t l_offset= (ptrdiff_t) (table->getDefaultValues() - table->record[0]);
496
496
  memcpy(ptr, ptr + l_offset, pack_length());
497
497
  if (null_ptr)
498
498
    *null_ptr= ((*null_ptr & (unsigned char) ~null_bit) | (null_ptr[l_offset] & null_bit));
561
561
  return 0;
562
562
}
563
563
 
564
 
bool Field::is_null(ptrdiff_t row_offset)
 
564
bool Field::is_null(my_ptrdiff_t row_offset)
565
565
{
566
566
  return null_ptr ?
567
567
    (null_ptr[row_offset] & null_bit ? true : false) :
568
568
    table->null_row;
569
569
}
570
570
 
571
 
bool Field::is_real_null(ptrdiff_t row_offset)
 
571
bool Field::is_real_null(my_ptrdiff_t row_offset)
572
572
{
573
573
  return null_ptr ? (null_ptr[row_offset] & null_bit ? true : false) : false;
574
574
}
577
577
{
578
578
  if (! null_ptr)
579
579
    return false;
580
 
  return test(record[(uint32_t) (null_ptr -table->getInsertRecord())] & null_bit);
 
580
  return test(record[(uint32_t) (null_ptr -table->record[0])] & null_bit);
581
581
}
582
582
 
583
 
bool Field::is_null_in_record_with_offset(ptrdiff_t with_offset)
 
583
bool Field::is_null_in_record_with_offset(my_ptrdiff_t with_offset)
584
584
{
585
585
  if (! null_ptr)
586
586
    return false;
587
587
  return test(null_ptr[with_offset] & null_bit);
588
588
}
589
589
 
590
 
void Field::set_null(ptrdiff_t row_offset)
 
590
void Field::set_null(my_ptrdiff_t row_offset)
591
591
{
592
592
  if (null_ptr)
593
593
    null_ptr[row_offset]|= null_bit;
594
594
}
595
595
 
596
 
void Field::set_notnull(ptrdiff_t row_offset)
 
596
void Field::set_notnull(my_ptrdiff_t row_offset)
597
597
{
598
598
  if (null_ptr)
599
599
    null_ptr[row_offset]&= (unsigned char) ~null_bit;
638
638
void Field::init(Table *table_arg)
639
639
{
640
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;
641
658
}
642
659
 
643
660
/// This is used as a table name when the table structure is not set up
652
669
    null_ptr(null_ptr_arg),
653
670
    table(NULL),
654
671
    orig_table(NULL),
 
672
    table_name(NULL),
655
673
    field_name(field_name_arg),
656
674
    key_start(0),
657
675
    part_of_key(0),
694
712
  }
695
713
}
696
714
 
697
 
int Field::store_and_check(enum_check_fields check_level,
698
 
                           const char *to, 
699
 
                           uint32_t length,
700
 
                           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
}
701
721
 
 
722
int Field::store(const char *to, 
 
723
                 uint32_t length,
 
724
                 const CHARSET_INFO * const cs,
 
725
                 enum_check_fields check_level)
702
726
{
703
727
  int res;
704
728
  enum_check_fields old_check_level= table->in_use->count_cuted_fields;
718
742
 
719
743
unsigned char *Field::pack(unsigned char *to, const unsigned char *from)
720
744
{
721
 
  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);
722
746
  return(result);
723
747
}
724
748
 
756
780
 
757
781
const unsigned char *Field::unpack(unsigned char* to, const unsigned char *from)
758
782
{
759
 
  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);
760
784
  return(result);
761
785
}
762
786
 
 
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
 
763
803
my_decimal *Field::val_decimal(my_decimal *)
764
804
{
765
805
  /* This never have to be called */
770
810
 
771
811
void Field::make_field(SendField *field)
772
812
{
773
 
  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)
774
814
  {
775
 
    field->db_name= orig_table->getShare()->getSchemaName();
776
 
    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;
777
817
  }
778
818
  else
779
819
    field->org_table_name= field->db_name= "";
780
820
  if (orig_table)
781
821
  {
782
 
    field->table_name= orig_table->getAlias();
 
822
    field->table_name= orig_table->alias;
783
823
    field->org_col_name= field_name;
784
824
  }
785
825
  else
808
848
  return i;
809
849
}
810
850
 
811
 
uint32_t Field::fill_cache_field(CacheField *copy)
 
851
uint32_t Field::fill_cache_field(CACHE_FIELD *copy)
812
852
{
813
853
  uint32_t store_length;
814
854
  copy->str=ptr;
818
858
  {
819
859
    copy->blob_field=(Field_blob*) this;
820
860
    copy->strip=0;
821
 
    copy->length-= table->getShare()->blob_ptr_size;
 
861
    copy->length-= table->s->blob_ptr_size;
822
862
    return copy->length;
823
863
  }
824
864
  else
833
873
{
834
874
  char buff[40];
835
875
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
836
 
  if (!(res=val_str_internal(&tmp)) || str_to_datetime_with_warn(res->ptr(), res->length(),
837
 
                                                                 ltime, fuzzydate) <= DRIZZLE_TIMESTAMP_ERROR)
838
 
  {
 
876
  if (!(res=val_str(&tmp)) ||
 
877
      str_to_datetime_with_warn(res->ptr(), res->length(),
 
878
                                ltime, fuzzydate) <= DRIZZLE_TIMESTAMP_ERROR)
839
879
    return 1;
840
 
  }
841
 
 
842
880
  return 0;
843
881
}
844
882
 
846
884
{
847
885
  char buff[40];
848
886
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
849
 
 
850
 
  if (!(res=val_str_internal(&tmp)) || str_to_time_with_warn(res->ptr(), res->length(), ltime))
851
 
  {
 
887
  if (!(res=val_str(&tmp)) ||
 
888
      str_to_time_with_warn(res->ptr(), res->length(), ltime))
852
889
    return 1;
853
 
  }
854
 
 
855
890
  return 0;
856
891
}
857
892
 
862
897
  return store(buff, length, &my_charset_bin);
863
898
}
864
899
 
865
 
bool Field::optimize_range(uint32_t idx, uint32_t)
 
900
bool Field::optimize_range(uint32_t idx, uint32_t part)
866
901
{
867
 
  return test(table->index_flags(idx) & HA_READ_RANGE);
 
902
  return test(table->file->index_flags(idx, part, 1) & HA_READ_RANGE);
868
903
}
869
904
 
870
 
Field *Field::new_field(memory::Root *root, Table *new_table, bool)
 
905
Field *Field::new_field(MEM_ROOT *root, Table *new_table, bool)
871
906
{
872
907
  Field *tmp;
873
 
  if (!(tmp= (Field*) root->memdup_root((char*) this,size_of())))
 
908
  if (!(tmp= (Field*) memdup_root(root,(char*) this,size_of())))
874
909
    return 0;
875
910
 
876
911
  if (tmp->table->maybe_null)
880
915
  tmp->part_of_key.reset();
881
916
  tmp->part_of_sortkey.reset();
882
917
  tmp->unireg_check= Field::NONE;
883
 
  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);
884
919
  tmp->reset_fields();
885
920
  return tmp;
886
921
}
887
922
 
888
 
Field *Field::new_key_field(memory::Root *root, Table *new_table,
 
923
Field *Field::new_key_field(MEM_ROOT *root, Table *new_table,
889
924
                            unsigned char *new_ptr,
890
925
                            unsigned char *new_null_ptr,
891
926
                            uint32_t new_null_bit)
900
935
  return tmp;
901
936
}
902
937
 
903
 
Field *Field::clone(memory::Root *root, Table *new_table)
 
938
Field *Field::clone(MEM_ROOT *root, Table *new_table)
904
939
{
905
940
  Field *tmp;
906
 
  if ((tmp= (Field*) root->memdup_root((char*) this,size_of())))
 
941
  if ((tmp= (Field*) memdup_root(root,(char*) this,size_of())))
907
942
  {
908
943
    tmp->init(new_table);
909
 
    tmp->move_field_offset((ptrdiff_t) (new_table->getInsertRecord() -
910
 
                                           new_table->getDefaultValues()));
 
944
    tmp->move_field_offset((my_ptrdiff_t) (new_table->record[0] -
 
945
                                           new_table->s->default_values));
911
946
  }
912
947
  return tmp;
913
948
}
944
979
  return 1;
945
980
}
946
981
 
 
982
/*
 
983
  Make a field from the .frm file info
 
984
*/
947
985
uint32_t calc_pack_length(enum_field_types type,uint32_t length)
948
986
{
949
987
  switch (type) {
950
988
  case DRIZZLE_TYPE_VARCHAR: return (length + (length < 256 ? 1: 2));
951
 
  case DRIZZLE_TYPE_UUID: return field::Uuid::max_string_length();
952
 
  case DRIZZLE_TYPE_DATE:
953
 
  case DRIZZLE_TYPE_ENUM:
 
989
  case DRIZZLE_TYPE_TINY: return 1;
 
990
  case DRIZZLE_TYPE_DATE: return 3;
 
991
  case DRIZZLE_TYPE_TIMESTAMP:
954
992
  case DRIZZLE_TYPE_LONG: return 4;
955
993
  case DRIZZLE_TYPE_DOUBLE: return sizeof(double);
956
994
  case DRIZZLE_TYPE_DATETIME:
957
 
  case DRIZZLE_TYPE_TIMESTAMP:
958
995
  case DRIZZLE_TYPE_LONGLONG: return 8; /* Don't crash if no int64_t */
959
996
  case DRIZZLE_TYPE_NULL: return 0;
960
997
  case DRIZZLE_TYPE_BLOB: return 4 + portable_sizeof_char_ptr;
961
 
  case DRIZZLE_TYPE_DECIMAL:
962
 
                          assert(0);
963
 
                          abort();
 
998
  case DRIZZLE_TYPE_ENUM:
 
999
  case DRIZZLE_TYPE_NEWDECIMAL:
 
1000
    abort();
 
1001
  default:
 
1002
    return 0;
964
1003
  }
965
 
 
966
 
  assert(0);
967
 
  abort();
968
1004
}
969
1005
 
970
1006
uint32_t pack_length_to_packflag(uint32_t type)
973
1009
    case 1: return 1 << FIELDFLAG_PACK_SHIFT;
974
1010
    case 2: assert(1);
975
1011
    case 3: assert(1);
976
 
    case 4: return f_settype(DRIZZLE_TYPE_LONG);
977
 
    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);
978
1014
  }
979
1015
  return 0;                                     // This shouldn't happen
980
1016
}
981
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
 
982
1130
/*****************************************************************************
983
1131
 Warning handling
984
1132
*****************************************************************************/
1029
1177
      set_warning(level, code, cuted_increment))
1030
1178
  {
1031
1179
    char str_nr[22];
1032
 
    char *str_end= internal::int64_t10_to_str(nr, str_nr, -10);
 
1180
    char *str_end= int64_t10_to_str(nr, str_nr, -10);
1033
1181
    make_truncated_value_warning(session, level, str_nr, (uint32_t) (str_end - str_nr),
1034
1182
                                 ts_type, field_name);
1035
1183
  }
1046
1194
  {
1047
1195
    /* DBL_DIG is enough to print '-[digits].E+###' */
1048
1196
    char str_nr[DBL_DIG + 8];
1049
 
    uint32_t str_len= snprintf(str_nr, sizeof(str_nr), "%g", nr);
 
1197
    uint32_t str_len= sprintf(str_nr, "%g", nr);
1050
1198
    make_truncated_value_warning(session, level, str_nr, str_len, ts_type,
1051
1199
                                 field_name);
1052
1200
  }
1061
1209
{ 
1062
1210
  return table->isWriteSet(field_index); 
1063
1211
}
1064
 
 
1065
 
void Field::setReadSet(bool arg)
1066
 
{
1067
 
  if (arg)
1068
 
    table->setReadSet(field_index);
1069
 
  else
1070
 
    table->clearReadSet(field_index);
1071
 
}
1072
 
 
1073
 
void Field::setWriteSet(bool arg)
1074
 
{
1075
 
  if (arg)
1076
 
    table->setWriteSet(field_index);
1077
 
  else
1078
 
    table->clearWriteSet(field_index);
1079
 
}
1080
 
 
1081
 
std::ostream& operator<<(std::ostream& output, const Field &field)
1082
 
{
1083
 
  output << "Field:(";
1084
 
  output <<  field.field_name;
1085
 
  output << ", ";
1086
 
  output << drizzled::display::type(field.real_type());
1087
 
  output << ")";
1088
 
 
1089
 
  return output;  // for multiple << operators.
1090
 
}
1091
 
 
1092
 
} /* namespace drizzled */