← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.cc

  • Committer: Lee Bieber
  • Date: 2010-11-07 19:34:48 UTC
  • mfrom: (1910.1.2 build)
  • Revision ID: kalebral@gmail.com-20101107193448-64kdu912qej354sh
Merge Stewart - including adapting and expanding the "differences from mysql" page from the wiki.
Merge Stewart - fix bug 668143: drizzleslap with --commit runs second iteration data load in a transaction

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field.cc
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2010 Brian Aker
5
4
 *  Copyright (C) 2008 MySQL
6
5
 *
7
6
 *  This program is free software; you can redistribute it and/or modify
32
31
#include "drizzled/field/str.h"
33
32
#include "drizzled/field/num.h"
34
33
#include "drizzled/field/blob.h"
35
 
#include "drizzled/field/boolean.h"
36
34
#include "drizzled/field/enum.h"
37
35
#include "drizzled/field/null.h"
38
36
#include "drizzled/field/date.h"
39
37
#include "drizzled/field/decimal.h"
40
38
#include "drizzled/field/real.h"
41
39
#include "drizzled/field/double.h"
42
 
#include "drizzled/field/int32.h"
43
 
#include "drizzled/field/int64.h"
 
40
#include "drizzled/field/long.h"
 
41
#include "drizzled/field/int64_t.h"
44
42
#include "drizzled/field/num.h"
45
 
#include "drizzled/field/time.h"
46
 
#include "drizzled/field/epoch.h"
 
43
#include "drizzled/field/timestamp.h"
47
44
#include "drizzled/field/datetime.h"
48
 
#include "drizzled/field/microtime.h"
49
45
#include "drizzled/field/varstring.h"
50
 
#include "drizzled/field/uuid.h"
51
46
#include "drizzled/time_functions.h"
52
47
#include "drizzled/internal/m_string.h"
53
48
 
54
 
#include "drizzled/display.h"
55
 
 
56
49
namespace drizzled
57
50
{
58
51
 
61
54
*****************************************************************************/
62
55
 
63
56
static enum_field_types
64
 
field_types_merge_rules [enum_field_types_size][enum_field_types_size]=
 
57
field_types_merge_rules [DRIZZLE_TYPE_MAX+1][DRIZZLE_TYPE_MAX+1]=
65
58
{
66
59
  /* DRIZZLE_TYPE_LONG -> */
67
60
  {
87
80
    DRIZZLE_TYPE_VARCHAR,
88
81
    //DRIZZLE_TYPE_BLOB
89
82
    DRIZZLE_TYPE_BLOB,
90
 
    //DRIZZLE_TYPE_TIME
91
 
    DRIZZLE_TYPE_TIME,
92
 
    //DRIZZLE_TYPE_BOOLEAN
93
 
    DRIZZLE_TYPE_VARCHAR,
94
 
    //DRIZZLE_TYPE_UUID
95
 
    DRIZZLE_TYPE_VARCHAR,
96
 
    //DRIZZLE_TYPE_MICROTIME
97
 
    DRIZZLE_TYPE_VARCHAR,
98
83
  },
99
84
  /* DRIZZLE_TYPE_DOUBLE -> */
100
85
  {
120
105
    DRIZZLE_TYPE_VARCHAR,
121
106
    //DRIZZLE_TYPE_BLOB
122
107
    DRIZZLE_TYPE_BLOB,
123
 
    //DRIZZLE_TYPE_TIME
124
 
    DRIZZLE_TYPE_TIME,
125
 
    //DRIZZLE_TYPE_BOOLEAN
126
 
    DRIZZLE_TYPE_VARCHAR,
127
 
    //DRIZZLE_TYPE_UUID
128
 
    DRIZZLE_TYPE_VARCHAR,
129
 
    //DRIZZLE_TYPE_MICROTIME
130
 
    DRIZZLE_TYPE_VARCHAR,
131
108
  },
132
109
  /* DRIZZLE_TYPE_NULL -> */
133
110
  {
153
130
    DRIZZLE_TYPE_ENUM,
154
131
    //DRIZZLE_TYPE_BLOB
155
132
    DRIZZLE_TYPE_BLOB,
156
 
    //DRIZZLE_TYPE_TIME
157
 
    DRIZZLE_TYPE_TIME,
158
 
    //DRIZZLE_TYPE_BOOLEAN
159
 
    DRIZZLE_TYPE_BOOLEAN,
160
 
    //DRIZZLE_TYPE_UUID
161
 
    DRIZZLE_TYPE_UUID,
162
 
    //DRIZZLE_TYPE_MICROTIME
163
 
    DRIZZLE_TYPE_MICROTIME,
164
133
  },
165
134
  /* DRIZZLE_TYPE_TIMESTAMP -> */
166
135
  {
186
155
    DRIZZLE_TYPE_VARCHAR,
187
156
    //DRIZZLE_TYPE_BLOB
188
157
    DRIZZLE_TYPE_BLOB,
189
 
    //DRIZZLE_TYPE_TIME
190
 
    DRIZZLE_TYPE_TIME,
191
 
    //DRIZZLE_TYPE_BOOLEAN
192
 
    DRIZZLE_TYPE_VARCHAR,
193
 
    //DRIZZLE_TYPE_UUID
194
 
    DRIZZLE_TYPE_VARCHAR,
195
 
    //DRIZZLE_TYPE_MICROTIME
196
 
    DRIZZLE_TYPE_VARCHAR,
197
158
  },
198
159
  /* DRIZZLE_TYPE_LONGLONG -> */
199
160
  {
218
179
    DRIZZLE_TYPE_VARCHAR,
219
180
    //DRIZZLE_TYPE_BLOB
220
181
    DRIZZLE_TYPE_BLOB,
221
 
    //DRIZZLE_TYPE_TIME
222
 
    DRIZZLE_TYPE_TIME,
223
 
    //DRIZZLE_TYPE_BOOLEAN
224
 
    DRIZZLE_TYPE_VARCHAR,
225
 
    //DRIZZLE_TYPE_UUID
226
 
    DRIZZLE_TYPE_VARCHAR,
227
 
    //DRIZZLE_TYPE_MICROTIME
228
 
    DRIZZLE_TYPE_VARCHAR,
229
182
  },
230
183
  /* DRIZZLE_TYPE_DATETIME -> */
231
184
  {
251
204
    DRIZZLE_TYPE_VARCHAR,
252
205
    //DRIZZLE_TYPE_BLOB
253
206
    DRIZZLE_TYPE_BLOB,
254
 
    //DRIZZLE_TYPE_TIME
255
 
    DRIZZLE_TYPE_TIME,
256
 
    //DRIZZLE_TYPE_BOOLEAN
257
 
    DRIZZLE_TYPE_VARCHAR,
258
 
    //DRIZZLE_TYPE_UUID
259
 
    DRIZZLE_TYPE_VARCHAR,
260
 
    //DRIZZLE_TYPE_MICROTIME
261
 
    DRIZZLE_TYPE_VARCHAR,
262
207
  },
263
208
  /* DRIZZLE_TYPE_DATE -> */
264
209
  {
284
229
    DRIZZLE_TYPE_VARCHAR,
285
230
    //DRIZZLE_TYPE_BLOB
286
231
    DRIZZLE_TYPE_BLOB,
287
 
    //DRIZZLE_TYPE_TIME
288
 
    DRIZZLE_TYPE_TIME,
289
 
    //DRIZZLE_TYPE_BOOLEAN
290
 
    DRIZZLE_TYPE_VARCHAR,
291
 
    //DRIZZLE_TYPE_UUID
292
 
    DRIZZLE_TYPE_VARCHAR,
293
 
    //DRIZZLE_TYPE_MICROTIME
294
 
    DRIZZLE_TYPE_VARCHAR,
295
232
  },
296
233
  /* DRIZZLE_TYPE_VARCHAR -> */
297
234
  {
317
254
    DRIZZLE_TYPE_VARCHAR,
318
255
    //DRIZZLE_TYPE_BLOB
319
256
    DRIZZLE_TYPE_BLOB,
320
 
    //DRIZZLE_TYPE_TIME
321
 
    DRIZZLE_TYPE_TIME,
322
 
    //DRIZZLE_TYPE_BOOLEAN
323
 
    DRIZZLE_TYPE_VARCHAR,
324
 
    //DRIZZLE_TYPE_UUID
325
 
    DRIZZLE_TYPE_VARCHAR,
326
 
    //DRIZZLE_TYPE_MICROTIME
327
 
    DRIZZLE_TYPE_VARCHAR,
328
257
  },
329
258
  /* DRIZZLE_TYPE_DECIMAL -> */
330
259
  {
350
279
    DRIZZLE_TYPE_VARCHAR,
351
280
    //DRIZZLE_TYPE_BLOB
352
281
    DRIZZLE_TYPE_BLOB,
353
 
    //DRIZZLE_TYPE_TIME
354
 
    DRIZZLE_TYPE_TIME,
355
 
    //DRIZZLE_TYPE_BOOLEAN
356
 
    DRIZZLE_TYPE_VARCHAR,
357
 
    //DRIZZLE_TYPE_UUID
358
 
    DRIZZLE_TYPE_VARCHAR,
359
 
    //DRIZZLE_TYPE_MICROTIME
360
 
    DRIZZLE_TYPE_VARCHAR,
361
282
  },
362
283
  /* DRIZZLE_TYPE_ENUM -> */
363
284
  {
383
304
    DRIZZLE_TYPE_VARCHAR,
384
305
    //DRIZZLE_TYPE_BLOB
385
306
    DRIZZLE_TYPE_BLOB,
386
 
    //DRIZZLE_TYPE_TIME
387
 
    DRIZZLE_TYPE_TIME,
388
 
    //DRIZZLE_TYPE_BOOLEAN
389
 
    DRIZZLE_TYPE_VARCHAR,
390
 
    //DRIZZLE_TYPE_UUID
391
 
    DRIZZLE_TYPE_VARCHAR,
392
 
    //DRIZZLE_TYPE_MICROTIME
393
 
    DRIZZLE_TYPE_VARCHAR,
394
 
   },
 
307
  },
395
308
  /* DRIZZLE_TYPE_BLOB -> */
396
309
  {
397
310
    //DRIZZLE_TYPE_LONG
416
329
    DRIZZLE_TYPE_BLOB,
417
330
    //DRIZZLE_TYPE_BLOB
418
331
    DRIZZLE_TYPE_BLOB,
419
 
    //DRIZZLE_TYPE_TIME
420
 
    DRIZZLE_TYPE_TIME,
421
 
    //DRIZZLE_TYPE_BOOLEAN
422
 
    DRIZZLE_TYPE_VARCHAR,
423
 
    //DRIZZLE_TYPE_UUID
424
 
    DRIZZLE_TYPE_VARCHAR,
425
 
    //DRIZZLE_TYPE_MICROTIME
426
 
    DRIZZLE_TYPE_VARCHAR,
427
 
  },
428
 
  /* DRIZZLE_TYPE_TIME -> */
429
 
  {
430
 
    //DRIZZLE_TYPE_LONG
431
 
    DRIZZLE_TYPE_VARCHAR,
432
 
    //DRIZZLE_TYPE_DOUBLE
433
 
    DRIZZLE_TYPE_VARCHAR,
434
 
    //DRIZZLE_TYPE_NULL
435
 
    DRIZZLE_TYPE_TIME,
436
 
    //DRIZZLE_TYPE_TIMESTAMP
437
 
    DRIZZLE_TYPE_VARCHAR,
438
 
    //DRIZZLE_TYPE_LONGLONG
439
 
    DRIZZLE_TYPE_VARCHAR,
440
 
    //DRIZZLE_TYPE_DATETIME
441
 
    DRIZZLE_TYPE_VARCHAR,
442
 
    //DRIZZLE_TYPE_DATE
443
 
    DRIZZLE_TYPE_VARCHAR,
444
 
    //DRIZZLE_TYPE_VARCHAR
445
 
    DRIZZLE_TYPE_VARCHAR,
446
 
    //DRIZZLE_TYPE_DECIMAL
447
 
    DRIZZLE_TYPE_VARCHAR,
448
 
    //DRIZZLE_TYPE_VARCHAR,
449
 
    DRIZZLE_TYPE_VARCHAR,
450
 
    //DRIZZLE_TYPE_BLOB
451
 
    DRIZZLE_TYPE_BLOB,
452
 
    //DRIZZLE_TYPE_TIME
453
 
    DRIZZLE_TYPE_TIME,
454
 
    //DRIZZLE_TYPE_BOOLEAN
455
 
    DRIZZLE_TYPE_VARCHAR,
456
 
    //DRIZZLE_TYPE_UUID
457
 
    DRIZZLE_TYPE_UUID,
458
 
    //DRIZZLE_TYPE_MICROTIME
459
 
    DRIZZLE_TYPE_VARCHAR,
460
 
  },
461
 
  /* DRIZZLE_TYPE_BOOLEAN -> */
462
 
  {
463
 
    //DRIZZLE_TYPE_LONG
464
 
    DRIZZLE_TYPE_VARCHAR,
465
 
    //DRIZZLE_TYPE_DOUBLE
466
 
    DRIZZLE_TYPE_VARCHAR,
467
 
    //DRIZZLE_TYPE_NULL
468
 
    DRIZZLE_TYPE_BOOLEAN,
469
 
    //DRIZZLE_TYPE_TIMESTAMP
470
 
    DRIZZLE_TYPE_VARCHAR,
471
 
    //DRIZZLE_TYPE_LONGLONG
472
 
    DRIZZLE_TYPE_VARCHAR,
473
 
    //DRIZZLE_TYPE_DATETIME
474
 
    DRIZZLE_TYPE_VARCHAR,
475
 
    //DRIZZLE_TYPE_DATE
476
 
    DRIZZLE_TYPE_VARCHAR,
477
 
    //DRIZZLE_TYPE_VARCHAR
478
 
    DRIZZLE_TYPE_VARCHAR,
479
 
    //DRIZZLE_TYPE_DECIMAL
480
 
    DRIZZLE_TYPE_VARCHAR,
481
 
    //DRIZZLE_TYPE_VARCHAR,
482
 
    DRIZZLE_TYPE_VARCHAR,
483
 
    //DRIZZLE_TYPE_BLOB
484
 
    DRIZZLE_TYPE_BLOB,
485
 
    //DRIZZLE_TYPE_TIME
486
 
    DRIZZLE_TYPE_TIME,
487
 
    //DRIZZLE_TYPE_BOOLEAN
488
 
    DRIZZLE_TYPE_BOOLEAN,
489
 
    //DRIZZLE_TYPE_UUID
490
 
    DRIZZLE_TYPE_VARCHAR,
491
 
    //DRIZZLE_TYPE_MICROTIME
492
 
    DRIZZLE_TYPE_VARCHAR,
493
 
  },
494
 
  /* DRIZZLE_TYPE_UUID -> */
495
 
  {
496
 
    //DRIZZLE_TYPE_LONG
497
 
    DRIZZLE_TYPE_VARCHAR,
498
 
    //DRIZZLE_TYPE_DOUBLE
499
 
    DRIZZLE_TYPE_VARCHAR,
500
 
    //DRIZZLE_TYPE_NULL
501
 
    DRIZZLE_TYPE_UUID,
502
 
    //DRIZZLE_TYPE_TIMESTAMP
503
 
    DRIZZLE_TYPE_VARCHAR,
504
 
    //DRIZZLE_TYPE_LONGLONG
505
 
    DRIZZLE_TYPE_VARCHAR,
506
 
    //DRIZZLE_TYPE_DATETIME
507
 
    DRIZZLE_TYPE_VARCHAR,
508
 
    //DRIZZLE_TYPE_DATE
509
 
    DRIZZLE_TYPE_VARCHAR,
510
 
    //DRIZZLE_TYPE_VARCHAR
511
 
    DRIZZLE_TYPE_VARCHAR,
512
 
    //DRIZZLE_TYPE_DECIMAL
513
 
    DRIZZLE_TYPE_VARCHAR,
514
 
    //DRIZZLE_TYPE_VARCHAR,
515
 
    DRIZZLE_TYPE_VARCHAR,
516
 
    //DRIZZLE_TYPE_BLOB
517
 
    DRIZZLE_TYPE_BLOB,
518
 
    //DRIZZLE_TYPE_TIME
519
 
    DRIZZLE_TYPE_TIME,
520
 
    //DRIZZLE_TYPE_BOOLEAN
521
 
    DRIZZLE_TYPE_VARCHAR,
522
 
    //DRIZZLE_TYPE_UUID
523
 
    DRIZZLE_TYPE_UUID,
524
 
    //DRIZZLE_TYPE_MICROTIME
525
 
    DRIZZLE_TYPE_VARCHAR,
526
 
  },
527
 
  /* DRIZZLE_TYPE_MICROTIME -> */
528
 
  {
529
 
    //DRIZZLE_TYPE_LONG
530
 
    DRIZZLE_TYPE_VARCHAR,
531
 
    //DRIZZLE_TYPE_DOUBLE
532
 
    DRIZZLE_TYPE_VARCHAR,
533
 
    //DRIZZLE_TYPE_NULL
534
 
    DRIZZLE_TYPE_MICROTIME,
535
 
    //DRIZZLE_TYPE_TIMESTAMP
536
 
    DRIZZLE_TYPE_VARCHAR,
537
 
    //DRIZZLE_TYPE_LONGLONG
538
 
    DRIZZLE_TYPE_VARCHAR,
539
 
    //DRIZZLE_TYPE_DATETIME
540
 
    DRIZZLE_TYPE_VARCHAR,
541
 
    //DRIZZLE_TYPE_DATE
542
 
    DRIZZLE_TYPE_VARCHAR,
543
 
    //DRIZZLE_TYPE_VARCHAR
544
 
    DRIZZLE_TYPE_VARCHAR,
545
 
    //DRIZZLE_TYPE_DECIMAL
546
 
    DRIZZLE_TYPE_VARCHAR,
547
 
    //DRIZZLE_TYPE_VARCHAR,
548
 
    DRIZZLE_TYPE_VARCHAR,
549
 
    //DRIZZLE_TYPE_BLOB
550
 
    DRIZZLE_TYPE_BLOB,
551
 
    //DRIZZLE_TYPE_TIME
552
 
    DRIZZLE_TYPE_TIME,
553
 
    //DRIZZLE_TYPE_BOOLEAN
554
 
    DRIZZLE_TYPE_VARCHAR,
555
 
    //DRIZZLE_TYPE_UUID
556
 
    DRIZZLE_TYPE_UUID,
557
 
    //DRIZZLE_TYPE_MICROTIME
558
 
    DRIZZLE_TYPE_MICROTIME,
559
332
  },
560
333
};
561
334
 
562
 
static Item_result field_types_result_type [enum_field_types_size]=
 
335
static Item_result field_types_result_type [DRIZZLE_TYPE_MAX+1]=
563
336
{
564
337
  //DRIZZLE_TYPE_LONG
565
338
  INT_RESULT,
583
356
  STRING_RESULT,
584
357
  //DRIZZLE_TYPE_BLOB
585
358
  STRING_RESULT,
586
 
  //DRIZZLE_TYPE_TIME
587
 
  STRING_RESULT,
588
 
  //DRIZZLE_TYPE_BOOLEAN
589
 
  STRING_RESULT,
590
 
  //DRIZZLE_TYPE_UUID
591
 
  STRING_RESULT,
592
 
  //DRIZZLE_TYPE_MICROTIME
593
 
  STRING_RESULT,
594
359
};
595
360
 
596
361
bool test_if_important_data(const CHARSET_INFO * const cs, 
615
380
enum_field_types Field::field_type_merge(enum_field_types a,
616
381
                                         enum_field_types b)
617
382
{
618
 
  assert(a < enum_field_types_size);
619
 
  assert(b < enum_field_types_size);
 
383
  assert(a <= DRIZZLE_TYPE_MAX);
 
384
  assert(b <= DRIZZLE_TYPE_MAX);
620
385
  return field_types_merge_rules[a][b];
621
386
}
622
387
 
623
388
Item_result Field::result_merge_type(enum_field_types field_type)
624
389
{
625
 
  assert(field_type < enum_field_types_size);
 
390
  assert(field_type <= DRIZZLE_TYPE_MAX);
626
391
  return field_types_result_type[field_type];
627
392
}
628
393
 
827
592
             unsigned char *null_ptr_arg,
828
593
             unsigned char null_bit_arg,
829
594
             utype unireg_check_arg, 
830
 
             const char *field_name_arg) :
 
595
             const char *field_name_arg)
 
596
  :
831
597
    ptr(ptr_arg),
832
598
    null_ptr(null_ptr_arg),
833
599
    table(NULL),
834
600
    orig_table(NULL),
835
601
    field_name(field_name_arg),
836
 
    comment(NULL_LEX_STRING),
837
602
    key_start(0),
838
603
    part_of_key(0),
839
604
    part_of_key_not_clustered(0),
840
605
    part_of_sortkey(0),
841
606
    unireg_check(unireg_check_arg),
842
607
    field_length(length_arg),
843
 
    flags(null_ptr ? 0: NOT_NULL_FLAG),
844
 
    field_index(0),
845
608
    null_bit(null_bit_arg),
846
609
    is_created_from_null_item(false)
847
610
{
 
611
  flags= null_ptr ? 0: NOT_NULL_FLAG;
 
612
  comment.str= (char*) "";
 
613
  comment.length= 0;
 
614
  field_index= 0;
848
615
}
849
616
 
850
617
void Field::hash(uint32_t *nr, uint32_t *nr2)
873
640
  }
874
641
}
875
642
 
876
 
int Field::store_and_check(enum_check_fields check_level,
877
 
                           const char *to, 
878
 
                           uint32_t length,
879
 
                           const CHARSET_INFO * const cs)
880
 
 
 
643
int Field::store(const char *to, 
 
644
                 uint32_t length,
 
645
                 const CHARSET_INFO * const cs,
 
646
                 enum_check_fields check_level)
881
647
{
882
648
  int res;
883
649
  enum_check_fields old_check_level= table->in_use->count_cuted_fields;
939
705
  return(result);
940
706
}
941
707
 
942
 
type::Decimal *Field::val_decimal(type::Decimal *)
 
708
my_decimal *Field::val_decimal(my_decimal *)
943
709
{
944
710
  /* This never have to be called */
945
711
  assert(0);
974
740
  field->decimals= 0;
975
741
}
976
742
 
977
 
int64_t Field::convert_decimal2int64_t(const type::Decimal *val, bool, int *err)
 
743
int64_t Field::convert_decimal2int64_t(const my_decimal *val, bool, int *err)
978
744
{
979
745
  int64_t i;
980
 
  if (warn_if_overflow(val->val_int32(E_DEC_ERROR &
 
746
  if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
981
747
                                      ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
982
 
                                      false, &i)))
 
748
                                      val, false, &i)))
983
749
  {
984
750
    i= (val->sign() ? INT64_MIN : INT64_MAX);
985
751
    *err= 1;
997
763
  {
998
764
    copy->blob_field=(Field_blob*) this;
999
765
    copy->strip=0;
1000
 
    copy->length-= table->getShare()->sizeBlobPtr();
 
766
    copy->length-= table->getShare()->blob_ptr_size;
1001
767
    return copy->length;
1002
768
  }
1003
769
  else
1008
774
  return copy->length+ store_length;
1009
775
}
1010
776
 
1011
 
bool Field::get_date(type::Time &ltime, uint32_t fuzzydate)
1012
 
{
1013
 
  char buff[type::Time::MAX_STRING_LENGTH];
1014
 
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
1015
 
 
1016
 
  assert(getTable() and getTable()->getSession());
1017
 
 
1018
 
  if (not (res=val_str_internal(&tmp)) or
1019
 
      str_to_datetime_with_warn(getTable()->getSession(),
1020
 
                                res->ptr(), res->length(),
1021
 
                                &ltime, fuzzydate) <= type::DRIZZLE_TIMESTAMP_ERROR)
1022
 
  {
1023
 
    return true;
1024
 
  }
1025
 
 
1026
 
  return false;
1027
 
}
1028
 
 
1029
 
bool Field::get_time(type::Time &ltime)
1030
 
{
1031
 
  char buff[type::Time::MAX_STRING_LENGTH];
1032
 
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
1033
 
 
1034
 
  if (not (res= val_str_internal(&tmp)) or
1035
 
      str_to_time_with_warn(getTable()->getSession(), res->ptr(), res->length(), &ltime))
1036
 
  {
1037
 
    return true;
1038
 
  }
1039
 
 
1040
 
  return false;
1041
 
}
1042
 
 
1043
 
int Field::store_time(type::Time &ltime, type::timestamp_t)
1044
 
{
1045
 
  String tmp;
1046
 
 
1047
 
  ltime.convert(tmp);
1048
 
 
1049
 
  return store(tmp.ptr(), tmp.length(), &my_charset_bin);
 
777
bool Field::get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
 
778
{
 
779
  char buff[40];
 
780
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
 
781
  if (!(res=val_str(&tmp)) ||
 
782
      str_to_datetime_with_warn(res->ptr(), res->length(),
 
783
                                ltime, fuzzydate) <= DRIZZLE_TIMESTAMP_ERROR)
 
784
    return 1;
 
785
  return 0;
 
786
}
 
787
 
 
788
bool Field::get_time(DRIZZLE_TIME *ltime)
 
789
{
 
790
  char buff[40];
 
791
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
 
792
  if (!(res=val_str(&tmp)) ||
 
793
      str_to_time_with_warn(res->ptr(), res->length(), ltime))
 
794
    return 1;
 
795
  return 0;
 
796
}
 
797
 
 
798
int Field::store_time(DRIZZLE_TIME *ltime, enum enum_drizzle_timestamp_type)
 
799
{
 
800
  char buff[MAX_DATE_STRING_REP_LENGTH];
 
801
  uint32_t length= (uint32_t) my_TIME_to_str(ltime, buff);
 
802
  return store(buff, length, &my_charset_bin);
1050
803
}
1051
804
 
1052
805
bool Field::optimize_range(uint32_t idx, uint32_t)
1117
870
{
1118
871
  if (!Field::eq_def(field))
1119
872
    return 0;
1120
 
 
1121
873
  TYPELIB *from_lib=((Field_enum*) field)->typelib;
1122
874
 
1123
875
  if (typelib->count < from_lib->count)
1124
876
    return 0;
1125
 
 
1126
877
  for (uint32_t i=0 ; i < from_lib->count ; i++)
1127
 
  {
1128
878
    if (my_strnncoll(field_charset,
1129
879
                     (const unsigned char*)typelib->type_names[i],
1130
880
                     strlen(typelib->type_names[i]),
1131
881
                     (const unsigned char*)from_lib->type_names[i],
1132
882
                     strlen(from_lib->type_names[i])))
1133
883
      return 0;
1134
 
  }
1135
 
 
1136
884
  return 1;
1137
885
}
1138
886
 
1140
888
{
1141
889
  switch (type) {
1142
890
  case DRIZZLE_TYPE_VARCHAR: return (length + (length < 256 ? 1: 2));
1143
 
  case DRIZZLE_TYPE_UUID: return field::Uuid::max_string_length();
1144
 
  case DRIZZLE_TYPE_MICROTIME: return field::Microtime::max_string_length();
1145
 
  case DRIZZLE_TYPE_TIMESTAMP: return field::Epoch::max_string_length();
1146
 
  case DRIZZLE_TYPE_BOOLEAN: return field::Boolean::max_string_length();
1147
891
  case DRIZZLE_TYPE_DATE:
1148
892
  case DRIZZLE_TYPE_ENUM:
1149
893
  case DRIZZLE_TYPE_LONG: return 4;
1150
894
  case DRIZZLE_TYPE_DOUBLE: return sizeof(double);
1151
 
  case DRIZZLE_TYPE_TIME:
1152
895
  case DRIZZLE_TYPE_DATETIME:
 
896
  case DRIZZLE_TYPE_TIMESTAMP:
1153
897
  case DRIZZLE_TYPE_LONGLONG: return 8; /* Don't crash if no int64_t */
1154
898
  case DRIZZLE_TYPE_NULL: return 0;
1155
899
  case DRIZZLE_TYPE_BLOB: return 4 + portable_sizeof_char_ptr;
1156
900
  case DRIZZLE_TYPE_DECIMAL:
1157
 
                          break;
 
901
    abort();
 
902
  default:
 
903
    return 0;
1158
904
  }
1159
 
 
1160
 
  assert(0);
1161
 
  abort();
1162
905
}
1163
906
 
1164
907
uint32_t pack_length_to_packflag(uint32_t type)
1167
910
    case 1: return 1 << FIELDFLAG_PACK_SHIFT;
1168
911
    case 2: assert(1);
1169
912
    case 3: assert(1);
1170
 
    case 4: return f_settype(DRIZZLE_TYPE_LONG);
1171
 
    case 8: return f_settype(DRIZZLE_TYPE_LONGLONG);
 
913
    case 4: return f_settype((uint32_t) DRIZZLE_TYPE_LONG);
 
914
    case 8: return f_settype((uint32_t) DRIZZLE_TYPE_LONGLONG);
1172
915
  }
1173
916
  return 0;                                     // This shouldn't happen
1174
917
}
1178
921
*****************************************************************************/
1179
922
 
1180
923
bool Field::set_warning(DRIZZLE_ERROR::enum_warning_level level,
1181
 
                        drizzled::error_t code,
 
924
                        uint32_t code,
1182
925
                        int cuted_increment)
1183
926
{
1184
927
  /*
1198
941
 
1199
942
 
1200
943
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1201
 
                                 drizzled::error_t code,
 
944
                                 unsigned int code,
1202
945
                                 const char *str, 
1203
946
                                 uint32_t str_length,
1204
 
                                 type::timestamp_t ts_type, 
 
947
                                 enum enum_drizzle_timestamp_type ts_type, 
1205
948
                                 int cuted_increment)
1206
949
{
1207
 
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
1208
 
 
1209
 
  if ((session->abortOnWarning() and
 
950
  Session *session= table ? table->in_use : current_session;
 
951
  if ((session->really_abort_on_warning() &&
1210
952
       level >= DRIZZLE_ERROR::WARN_LEVEL_WARN) ||
1211
953
      set_warning(level, code, cuted_increment))
1212
954
    make_truncated_value_warning(session, level, str, str_length, ts_type,
1214
956
}
1215
957
 
1216
958
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, 
1217
 
                                 drizzled::error_t code,
 
959
                                 uint32_t code,
1218
960
                                 int64_t nr, 
1219
 
                                 type::timestamp_t ts_type,
 
961
                                 enum enum_drizzle_timestamp_type ts_type,
1220
962
                                 int cuted_increment)
1221
963
{
1222
 
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
1223
 
 
1224
 
  if (session->abortOnWarning() or
 
964
  Session *session= table ? table->in_use : current_session;
 
965
  if (session->really_abort_on_warning() ||
1225
966
      set_warning(level, code, cuted_increment))
1226
967
  {
1227
 
    char str_nr[DECIMAL_LONGLONG_DIGITS];
 
968
    char str_nr[22];
1228
969
    char *str_end= internal::int64_t10_to_str(nr, str_nr, -10);
1229
970
    make_truncated_value_warning(session, level, str_nr, (uint32_t) (str_end - str_nr),
1230
971
                                 ts_type, field_name);
1232
973
}
1233
974
 
1234
975
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1235
 
                                 const drizzled::error_t code,
 
976
                                 const uint32_t code,
1236
977
                                 double nr, 
1237
 
                                 type::timestamp_t ts_type)
 
978
                                 enum enum_drizzle_timestamp_type ts_type)
1238
979
{
1239
 
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
1240
 
 
1241
 
  if (session->abortOnWarning() or
 
980
  Session *session= table ? table->in_use : current_session;
 
981
  if (session->really_abort_on_warning() ||
1242
982
      set_warning(level, code, 1))
1243
983
  {
1244
984
    /* DBL_DIG is enough to print '-[digits].E+###' */
1275
1015
    table->clearWriteSet(field_index);
1276
1016
}
1277
1017
 
1278
 
void Field::pack_num(uint64_t arg, unsigned char *destination)
1279
 
{
1280
 
  if (not destination)
1281
 
    destination= ptr;
1282
 
 
1283
 
  int64_tstore(destination, arg);
1284
 
}
1285
 
 
1286
 
void Field::pack_num(uint32_t arg, unsigned char *destination)
1287
 
{
1288
 
  if (not destination)
1289
 
    destination= ptr;
1290
 
 
1291
 
  longstore(destination, arg);
1292
 
}
1293
 
 
1294
 
uint64_t Field::unpack_num(uint64_t &destination, const unsigned char *arg) const
1295
 
{
1296
 
  if (not arg)
1297
 
    arg= ptr;
1298
 
 
1299
 
  int64_tget(destination, arg);
1300
 
 
1301
 
  return destination;
1302
 
}
1303
 
 
1304
 
uint32_t Field::unpack_num(uint32_t &destination, const unsigned char *arg) const
1305
 
{
1306
 
  if (not arg)
1307
 
    arg= ptr;
1308
 
 
1309
 
  longget(destination, arg);
1310
 
 
1311
 
  return destination;
1312
 
}
1313
 
 
1314
 
std::ostream& operator<<(std::ostream& output, const Field &field)
1315
 
{
1316
 
  output << "Field:(";
1317
 
  output <<  field.field_name;
1318
 
  output << ", ";
1319
 
  output << drizzled::display::type(field.real_type());
1320
 
  output << ", { ";
1321
 
 
1322
 
  if (field.flags & NOT_NULL_FLAG)
1323
 
    output << " NOT_NULL";
1324
 
 
1325
 
  if (field.flags & PRI_KEY_FLAG)
1326
 
    output << ", PRIMARY KEY";
1327
 
 
1328
 
  if (field.flags & UNIQUE_KEY_FLAG)
1329
 
    output << ", UNIQUE KEY";
1330
 
 
1331
 
  if (field.flags & MULTIPLE_KEY_FLAG)
1332
 
    output << ", MULTIPLE KEY";
1333
 
 
1334
 
  if (field.flags & BLOB_FLAG)
1335
 
    output << ", BLOB";
1336
 
 
1337
 
  if (field.flags & UNSIGNED_FLAG)
1338
 
    output << ", UNSIGNED";
1339
 
 
1340
 
  if (field.flags & BINARY_FLAG)
1341
 
    output << ", BINARY";
1342
 
  output << "}, ";
1343
 
  output << ")";
1344
 
 
1345
 
  return output;  // for multiple << operators.
1346
 
}
1347
 
 
1348
1018
} /* namespace drizzled */