← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.cc

Refactor

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
22
23
 * @file This file implements the Field class and API
23
24
 */
24
25
 
25
 
#include "config.h"
 
26
#include <config.h>
26
27
#include <cstdio>
27
28
#include <errno.h>
28
29
#include <float.h>
29
 
#include "drizzled/sql_select.h"
30
 
#include "drizzled/error.h"
31
 
#include "drizzled/field/str.h"
32
 
#include "drizzled/field/num.h"
33
 
#include "drizzled/field/blob.h"
34
 
#include "drizzled/field/enum.h"
35
 
#include "drizzled/field/null.h"
36
 
#include "drizzled/field/date.h"
37
 
#include "drizzled/field/decimal.h"
38
 
#include "drizzled/field/real.h"
39
 
#include "drizzled/field/double.h"
40
 
#include "drizzled/field/int32.h"
41
 
#include "drizzled/field/int64.h"
42
 
#include "drizzled/field/num.h"
43
 
#include "drizzled/field/timestamp.h"
44
 
#include "drizzled/field/datetime.h"
45
 
#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"
 
30
#include <drizzled/sql_select.h>
 
31
#include <drizzled/error.h>
 
32
#include <drizzled/field/str.h>
 
33
#include <drizzled/field/num.h>
 
34
#include <drizzled/field/blob.h>
 
35
#include <drizzled/field/boolean.h>
 
36
#include <drizzled/field/enum.h>
 
37
#include <drizzled/field/null.h>
 
38
#include <drizzled/field/date.h>
 
39
#include <drizzled/field/decimal.h>
 
40
#include <drizzled/field/real.h>
 
41
#include <drizzled/field/double.h>
 
42
#include <drizzled/field/int32.h>
 
43
#include <drizzled/field/int64.h>
 
44
#include <drizzled/field/num.h>
 
45
#include <drizzled/field/time.h>
 
46
#include <drizzled/field/epoch.h>
 
47
#include <drizzled/field/datetime.h>
 
48
#include <drizzled/field/microtime.h>
 
49
#include <drizzled/field/varstring.h>
 
50
#include <drizzled/field/uuid.h>
 
51
#include <drizzled/time_functions.h>
 
52
#include <drizzled/internal/m_string.h>
 
53
#include <drizzled/table.h>
 
54
#include <drizzled/util/test.h>
 
55
#include <drizzled/session.h>
 
56
#include <drizzled/current_session.h>
 
57
#include <drizzled/display.h>
 
58
#include <drizzled/typelib.h>
51
59
 
52
60
namespace drizzled
53
61
{
83
91
    DRIZZLE_TYPE_VARCHAR,
84
92
    //DRIZZLE_TYPE_BLOB
85
93
    DRIZZLE_TYPE_BLOB,
 
94
    //DRIZZLE_TYPE_TIME
 
95
    DRIZZLE_TYPE_TIME,
 
96
    //DRIZZLE_TYPE_BOOLEAN
 
97
    DRIZZLE_TYPE_VARCHAR,
86
98
    //DRIZZLE_TYPE_UUID
87
99
    DRIZZLE_TYPE_VARCHAR,
 
100
    //DRIZZLE_TYPE_MICROTIME
 
101
    DRIZZLE_TYPE_VARCHAR,
88
102
  },
89
103
  /* DRIZZLE_TYPE_DOUBLE -> */
90
104
  {
110
124
    DRIZZLE_TYPE_VARCHAR,
111
125
    //DRIZZLE_TYPE_BLOB
112
126
    DRIZZLE_TYPE_BLOB,
 
127
    //DRIZZLE_TYPE_TIME
 
128
    DRIZZLE_TYPE_TIME,
 
129
    //DRIZZLE_TYPE_BOOLEAN
 
130
    DRIZZLE_TYPE_VARCHAR,
113
131
    //DRIZZLE_TYPE_UUID
114
132
    DRIZZLE_TYPE_VARCHAR,
 
133
    //DRIZZLE_TYPE_MICROTIME
 
134
    DRIZZLE_TYPE_VARCHAR,
115
135
  },
116
136
  /* DRIZZLE_TYPE_NULL -> */
117
137
  {
137
157
    DRIZZLE_TYPE_ENUM,
138
158
    //DRIZZLE_TYPE_BLOB
139
159
    DRIZZLE_TYPE_BLOB,
 
160
    //DRIZZLE_TYPE_TIME
 
161
    DRIZZLE_TYPE_TIME,
 
162
    //DRIZZLE_TYPE_BOOLEAN
 
163
    DRIZZLE_TYPE_BOOLEAN,
140
164
    //DRIZZLE_TYPE_UUID
141
165
    DRIZZLE_TYPE_UUID,
 
166
    //DRIZZLE_TYPE_MICROTIME
 
167
    DRIZZLE_TYPE_MICROTIME,
142
168
  },
143
169
  /* DRIZZLE_TYPE_TIMESTAMP -> */
144
170
  {
164
190
    DRIZZLE_TYPE_VARCHAR,
165
191
    //DRIZZLE_TYPE_BLOB
166
192
    DRIZZLE_TYPE_BLOB,
 
193
    //DRIZZLE_TYPE_TIME
 
194
    DRIZZLE_TYPE_TIME,
 
195
    //DRIZZLE_TYPE_BOOLEAN
 
196
    DRIZZLE_TYPE_VARCHAR,
167
197
    //DRIZZLE_TYPE_UUID
168
198
    DRIZZLE_TYPE_VARCHAR,
 
199
    //DRIZZLE_TYPE_MICROTIME
 
200
    DRIZZLE_TYPE_VARCHAR,
169
201
  },
170
202
  /* DRIZZLE_TYPE_LONGLONG -> */
171
203
  {
190
222
    DRIZZLE_TYPE_VARCHAR,
191
223
    //DRIZZLE_TYPE_BLOB
192
224
    DRIZZLE_TYPE_BLOB,
 
225
    //DRIZZLE_TYPE_TIME
 
226
    DRIZZLE_TYPE_TIME,
 
227
    //DRIZZLE_TYPE_BOOLEAN
 
228
    DRIZZLE_TYPE_VARCHAR,
193
229
    //DRIZZLE_TYPE_UUID
194
230
    DRIZZLE_TYPE_VARCHAR,
 
231
    //DRIZZLE_TYPE_MICROTIME
 
232
    DRIZZLE_TYPE_VARCHAR,
195
233
  },
196
234
  /* DRIZZLE_TYPE_DATETIME -> */
197
235
  {
217
255
    DRIZZLE_TYPE_VARCHAR,
218
256
    //DRIZZLE_TYPE_BLOB
219
257
    DRIZZLE_TYPE_BLOB,
 
258
    //DRIZZLE_TYPE_TIME
 
259
    DRIZZLE_TYPE_TIME,
 
260
    //DRIZZLE_TYPE_BOOLEAN
 
261
    DRIZZLE_TYPE_VARCHAR,
220
262
    //DRIZZLE_TYPE_UUID
221
263
    DRIZZLE_TYPE_VARCHAR,
 
264
    //DRIZZLE_TYPE_MICROTIME
 
265
    DRIZZLE_TYPE_VARCHAR,
222
266
  },
223
267
  /* DRIZZLE_TYPE_DATE -> */
224
268
  {
244
288
    DRIZZLE_TYPE_VARCHAR,
245
289
    //DRIZZLE_TYPE_BLOB
246
290
    DRIZZLE_TYPE_BLOB,
 
291
    //DRIZZLE_TYPE_TIME
 
292
    DRIZZLE_TYPE_TIME,
 
293
    //DRIZZLE_TYPE_BOOLEAN
 
294
    DRIZZLE_TYPE_VARCHAR,
247
295
    //DRIZZLE_TYPE_UUID
248
296
    DRIZZLE_TYPE_VARCHAR,
 
297
    //DRIZZLE_TYPE_MICROTIME
 
298
    DRIZZLE_TYPE_VARCHAR,
249
299
  },
250
300
  /* DRIZZLE_TYPE_VARCHAR -> */
251
301
  {
271
321
    DRIZZLE_TYPE_VARCHAR,
272
322
    //DRIZZLE_TYPE_BLOB
273
323
    DRIZZLE_TYPE_BLOB,
 
324
    //DRIZZLE_TYPE_TIME
 
325
    DRIZZLE_TYPE_TIME,
 
326
    //DRIZZLE_TYPE_BOOLEAN
 
327
    DRIZZLE_TYPE_VARCHAR,
274
328
    //DRIZZLE_TYPE_UUID
275
329
    DRIZZLE_TYPE_VARCHAR,
 
330
    //DRIZZLE_TYPE_MICROTIME
 
331
    DRIZZLE_TYPE_VARCHAR,
276
332
  },
277
333
  /* DRIZZLE_TYPE_DECIMAL -> */
278
334
  {
298
354
    DRIZZLE_TYPE_VARCHAR,
299
355
    //DRIZZLE_TYPE_BLOB
300
356
    DRIZZLE_TYPE_BLOB,
 
357
    //DRIZZLE_TYPE_TIME
 
358
    DRIZZLE_TYPE_TIME,
 
359
    //DRIZZLE_TYPE_BOOLEAN
 
360
    DRIZZLE_TYPE_VARCHAR,
301
361
    //DRIZZLE_TYPE_UUID
302
362
    DRIZZLE_TYPE_VARCHAR,
 
363
    //DRIZZLE_TYPE_MICROTIME
 
364
    DRIZZLE_TYPE_VARCHAR,
303
365
  },
304
366
  /* DRIZZLE_TYPE_ENUM -> */
305
367
  {
325
387
    DRIZZLE_TYPE_VARCHAR,
326
388
    //DRIZZLE_TYPE_BLOB
327
389
    DRIZZLE_TYPE_BLOB,
 
390
    //DRIZZLE_TYPE_TIME
 
391
    DRIZZLE_TYPE_TIME,
 
392
    //DRIZZLE_TYPE_BOOLEAN
 
393
    DRIZZLE_TYPE_VARCHAR,
328
394
    //DRIZZLE_TYPE_UUID
329
395
    DRIZZLE_TYPE_VARCHAR,
 
396
    //DRIZZLE_TYPE_MICROTIME
 
397
    DRIZZLE_TYPE_VARCHAR,
330
398
   },
331
399
  /* DRIZZLE_TYPE_BLOB -> */
332
400
  {
352
420
    DRIZZLE_TYPE_BLOB,
353
421
    //DRIZZLE_TYPE_BLOB
354
422
    DRIZZLE_TYPE_BLOB,
355
 
    //DRIZZLE_TYPE_UUID
 
423
    //DRIZZLE_TYPE_TIME
 
424
    DRIZZLE_TYPE_TIME,
 
425
    //DRIZZLE_TYPE_BOOLEAN
 
426
    DRIZZLE_TYPE_VARCHAR,
 
427
    //DRIZZLE_TYPE_UUID
 
428
    DRIZZLE_TYPE_VARCHAR,
 
429
    //DRIZZLE_TYPE_MICROTIME
 
430
    DRIZZLE_TYPE_VARCHAR,
 
431
  },
 
432
  /* DRIZZLE_TYPE_TIME -> */
 
433
  {
 
434
    //DRIZZLE_TYPE_LONG
 
435
    DRIZZLE_TYPE_VARCHAR,
 
436
    //DRIZZLE_TYPE_DOUBLE
 
437
    DRIZZLE_TYPE_VARCHAR,
 
438
    //DRIZZLE_TYPE_NULL
 
439
    DRIZZLE_TYPE_TIME,
 
440
    //DRIZZLE_TYPE_TIMESTAMP
 
441
    DRIZZLE_TYPE_VARCHAR,
 
442
    //DRIZZLE_TYPE_LONGLONG
 
443
    DRIZZLE_TYPE_VARCHAR,
 
444
    //DRIZZLE_TYPE_DATETIME
 
445
    DRIZZLE_TYPE_VARCHAR,
 
446
    //DRIZZLE_TYPE_DATE
 
447
    DRIZZLE_TYPE_VARCHAR,
 
448
    //DRIZZLE_TYPE_VARCHAR
 
449
    DRIZZLE_TYPE_VARCHAR,
 
450
    //DRIZZLE_TYPE_DECIMAL
 
451
    DRIZZLE_TYPE_VARCHAR,
 
452
    //DRIZZLE_TYPE_VARCHAR,
 
453
    DRIZZLE_TYPE_VARCHAR,
 
454
    //DRIZZLE_TYPE_BLOB
 
455
    DRIZZLE_TYPE_BLOB,
 
456
    //DRIZZLE_TYPE_TIME
 
457
    DRIZZLE_TYPE_TIME,
 
458
    //DRIZZLE_TYPE_BOOLEAN
 
459
    DRIZZLE_TYPE_VARCHAR,
 
460
    //DRIZZLE_TYPE_UUID
 
461
    DRIZZLE_TYPE_UUID,
 
462
    //DRIZZLE_TYPE_MICROTIME
 
463
    DRIZZLE_TYPE_VARCHAR,
 
464
  },
 
465
  /* DRIZZLE_TYPE_BOOLEAN -> */
 
466
  {
 
467
    //DRIZZLE_TYPE_LONG
 
468
    DRIZZLE_TYPE_VARCHAR,
 
469
    //DRIZZLE_TYPE_DOUBLE
 
470
    DRIZZLE_TYPE_VARCHAR,
 
471
    //DRIZZLE_TYPE_NULL
 
472
    DRIZZLE_TYPE_BOOLEAN,
 
473
    //DRIZZLE_TYPE_TIMESTAMP
 
474
    DRIZZLE_TYPE_VARCHAR,
 
475
    //DRIZZLE_TYPE_LONGLONG
 
476
    DRIZZLE_TYPE_VARCHAR,
 
477
    //DRIZZLE_TYPE_DATETIME
 
478
    DRIZZLE_TYPE_VARCHAR,
 
479
    //DRIZZLE_TYPE_DATE
 
480
    DRIZZLE_TYPE_VARCHAR,
 
481
    //DRIZZLE_TYPE_VARCHAR
 
482
    DRIZZLE_TYPE_VARCHAR,
 
483
    //DRIZZLE_TYPE_DECIMAL
 
484
    DRIZZLE_TYPE_VARCHAR,
 
485
    //DRIZZLE_TYPE_VARCHAR,
 
486
    DRIZZLE_TYPE_VARCHAR,
 
487
    //DRIZZLE_TYPE_BLOB
 
488
    DRIZZLE_TYPE_BLOB,
 
489
    //DRIZZLE_TYPE_TIME
 
490
    DRIZZLE_TYPE_TIME,
 
491
    //DRIZZLE_TYPE_BOOLEAN
 
492
    DRIZZLE_TYPE_BOOLEAN,
 
493
    //DRIZZLE_TYPE_UUID
 
494
    DRIZZLE_TYPE_VARCHAR,
 
495
    //DRIZZLE_TYPE_MICROTIME
356
496
    DRIZZLE_TYPE_VARCHAR,
357
497
  },
358
498
  /* DRIZZLE_TYPE_UUID -> */
379
519
    DRIZZLE_TYPE_VARCHAR,
380
520
    //DRIZZLE_TYPE_BLOB
381
521
    DRIZZLE_TYPE_BLOB,
382
 
    //DRIZZLE_TYPE_UUID
383
 
    DRIZZLE_TYPE_UUID,
 
522
    //DRIZZLE_TYPE_TIME
 
523
    DRIZZLE_TYPE_TIME,
 
524
    //DRIZZLE_TYPE_BOOLEAN
 
525
    DRIZZLE_TYPE_VARCHAR,
 
526
    //DRIZZLE_TYPE_UUID
 
527
    DRIZZLE_TYPE_UUID,
 
528
    //DRIZZLE_TYPE_MICROTIME
 
529
    DRIZZLE_TYPE_VARCHAR,
 
530
  },
 
531
  /* DRIZZLE_TYPE_MICROTIME -> */
 
532
  {
 
533
    //DRIZZLE_TYPE_LONG
 
534
    DRIZZLE_TYPE_VARCHAR,
 
535
    //DRIZZLE_TYPE_DOUBLE
 
536
    DRIZZLE_TYPE_VARCHAR,
 
537
    //DRIZZLE_TYPE_NULL
 
538
    DRIZZLE_TYPE_MICROTIME,
 
539
    //DRIZZLE_TYPE_TIMESTAMP
 
540
    DRIZZLE_TYPE_VARCHAR,
 
541
    //DRIZZLE_TYPE_LONGLONG
 
542
    DRIZZLE_TYPE_VARCHAR,
 
543
    //DRIZZLE_TYPE_DATETIME
 
544
    DRIZZLE_TYPE_VARCHAR,
 
545
    //DRIZZLE_TYPE_DATE
 
546
    DRIZZLE_TYPE_VARCHAR,
 
547
    //DRIZZLE_TYPE_VARCHAR
 
548
    DRIZZLE_TYPE_VARCHAR,
 
549
    //DRIZZLE_TYPE_DECIMAL
 
550
    DRIZZLE_TYPE_VARCHAR,
 
551
    //DRIZZLE_TYPE_VARCHAR,
 
552
    DRIZZLE_TYPE_VARCHAR,
 
553
    //DRIZZLE_TYPE_BLOB
 
554
    DRIZZLE_TYPE_BLOB,
 
555
    //DRIZZLE_TYPE_TIME
 
556
    DRIZZLE_TYPE_TIME,
 
557
    //DRIZZLE_TYPE_BOOLEAN
 
558
    DRIZZLE_TYPE_VARCHAR,
 
559
    //DRIZZLE_TYPE_UUID
 
560
    DRIZZLE_TYPE_UUID,
 
561
    //DRIZZLE_TYPE_MICROTIME
 
562
    DRIZZLE_TYPE_MICROTIME,
384
563
  },
385
564
};
386
565
 
408
587
  STRING_RESULT,
409
588
  //DRIZZLE_TYPE_BLOB
410
589
  STRING_RESULT,
 
590
  //DRIZZLE_TYPE_TIME
 
591
  STRING_RESULT,
 
592
  //DRIZZLE_TYPE_BOOLEAN
 
593
  STRING_RESULT,
411
594
  //DRIZZLE_TYPE_UUID
412
595
  STRING_RESULT,
 
596
  //DRIZZLE_TYPE_MICROTIME
 
597
  STRING_RESULT,
413
598
};
414
599
 
415
 
bool test_if_important_data(const CHARSET_INFO * const cs, 
 
600
bool test_if_important_data(const charset_info_st * const cs, 
416
601
                            const char *str,
417
602
                            const char *strend)
418
603
{
561
746
  return 0;
562
747
}
563
748
 
564
 
bool Field::is_null(ptrdiff_t row_offset)
 
749
bool Field::is_null(ptrdiff_t row_offset) const
565
750
{
566
751
  return null_ptr ?
567
752
    (null_ptr[row_offset] & null_bit ? true : false) :
568
753
    table->null_row;
569
754
}
570
755
 
571
 
bool Field::is_real_null(ptrdiff_t row_offset)
 
756
bool Field::is_real_null(ptrdiff_t row_offset) const
572
757
{
573
758
  return null_ptr ? (null_ptr[row_offset] & null_bit ? true : false) : false;
574
759
}
575
760
 
576
 
bool Field::is_null_in_record(const unsigned char *record)
 
761
bool Field::is_null_in_record(const unsigned char *record) const
577
762
{
578
763
  if (! null_ptr)
579
764
    return false;
580
765
  return test(record[(uint32_t) (null_ptr -table->getInsertRecord())] & null_bit);
581
766
}
582
767
 
583
 
bool Field::is_null_in_record_with_offset(ptrdiff_t with_offset)
 
768
bool Field::is_null_in_record_with_offset(ptrdiff_t with_offset) const
584
769
{
585
770
  if (! null_ptr)
586
771
    return false;
599
784
    null_ptr[row_offset]&= (unsigned char) ~null_bit;
600
785
}
601
786
 
602
 
bool Field::maybe_null(void)
 
787
bool Field::maybe_null(void) const
603
788
{
604
789
  return null_ptr != 0 || table->maybe_null;
605
790
}
606
791
 
607
 
bool Field::real_maybe_null(void)
 
792
bool Field::real_maybe_null(void) const
608
793
{
609
794
  return null_ptr != 0;
610
795
}
646
831
             unsigned char *null_ptr_arg,
647
832
             unsigned char null_bit_arg,
648
833
             utype unireg_check_arg, 
649
 
             const char *field_name_arg)
650
 
  :
 
834
             const char *field_name_arg) :
651
835
    ptr(ptr_arg),
652
836
    null_ptr(null_ptr_arg),
653
837
    table(NULL),
654
838
    orig_table(NULL),
655
839
    field_name(field_name_arg),
 
840
    comment(NULL_LEX_STRING),
656
841
    key_start(0),
657
842
    part_of_key(0),
658
843
    part_of_key_not_clustered(0),
659
844
    part_of_sortkey(0),
660
845
    unireg_check(unireg_check_arg),
661
846
    field_length(length_arg),
 
847
    flags(null_ptr ? 0: NOT_NULL_FLAG),
 
848
    field_index(0),
662
849
    null_bit(null_bit_arg),
663
850
    is_created_from_null_item(false)
664
851
{
665
 
  flags= null_ptr ? 0: NOT_NULL_FLAG;
666
 
  comment.str= (char*) "";
667
 
  comment.length= 0;
668
 
  field_index= 0;
669
852
}
670
853
 
671
 
void Field::hash(uint32_t *nr, uint32_t *nr2)
 
854
void Field::hash(uint32_t *nr, uint32_t *nr2) const
672
855
{
673
856
  if (is_null())
674
857
  {
677
860
  else
678
861
  {
679
862
    uint32_t len= pack_length();
680
 
    const CHARSET_INFO * const cs= charset();
 
863
    const charset_info_st * const cs= charset();
681
864
    cs->coll->hash_sort(cs, ptr, len, nr, nr2);
682
865
  }
683
866
}
697
880
int Field::store_and_check(enum_check_fields check_level,
698
881
                           const char *to, 
699
882
                           uint32_t length,
700
 
                           const CHARSET_INFO * const cs)
 
883
                           const charset_info_st * const cs)
701
884
 
702
885
{
703
886
  int res;
760
943
  return(result);
761
944
}
762
945
 
763
 
my_decimal *Field::val_decimal(my_decimal *)
 
946
type::Decimal *Field::val_decimal(type::Decimal *) const
764
947
{
765
948
  /* This never have to be called */
766
949
  assert(0);
795
978
  field->decimals= 0;
796
979
}
797
980
 
798
 
int64_t Field::convert_decimal2int64_t(const my_decimal *val, bool, int *err)
 
981
int64_t Field::convert_decimal2int64_t(const type::Decimal *val, bool, int *err)
799
982
{
800
983
  int64_t i;
801
 
  if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
 
984
  if (warn_if_overflow(val->val_int32(E_DEC_ERROR &
802
985
                                      ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
803
 
                                      val, false, &i)))
 
986
                                      false, &i)))
804
987
  {
805
988
    i= (val->sign() ? INT64_MIN : INT64_MAX);
806
989
    *err= 1;
818
1001
  {
819
1002
    copy->blob_field=(Field_blob*) this;
820
1003
    copy->strip=0;
821
 
    copy->length-= table->getShare()->blob_ptr_size;
 
1004
    copy->length-= table->getShare()->sizeBlobPtr();
822
1005
    return copy->length;
823
1006
  }
824
1007
  else
829
1012
  return copy->length+ store_length;
830
1013
}
831
1014
 
832
 
bool Field::get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
833
 
{
834
 
  char buff[40];
835
 
  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
 
  {
839
 
    return 1;
840
 
  }
841
 
 
842
 
  return 0;
843
 
}
844
 
 
845
 
bool Field::get_time(DRIZZLE_TIME *ltime)
846
 
{
847
 
  char buff[40];
848
 
  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
 
  {
852
 
    return 1;
853
 
  }
854
 
 
855
 
  return 0;
856
 
}
857
 
 
858
 
int Field::store_time(DRIZZLE_TIME *ltime, enum enum_drizzle_timestamp_type)
859
 
{
860
 
  char buff[MAX_DATE_STRING_REP_LENGTH];
861
 
  uint32_t length= (uint32_t) my_TIME_to_str(ltime, buff);
862
 
  return store(buff, length, &my_charset_bin);
 
1015
bool Field::get_date(type::Time &ltime, uint32_t fuzzydate) const
 
1016
{
 
1017
  char buff[type::Time::MAX_STRING_LENGTH];
 
1018
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
 
1019
 
 
1020
  assert(getTable() and getTable()->getSession());
 
1021
 
 
1022
  if (not (res= val_str_internal(&tmp)) or
 
1023
      str_to_datetime_with_warn(getTable()->getSession(),
 
1024
                                res->ptr(), res->length(),
 
1025
                                &ltime, fuzzydate) <= type::DRIZZLE_TIMESTAMP_ERROR)
 
1026
  {
 
1027
    return true;
 
1028
  }
 
1029
 
 
1030
  return false;
 
1031
}
 
1032
 
 
1033
bool Field::get_time(type::Time &ltime) const
 
1034
{
 
1035
  char buff[type::Time::MAX_STRING_LENGTH];
 
1036
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
 
1037
 
 
1038
  if (not (res= val_str_internal(&tmp)) or
 
1039
      str_to_time_with_warn(getTable()->getSession(), res->ptr(), res->length(), &ltime))
 
1040
  {
 
1041
    return true;
 
1042
  }
 
1043
 
 
1044
  return false;
 
1045
}
 
1046
 
 
1047
int Field::store_time(type::Time &ltime, type::timestamp_t)
 
1048
{
 
1049
  String tmp;
 
1050
 
 
1051
  ltime.convert(tmp);
 
1052
 
 
1053
  return store(tmp.ptr(), tmp.length(), &my_charset_bin);
863
1054
}
864
1055
 
865
1056
bool Field::optimize_range(uint32_t idx, uint32_t)
930
1121
{
931
1122
  if (!Field::eq_def(field))
932
1123
    return 0;
 
1124
 
933
1125
  TYPELIB *from_lib=((Field_enum*) field)->typelib;
934
1126
 
935
1127
  if (typelib->count < from_lib->count)
936
1128
    return 0;
 
1129
 
937
1130
  for (uint32_t i=0 ; i < from_lib->count ; i++)
 
1131
  {
938
1132
    if (my_strnncoll(field_charset,
939
1133
                     (const unsigned char*)typelib->type_names[i],
940
1134
                     strlen(typelib->type_names[i]),
941
1135
                     (const unsigned char*)from_lib->type_names[i],
942
1136
                     strlen(from_lib->type_names[i])))
943
1137
      return 0;
 
1138
  }
 
1139
 
944
1140
  return 1;
945
1141
}
946
1142
 
949
1145
  switch (type) {
950
1146
  case DRIZZLE_TYPE_VARCHAR: return (length + (length < 256 ? 1: 2));
951
1147
  case DRIZZLE_TYPE_UUID: return field::Uuid::max_string_length();
 
1148
  case DRIZZLE_TYPE_MICROTIME: return field::Microtime::max_string_length();
 
1149
  case DRIZZLE_TYPE_TIMESTAMP: return field::Epoch::max_string_length();
 
1150
  case DRIZZLE_TYPE_BOOLEAN: return field::Boolean::max_string_length();
952
1151
  case DRIZZLE_TYPE_DATE:
953
1152
  case DRIZZLE_TYPE_ENUM:
954
1153
  case DRIZZLE_TYPE_LONG: return 4;
955
1154
  case DRIZZLE_TYPE_DOUBLE: return sizeof(double);
 
1155
  case DRIZZLE_TYPE_TIME:
956
1156
  case DRIZZLE_TYPE_DATETIME:
957
 
  case DRIZZLE_TYPE_TIMESTAMP:
958
1157
  case DRIZZLE_TYPE_LONGLONG: return 8; /* Don't crash if no int64_t */
959
1158
  case DRIZZLE_TYPE_NULL: return 0;
960
1159
  case DRIZZLE_TYPE_BLOB: return 4 + portable_sizeof_char_ptr;
961
1160
  case DRIZZLE_TYPE_DECIMAL:
962
 
                          assert(0);
963
 
                          abort();
 
1161
                          break;
964
1162
  }
965
1163
 
966
1164
  assert(0);
984
1182
*****************************************************************************/
985
1183
 
986
1184
bool Field::set_warning(DRIZZLE_ERROR::enum_warning_level level,
987
 
                        uint32_t code,
 
1185
                        drizzled::error_t code,
988
1186
                        int cuted_increment)
989
1187
{
990
1188
  /*
1004
1202
 
1005
1203
 
1006
1204
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1007
 
                                 unsigned int code,
 
1205
                                 drizzled::error_t code,
1008
1206
                                 const char *str, 
1009
1207
                                 uint32_t str_length,
1010
 
                                 enum enum_drizzle_timestamp_type ts_type, 
 
1208
                                 type::timestamp_t ts_type, 
1011
1209
                                 int cuted_increment)
1012
1210
{
1013
 
  Session *session= table ? table->in_use : current_session;
1014
 
  if ((session->really_abort_on_warning() &&
 
1211
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
 
1212
 
 
1213
  if ((session->abortOnWarning() and
1015
1214
       level >= DRIZZLE_ERROR::WARN_LEVEL_WARN) ||
1016
1215
      set_warning(level, code, cuted_increment))
1017
1216
    make_truncated_value_warning(session, level, str, str_length, ts_type,
1019
1218
}
1020
1219
 
1021
1220
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, 
1022
 
                                 uint32_t code,
 
1221
                                 drizzled::error_t code,
1023
1222
                                 int64_t nr, 
1024
 
                                 enum enum_drizzle_timestamp_type ts_type,
 
1223
                                 type::timestamp_t ts_type,
1025
1224
                                 int cuted_increment)
1026
1225
{
1027
 
  Session *session= table ? table->in_use : current_session;
1028
 
  if (session->really_abort_on_warning() ||
 
1226
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
 
1227
 
 
1228
  if (session->abortOnWarning() or
1029
1229
      set_warning(level, code, cuted_increment))
1030
1230
  {
1031
 
    char str_nr[22];
 
1231
    char str_nr[DECIMAL_LONGLONG_DIGITS];
1032
1232
    char *str_end= internal::int64_t10_to_str(nr, str_nr, -10);
1033
1233
    make_truncated_value_warning(session, level, str_nr, (uint32_t) (str_end - str_nr),
1034
1234
                                 ts_type, field_name);
1036
1236
}
1037
1237
 
1038
1238
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1039
 
                                 const uint32_t code,
 
1239
                                 const drizzled::error_t code,
1040
1240
                                 double nr, 
1041
 
                                 enum enum_drizzle_timestamp_type ts_type)
 
1241
                                 type::timestamp_t ts_type)
1042
1242
{
1043
 
  Session *session= table ? table->in_use : current_session;
1044
 
  if (session->really_abort_on_warning() ||
 
1243
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
 
1244
 
 
1245
  if (session->abortOnWarning() or
1045
1246
      set_warning(level, code, 1))
1046
1247
  {
1047
1248
    /* DBL_DIG is enough to print '-[digits].E+###' */
1052
1253
  }
1053
1254
}
1054
1255
 
1055
 
bool Field::isReadSet() 
 
1256
bool Field::isReadSet() const 
1056
1257
{ 
1057
1258
  return table->isReadSet(field_index); 
1058
1259
}
1078
1279
    table->clearWriteSet(field_index);
1079
1280
}
1080
1281
 
 
1282
void Field::pack_num(uint64_t arg, unsigned char *destination)
 
1283
{
 
1284
  if (not destination)
 
1285
    destination= ptr;
 
1286
 
 
1287
  int64_tstore(destination, arg);
 
1288
}
 
1289
 
 
1290
void Field::pack_num(uint32_t arg, unsigned char *destination)
 
1291
{
 
1292
  if (not destination)
 
1293
    destination= ptr;
 
1294
 
 
1295
  longstore(destination, arg);
 
1296
}
 
1297
 
 
1298
uint64_t Field::unpack_num(uint64_t &destination, const unsigned char *arg) const
 
1299
{
 
1300
  if (not arg)
 
1301
    arg= ptr;
 
1302
 
 
1303
  int64_tget(destination, arg);
 
1304
 
 
1305
  return destination;
 
1306
}
 
1307
 
 
1308
uint32_t Field::unpack_num(uint32_t &destination, const unsigned char *arg) const
 
1309
{
 
1310
  if (not arg)
 
1311
    arg= ptr;
 
1312
 
 
1313
  longget(destination, arg);
 
1314
 
 
1315
  return destination;
 
1316
}
 
1317
 
1081
1318
std::ostream& operator<<(std::ostream& output, const Field &field)
1082
1319
{
1083
1320
  output << "Field:(";
1084
1321
  output <<  field.field_name;
1085
1322
  output << ", ";
1086
1323
  output << drizzled::display::type(field.real_type());
 
1324
  output << ", { ";
 
1325
 
 
1326
  if (field.flags & NOT_NULL_FLAG)
 
1327
    output << " NOT_NULL";
 
1328
 
 
1329
  if (field.flags & PRI_KEY_FLAG)
 
1330
    output << ", PRIMARY KEY";
 
1331
 
 
1332
  if (field.flags & UNIQUE_KEY_FLAG)
 
1333
    output << ", UNIQUE KEY";
 
1334
 
 
1335
  if (field.flags & MULTIPLE_KEY_FLAG)
 
1336
    output << ", MULTIPLE KEY";
 
1337
 
 
1338
  if (field.flags & BLOB_FLAG)
 
1339
    output << ", BLOB";
 
1340
 
 
1341
  if (field.flags & UNSIGNED_FLAG)
 
1342
    output << ", UNSIGNED";
 
1343
 
 
1344
  if (field.flags & BINARY_FLAG)
 
1345
    output << ", BINARY";
 
1346
  output << "}, ";
1087
1347
  output << ")";
1088
1348
 
1089
1349
  return output;  // for multiple << operators.