← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.cc

  • Committer: Monty Taylor
  • Date: 2011-02-13 17:26:39 UTC
  • mfrom: (2157.2.2 give-in-to-pkg-config)
  • mto: This revision was merged to the branch mainline in revision 2166.
  • Revision ID: mordred@inaugust.com-20110213172639-nhy7i72sfhoq13ms
Merged in pkg-config fixes.

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
4
5
 *  Copyright (C) 2008 MySQL
5
6
 *
6
7
 *  This program is free software; you can redistribute it and/or modify
31
32
#include "drizzled/field/str.h"
32
33
#include "drizzled/field/num.h"
33
34
#include "drizzled/field/blob.h"
 
35
#include "drizzled/field/boolean.h"
34
36
#include "drizzled/field/enum.h"
35
37
#include "drizzled/field/null.h"
36
38
#include "drizzled/field/date.h"
37
39
#include "drizzled/field/decimal.h"
38
40
#include "drizzled/field/real.h"
39
41
#include "drizzled/field/double.h"
40
 
#include "drizzled/field/long.h"
41
 
#include "drizzled/field/int64_t.h"
 
42
#include "drizzled/field/int32.h"
 
43
#include "drizzled/field/int64.h"
42
44
#include "drizzled/field/num.h"
43
 
#include "drizzled/field/timestamp.h"
 
45
#include "drizzled/field/time.h"
 
46
#include "drizzled/field/epoch.h"
44
47
#include "drizzled/field/datetime.h"
 
48
#include "drizzled/field/microtime.h"
45
49
#include "drizzled/field/varstring.h"
 
50
#include "drizzled/field/uuid.h"
46
51
#include "drizzled/time_functions.h"
47
52
#include "drizzled/internal/m_string.h"
48
53
 
 
54
#include "drizzled/display.h"
 
55
 
49
56
namespace drizzled
50
57
{
51
58
 
54
61
*****************************************************************************/
55
62
 
56
63
static enum_field_types
57
 
field_types_merge_rules [DRIZZLE_TYPE_MAX+1][DRIZZLE_TYPE_MAX+1]=
 
64
field_types_merge_rules [enum_field_types_size][enum_field_types_size]=
58
65
{
59
66
  /* DRIZZLE_TYPE_LONG -> */
60
67
  {
80
87
    DRIZZLE_TYPE_VARCHAR,
81
88
    //DRIZZLE_TYPE_BLOB
82
89
    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,
83
98
  },
84
99
  /* DRIZZLE_TYPE_DOUBLE -> */
85
100
  {
105
120
    DRIZZLE_TYPE_VARCHAR,
106
121
    //DRIZZLE_TYPE_BLOB
107
122
    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,
108
131
  },
109
132
  /* DRIZZLE_TYPE_NULL -> */
110
133
  {
130
153
    DRIZZLE_TYPE_ENUM,
131
154
    //DRIZZLE_TYPE_BLOB
132
155
    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,
133
164
  },
134
165
  /* DRIZZLE_TYPE_TIMESTAMP -> */
135
166
  {
155
186
    DRIZZLE_TYPE_VARCHAR,
156
187
    //DRIZZLE_TYPE_BLOB
157
188
    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,
158
197
  },
159
198
  /* DRIZZLE_TYPE_LONGLONG -> */
160
199
  {
179
218
    DRIZZLE_TYPE_VARCHAR,
180
219
    //DRIZZLE_TYPE_BLOB
181
220
    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,
182
229
  },
183
230
  /* DRIZZLE_TYPE_DATETIME -> */
184
231
  {
204
251
    DRIZZLE_TYPE_VARCHAR,
205
252
    //DRIZZLE_TYPE_BLOB
206
253
    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,
207
262
  },
208
263
  /* DRIZZLE_TYPE_DATE -> */
209
264
  {
229
284
    DRIZZLE_TYPE_VARCHAR,
230
285
    //DRIZZLE_TYPE_BLOB
231
286
    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,
232
295
  },
233
296
  /* DRIZZLE_TYPE_VARCHAR -> */
234
297
  {
254
317
    DRIZZLE_TYPE_VARCHAR,
255
318
    //DRIZZLE_TYPE_BLOB
256
319
    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,
257
328
  },
258
329
  /* DRIZZLE_TYPE_DECIMAL -> */
259
330
  {
279
350
    DRIZZLE_TYPE_VARCHAR,
280
351
    //DRIZZLE_TYPE_BLOB
281
352
    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,
282
361
  },
283
362
  /* DRIZZLE_TYPE_ENUM -> */
284
363
  {
304
383
    DRIZZLE_TYPE_VARCHAR,
305
384
    //DRIZZLE_TYPE_BLOB
306
385
    DRIZZLE_TYPE_BLOB,
307
 
  },
 
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
   },
308
395
  /* DRIZZLE_TYPE_BLOB -> */
309
396
  {
310
397
    //DRIZZLE_TYPE_LONG
329
416
    DRIZZLE_TYPE_BLOB,
330
417
    //DRIZZLE_TYPE_BLOB
331
418
    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,
332
559
  },
333
560
};
334
561
 
335
 
static Item_result field_types_result_type [DRIZZLE_TYPE_MAX+1]=
 
562
static Item_result field_types_result_type [enum_field_types_size]=
336
563
{
337
564
  //DRIZZLE_TYPE_LONG
338
565
  INT_RESULT,
356
583
  STRING_RESULT,
357
584
  //DRIZZLE_TYPE_BLOB
358
585
  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,
359
594
};
360
595
 
361
596
bool test_if_important_data(const CHARSET_INFO * const cs, 
380
615
enum_field_types Field::field_type_merge(enum_field_types a,
381
616
                                         enum_field_types b)
382
617
{
383
 
  assert(a <= DRIZZLE_TYPE_MAX);
384
 
  assert(b <= DRIZZLE_TYPE_MAX);
 
618
  assert(a < enum_field_types_size);
 
619
  assert(b < enum_field_types_size);
385
620
  return field_types_merge_rules[a][b];
386
621
}
387
622
 
388
623
Item_result Field::result_merge_type(enum_field_types field_type)
389
624
{
390
 
  assert(field_type <= DRIZZLE_TYPE_MAX);
 
625
  assert(field_type < enum_field_types_size);
391
626
  return field_types_result_type[field_type];
392
627
}
393
628
 
592
827
             unsigned char *null_ptr_arg,
593
828
             unsigned char null_bit_arg,
594
829
             utype unireg_check_arg, 
595
 
             const char *field_name_arg)
596
 
  :
 
830
             const char *field_name_arg) :
597
831
    ptr(ptr_arg),
598
832
    null_ptr(null_ptr_arg),
599
833
    table(NULL),
600
834
    orig_table(NULL),
601
835
    field_name(field_name_arg),
 
836
    comment(NULL_LEX_STRING),
602
837
    key_start(0),
603
838
    part_of_key(0),
604
839
    part_of_key_not_clustered(0),
605
840
    part_of_sortkey(0),
606
841
    unireg_check(unireg_check_arg),
607
842
    field_length(length_arg),
 
843
    flags(null_ptr ? 0: NOT_NULL_FLAG),
 
844
    field_index(0),
608
845
    null_bit(null_bit_arg),
609
846
    is_created_from_null_item(false)
610
847
{
611
 
  flags= null_ptr ? 0: NOT_NULL_FLAG;
612
 
  comment.str= (char*) "";
613
 
  comment.length= 0;
614
 
  field_index= 0;
615
848
}
616
849
 
617
850
void Field::hash(uint32_t *nr, uint32_t *nr2)
640
873
  }
641
874
}
642
875
 
643
 
int Field::store(const char *to, 
644
 
                 uint32_t length,
645
 
                 const CHARSET_INFO * const cs,
646
 
                 enum_check_fields check_level)
 
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
 
647
881
{
648
882
  int res;
649
883
  enum_check_fields old_check_level= table->in_use->count_cuted_fields;
705
939
  return(result);
706
940
}
707
941
 
708
 
my_decimal *Field::val_decimal(my_decimal *)
 
942
type::Decimal *Field::val_decimal(type::Decimal *)
709
943
{
710
944
  /* This never have to be called */
711
945
  assert(0);
740
974
  field->decimals= 0;
741
975
}
742
976
 
743
 
int64_t Field::convert_decimal2int64_t(const my_decimal *val, bool, int *err)
 
977
int64_t Field::convert_decimal2int64_t(const type::Decimal *val, bool, int *err)
744
978
{
745
979
  int64_t i;
746
 
  if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
 
980
  if (warn_if_overflow(val->val_int32(E_DEC_ERROR &
747
981
                                      ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
748
 
                                      val, false, &i)))
 
982
                                      false, &i)))
749
983
  {
750
984
    i= (val->sign() ? INT64_MIN : INT64_MAX);
751
985
    *err= 1;
763
997
  {
764
998
    copy->blob_field=(Field_blob*) this;
765
999
    copy->strip=0;
766
 
    copy->length-= table->getShare()->blob_ptr_size;
 
1000
    copy->length-= table->getShare()->sizeBlobPtr();
767
1001
    return copy->length;
768
1002
  }
769
1003
  else
774
1008
  return copy->length+ store_length;
775
1009
}
776
1010
 
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);
 
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);
803
1050
}
804
1051
 
805
1052
bool Field::optimize_range(uint32_t idx, uint32_t)
870
1117
{
871
1118
  if (!Field::eq_def(field))
872
1119
    return 0;
 
1120
 
873
1121
  TYPELIB *from_lib=((Field_enum*) field)->typelib;
874
1122
 
875
1123
  if (typelib->count < from_lib->count)
876
1124
    return 0;
 
1125
 
877
1126
  for (uint32_t i=0 ; i < from_lib->count ; i++)
 
1127
  {
878
1128
    if (my_strnncoll(field_charset,
879
1129
                     (const unsigned char*)typelib->type_names[i],
880
1130
                     strlen(typelib->type_names[i]),
881
1131
                     (const unsigned char*)from_lib->type_names[i],
882
1132
                     strlen(from_lib->type_names[i])))
883
1133
      return 0;
 
1134
  }
 
1135
 
884
1136
  return 1;
885
1137
}
886
1138
 
888
1140
{
889
1141
  switch (type) {
890
1142
  case DRIZZLE_TYPE_VARCHAR: return (length + (length < 256 ? 1: 2));
 
1143
  case DRIZZLE_TYPE_UUID: return field::Uuid::max_string_length();
 
1144
  case DRIZZLE_TYPE_MICROTIME: return field::Microtime::max_string_length();
 
1145
  case DRIZZLE_TYPE_TIMESTAMP: return field::Epoch::max_string_length();
 
1146
  case DRIZZLE_TYPE_BOOLEAN: return field::Boolean::max_string_length();
891
1147
  case DRIZZLE_TYPE_DATE:
892
1148
  case DRIZZLE_TYPE_ENUM:
893
1149
  case DRIZZLE_TYPE_LONG: return 4;
894
1150
  case DRIZZLE_TYPE_DOUBLE: return sizeof(double);
 
1151
  case DRIZZLE_TYPE_TIME:
895
1152
  case DRIZZLE_TYPE_DATETIME:
896
 
  case DRIZZLE_TYPE_TIMESTAMP:
897
1153
  case DRIZZLE_TYPE_LONGLONG: return 8; /* Don't crash if no int64_t */
898
1154
  case DRIZZLE_TYPE_NULL: return 0;
899
1155
  case DRIZZLE_TYPE_BLOB: return 4 + portable_sizeof_char_ptr;
900
1156
  case DRIZZLE_TYPE_DECIMAL:
901
 
    abort();
902
 
  default:
903
 
    return 0;
 
1157
                          break;
904
1158
  }
 
1159
 
 
1160
  assert(0);
 
1161
  abort();
905
1162
}
906
1163
 
907
1164
uint32_t pack_length_to_packflag(uint32_t type)
921
1178
*****************************************************************************/
922
1179
 
923
1180
bool Field::set_warning(DRIZZLE_ERROR::enum_warning_level level,
924
 
                        uint32_t code,
 
1181
                        drizzled::error_t code,
925
1182
                        int cuted_increment)
926
1183
{
927
1184
  /*
941
1198
 
942
1199
 
943
1200
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
944
 
                                 unsigned int code,
 
1201
                                 drizzled::error_t code,
945
1202
                                 const char *str, 
946
1203
                                 uint32_t str_length,
947
 
                                 enum enum_drizzle_timestamp_type ts_type, 
 
1204
                                 type::timestamp_t ts_type, 
948
1205
                                 int cuted_increment)
949
1206
{
950
 
  Session *session= table ? table->in_use : current_session;
951
 
  if ((session->really_abort_on_warning() &&
 
1207
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
 
1208
 
 
1209
  if ((session->abortOnWarning() and
952
1210
       level >= DRIZZLE_ERROR::WARN_LEVEL_WARN) ||
953
1211
      set_warning(level, code, cuted_increment))
954
1212
    make_truncated_value_warning(session, level, str, str_length, ts_type,
956
1214
}
957
1215
 
958
1216
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, 
959
 
                                 uint32_t code,
 
1217
                                 drizzled::error_t code,
960
1218
                                 int64_t nr, 
961
 
                                 enum enum_drizzle_timestamp_type ts_type,
 
1219
                                 type::timestamp_t ts_type,
962
1220
                                 int cuted_increment)
963
1221
{
964
 
  Session *session= table ? table->in_use : current_session;
965
 
  if (session->really_abort_on_warning() ||
 
1222
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
 
1223
 
 
1224
  if (session->abortOnWarning() or
966
1225
      set_warning(level, code, cuted_increment))
967
1226
  {
968
 
    char str_nr[22];
 
1227
    char str_nr[DECIMAL_LONGLONG_DIGITS];
969
1228
    char *str_end= internal::int64_t10_to_str(nr, str_nr, -10);
970
1229
    make_truncated_value_warning(session, level, str_nr, (uint32_t) (str_end - str_nr),
971
1230
                                 ts_type, field_name);
973
1232
}
974
1233
 
975
1234
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
976
 
                                 const uint32_t code,
 
1235
                                 const drizzled::error_t code,
977
1236
                                 double nr, 
978
 
                                 enum enum_drizzle_timestamp_type ts_type)
 
1237
                                 type::timestamp_t ts_type)
979
1238
{
980
 
  Session *session= table ? table->in_use : current_session;
981
 
  if (session->really_abort_on_warning() ||
 
1239
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
 
1240
 
 
1241
  if (session->abortOnWarning() or
982
1242
      set_warning(level, code, 1))
983
1243
  {
984
1244
    /* DBL_DIG is enough to print '-[digits].E+###' */
1015
1275
    table->clearWriteSet(field_index);
1016
1276
}
1017
1277
 
 
1278
void Field::pack_num(uint64_t arg, unsigned char *destination)
 
1279
{
 
1280
  if (not destination)
 
1281
    destination= ptr;
 
1282
 
 
1283
  int64_tstore(destination, arg);
 
1284
}
 
1285
 
 
1286
void Field::pack_num(uint32_t arg, unsigned char *destination)
 
1287
{
 
1288
  if (not destination)
 
1289
    destination= ptr;
 
1290
 
 
1291
  longstore(destination, arg);
 
1292
}
 
1293
 
 
1294
uint64_t Field::unpack_num(uint64_t &destination, const unsigned char *arg) const
 
1295
{
 
1296
  if (not arg)
 
1297
    arg= ptr;
 
1298
 
 
1299
  int64_tget(destination, arg);
 
1300
 
 
1301
  return destination;
 
1302
}
 
1303
 
 
1304
uint32_t Field::unpack_num(uint32_t &destination, const unsigned char *arg) const
 
1305
{
 
1306
  if (not arg)
 
1307
    arg= ptr;
 
1308
 
 
1309
  longget(destination, arg);
 
1310
 
 
1311
  return destination;
 
1312
}
 
1313
 
 
1314
std::ostream& operator<<(std::ostream& output, const Field &field)
 
1315
{
 
1316
  output << "Field:(";
 
1317
  output <<  field.field_name;
 
1318
  output << ", ";
 
1319
  output << drizzled::display::type(field.real_type());
 
1320
  output << ", { ";
 
1321
 
 
1322
  if (field.flags & NOT_NULL_FLAG)
 
1323
    output << " NOT_NULL";
 
1324
 
 
1325
  if (field.flags & PRI_KEY_FLAG)
 
1326
    output << ", PRIMARY KEY";
 
1327
 
 
1328
  if (field.flags & UNIQUE_KEY_FLAG)
 
1329
    output << ", UNIQUE KEY";
 
1330
 
 
1331
  if (field.flags & MULTIPLE_KEY_FLAG)
 
1332
    output << ", MULTIPLE KEY";
 
1333
 
 
1334
  if (field.flags & BLOB_FLAG)
 
1335
    output << ", BLOB";
 
1336
 
 
1337
  if (field.flags & UNSIGNED_FLAG)
 
1338
    output << ", UNSIGNED";
 
1339
 
 
1340
  if (field.flags & BINARY_FLAG)
 
1341
    output << ", BINARY";
 
1342
  output << "}, ";
 
1343
  output << ")";
 
1344
 
 
1345
  return output;  // for multiple << operators.
 
1346
}
 
1347
 
1018
1348
} /* namespace drizzled */