← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.cc

  • Committer: Olaf van der Spek
  • Date: 2011-02-12 18:24:24 UTC
  • mto: (2167.1.2 build) (2172.1.4 build)
  • mto: This revision was merged to the branch mainline in revision 2168.
  • Revision ID: olafvdspek@gmail.com-20110212182424-kgnm9osi7qo97at2
casts

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
23
24
 */
24
25
 
25
26
#include "config.h"
 
27
#include <cstdio>
26
28
#include <errno.h>
27
29
#include <float.h>
28
30
#include "drizzled/sql_select.h"
30
32
#include "drizzled/field/str.h"
31
33
#include "drizzled/field/num.h"
32
34
#include "drizzled/field/blob.h"
 
35
#include "drizzled/field/boolean.h"
33
36
#include "drizzled/field/enum.h"
34
37
#include "drizzled/field/null.h"
35
38
#include "drizzled/field/date.h"
36
39
#include "drizzled/field/decimal.h"
37
40
#include "drizzled/field/real.h"
38
41
#include "drizzled/field/double.h"
39
 
#include "drizzled/field/long.h"
40
 
#include "drizzled/field/int64_t.h"
 
42
#include "drizzled/field/int32.h"
 
43
#include "drizzled/field/int64.h"
41
44
#include "drizzled/field/num.h"
42
 
#include "drizzled/field/timestamp.h"
 
45
#include "drizzled/field/time.h"
 
46
#include "drizzled/field/epoch.h"
43
47
#include "drizzled/field/datetime.h"
 
48
#include "drizzled/field/microtime.h"
44
49
#include "drizzled/field/varstring.h"
 
50
#include "drizzled/field/uuid.h"
45
51
#include "drizzled/time_functions.h"
46
52
#include "drizzled/internal/m_string.h"
47
53
 
 
54
#include "drizzled/display.h"
 
55
 
48
56
namespace drizzled
49
57
{
50
58
 
53
61
*****************************************************************************/
54
62
 
55
63
static enum_field_types
56
 
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]=
57
65
{
58
66
  /* DRIZZLE_TYPE_LONG -> */
59
67
  {
79
87
    DRIZZLE_TYPE_VARCHAR,
80
88
    //DRIZZLE_TYPE_BLOB
81
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,
82
98
  },
83
99
  /* DRIZZLE_TYPE_DOUBLE -> */
84
100
  {
104
120
    DRIZZLE_TYPE_VARCHAR,
105
121
    //DRIZZLE_TYPE_BLOB
106
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,
107
131
  },
108
132
  /* DRIZZLE_TYPE_NULL -> */
109
133
  {
129
153
    DRIZZLE_TYPE_ENUM,
130
154
    //DRIZZLE_TYPE_BLOB
131
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,
132
164
  },
133
165
  /* DRIZZLE_TYPE_TIMESTAMP -> */
134
166
  {
154
186
    DRIZZLE_TYPE_VARCHAR,
155
187
    //DRIZZLE_TYPE_BLOB
156
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,
157
197
  },
158
198
  /* DRIZZLE_TYPE_LONGLONG -> */
159
199
  {
178
218
    DRIZZLE_TYPE_VARCHAR,
179
219
    //DRIZZLE_TYPE_BLOB
180
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,
181
229
  },
182
230
  /* DRIZZLE_TYPE_DATETIME -> */
183
231
  {
203
251
    DRIZZLE_TYPE_VARCHAR,
204
252
    //DRIZZLE_TYPE_BLOB
205
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,
206
262
  },
207
263
  /* DRIZZLE_TYPE_DATE -> */
208
264
  {
228
284
    DRIZZLE_TYPE_VARCHAR,
229
285
    //DRIZZLE_TYPE_BLOB
230
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,
231
295
  },
232
296
  /* DRIZZLE_TYPE_VARCHAR -> */
233
297
  {
253
317
    DRIZZLE_TYPE_VARCHAR,
254
318
    //DRIZZLE_TYPE_BLOB
255
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,
256
328
  },
257
329
  /* DRIZZLE_TYPE_DECIMAL -> */
258
330
  {
278
350
    DRIZZLE_TYPE_VARCHAR,
279
351
    //DRIZZLE_TYPE_BLOB
280
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,
281
361
  },
282
362
  /* DRIZZLE_TYPE_ENUM -> */
283
363
  {
303
383
    DRIZZLE_TYPE_VARCHAR,
304
384
    //DRIZZLE_TYPE_BLOB
305
385
    DRIZZLE_TYPE_BLOB,
306
 
  },
 
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
  /* DRIZZLE_TYPE_BLOB -> */
308
396
  {
309
397
    //DRIZZLE_TYPE_LONG
328
416
    DRIZZLE_TYPE_BLOB,
329
417
    //DRIZZLE_TYPE_BLOB
330
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,
331
559
  },
332
560
};
333
561
 
334
 
static Item_result field_types_result_type [DRIZZLE_TYPE_MAX+1]=
 
562
static Item_result field_types_result_type [enum_field_types_size]=
335
563
{
336
564
  //DRIZZLE_TYPE_LONG
337
565
  INT_RESULT,
355
583
  STRING_RESULT,
356
584
  //DRIZZLE_TYPE_BLOB
357
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,
358
594
};
359
595
 
360
596
bool test_if_important_data(const CHARSET_INFO * const cs, 
373
609
 
374
610
void *Field::operator new(size_t size, memory::Root *mem_root)
375
611
{
376
 
  return alloc_root(mem_root, static_cast<uint32_t>(size));
 
612
  return mem_root->alloc_root(static_cast<uint32_t>(size));
377
613
}
378
614
 
379
615
enum_field_types Field::field_type_merge(enum_field_types a,
380
616
                                         enum_field_types b)
381
617
{
382
 
  assert(a <= DRIZZLE_TYPE_MAX);
383
 
  assert(b <= DRIZZLE_TYPE_MAX);
 
618
  assert(a < enum_field_types_size);
 
619
  assert(b < enum_field_types_size);
384
620
  return field_types_merge_rules[a][b];
385
621
}
386
622
 
387
623
Item_result Field::result_merge_type(enum_field_types field_type)
388
624
{
389
 
  assert(field_type <= DRIZZLE_TYPE_MAX);
 
625
  assert(field_type < enum_field_types_size);
390
626
  return field_types_result_type[field_type];
391
627
}
392
628
 
437
673
 
438
674
void Field::set_default()
439
675
{
440
 
  ptrdiff_t l_offset= (ptrdiff_t) (table->getDefaultValues() - table->record[0]);
 
676
  ptrdiff_t l_offset= (ptrdiff_t) (table->getDefaultValues() - table->getInsertRecord());
441
677
  memcpy(ptr, ptr + l_offset, pack_length());
442
678
  if (null_ptr)
443
679
    *null_ptr= ((*null_ptr & (unsigned char) ~null_bit) | (null_ptr[l_offset] & null_bit));
522
758
{
523
759
  if (! null_ptr)
524
760
    return false;
525
 
  return test(record[(uint32_t) (null_ptr -table->record[0])] & null_bit);
 
761
  return test(record[(uint32_t) (null_ptr -table->getInsertRecord())] & null_bit);
526
762
}
527
763
 
528
764
bool Field::is_null_in_record_with_offset(ptrdiff_t with_offset)
583
819
void Field::init(Table *table_arg)
584
820
{
585
821
  orig_table= table= table_arg;
586
 
  table_name= &table_arg->alias;
587
822
}
588
823
 
589
824
/// This is used as a table name when the table structure is not set up
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
 
    table_name(NULL),
602
835
    field_name(field_name_arg),
 
836
    comment(NULL_LEX_STRING),
603
837
    key_start(0),
604
838
    part_of_key(0),
605
839
    part_of_key_not_clustered(0),
606
840
    part_of_sortkey(0),
607
841
    unireg_check(unireg_check_arg),
608
842
    field_length(length_arg),
 
843
    flags(null_ptr ? 0: NOT_NULL_FLAG),
 
844
    field_index(0),
609
845
    null_bit(null_bit_arg),
610
846
    is_created_from_null_item(false)
611
847
{
612
 
  flags= null_ptr ? 0: NOT_NULL_FLAG;
613
 
  comment.str= (char*) "";
614
 
  comment.length= 0;
615
 
  field_index= 0;
616
848
}
617
849
 
618
850
void Field::hash(uint32_t *nr, uint32_t *nr2)
641
873
  }
642
874
}
643
875
 
644
 
int Field::store(const char *to, 
645
 
                 uint32_t length,
646
 
                 const CHARSET_INFO * const cs,
647
 
                 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
 
648
881
{
649
882
  int res;
650
883
  enum_check_fields old_check_level= table->in_use->count_cuted_fields;
664
897
 
665
898
unsigned char *Field::pack(unsigned char *to, const unsigned char *from)
666
899
{
667
 
  unsigned char *result= this->pack(to, from, UINT32_MAX, table->s->db_low_byte_first);
 
900
  unsigned char *result= this->pack(to, from, UINT32_MAX, table->getShare()->db_low_byte_first);
668
901
  return(result);
669
902
}
670
903
 
702
935
 
703
936
const unsigned char *Field::unpack(unsigned char* to, const unsigned char *from)
704
937
{
705
 
  const unsigned char *result= unpack(to, from, 0U, table->s->db_low_byte_first);
 
938
  const unsigned char *result= unpack(to, from, 0U, table->getShare()->db_low_byte_first);
706
939
  return(result);
707
940
}
708
941
 
709
 
my_decimal *Field::val_decimal(my_decimal *)
 
942
type::Decimal *Field::val_decimal(type::Decimal *)
710
943
{
711
944
  /* This never have to be called */
712
945
  assert(0);
716
949
 
717
950
void Field::make_field(SendField *field)
718
951
{
719
 
  if (orig_table && orig_table->s->getSchemaName() && *orig_table->s->getSchemaName())
 
952
  if (orig_table && orig_table->getShare()->getSchemaName() && *orig_table->getShare()->getSchemaName())
720
953
  {
721
 
    field->db_name= orig_table->s->getSchemaName();
722
 
    field->org_table_name= orig_table->s->table_name.str;
 
954
    field->db_name= orig_table->getShare()->getSchemaName();
 
955
    field->org_table_name= orig_table->getShare()->getTableName();
723
956
  }
724
957
  else
725
958
    field->org_table_name= field->db_name= "";
726
959
  if (orig_table)
727
960
  {
728
 
    field->table_name= orig_table->alias;
 
961
    field->table_name= orig_table->getAlias();
729
962
    field->org_col_name= field_name;
730
963
  }
731
964
  else
741
974
  field->decimals= 0;
742
975
}
743
976
 
744
 
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)
745
978
{
746
979
  int64_t i;
747
 
  if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
 
980
  if (warn_if_overflow(val->val_int32(E_DEC_ERROR &
748
981
                                      ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
749
 
                                      val, false, &i)))
 
982
                                      false, &i)))
750
983
  {
751
984
    i= (val->sign() ? INT64_MIN : INT64_MAX);
752
985
    *err= 1;
754
987
  return i;
755
988
}
756
989
 
757
 
uint32_t Field::fill_cache_field(CACHE_FIELD *copy)
 
990
uint32_t Field::fill_cache_field(CacheField *copy)
758
991
{
759
992
  uint32_t store_length;
760
993
  copy->str=ptr;
764
997
  {
765
998
    copy->blob_field=(Field_blob*) this;
766
999
    copy->strip=0;
767
 
    copy->length-= table->s->blob_ptr_size;
 
1000
    copy->length-= table->getShare()->sizeBlobPtr();
768
1001
    return copy->length;
769
1002
  }
770
1003
  else
775
1008
  return copy->length+ store_length;
776
1009
}
777
1010
 
778
 
bool Field::get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
779
 
{
780
 
  char buff[40];
781
 
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
782
 
  if (!(res=val_str(&tmp)) ||
783
 
      str_to_datetime_with_warn(res->ptr(), res->length(),
784
 
                                ltime, fuzzydate) <= DRIZZLE_TIMESTAMP_ERROR)
785
 
    return 1;
786
 
  return 0;
787
 
}
788
 
 
789
 
bool Field::get_time(DRIZZLE_TIME *ltime)
790
 
{
791
 
  char buff[40];
792
 
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
793
 
  if (!(res=val_str(&tmp)) ||
794
 
      str_to_time_with_warn(res->ptr(), res->length(), ltime))
795
 
    return 1;
796
 
  return 0;
797
 
}
798
 
 
799
 
int Field::store_time(DRIZZLE_TIME *ltime, enum enum_drizzle_timestamp_type)
800
 
{
801
 
  char buff[MAX_DATE_STRING_REP_LENGTH];
802
 
  uint32_t length= (uint32_t) my_TIME_to_str(ltime, buff);
803
 
  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);
804
1050
}
805
1051
 
806
1052
bool Field::optimize_range(uint32_t idx, uint32_t)
811
1057
Field *Field::new_field(memory::Root *root, Table *new_table, bool)
812
1058
{
813
1059
  Field *tmp;
814
 
  if (!(tmp= (Field*) memdup_root(root,(char*) this,size_of())))
 
1060
  if (!(tmp= (Field*) root->memdup_root((char*) this,size_of())))
815
1061
    return 0;
816
1062
 
817
1063
  if (tmp->table->maybe_null)
844
1090
Field *Field::clone(memory::Root *root, Table *new_table)
845
1091
{
846
1092
  Field *tmp;
847
 
  if ((tmp= (Field*) memdup_root(root,(char*) this,size_of())))
 
1093
  if ((tmp= (Field*) root->memdup_root((char*) this,size_of())))
848
1094
  {
849
1095
    tmp->init(new_table);
850
 
    tmp->move_field_offset((ptrdiff_t) (new_table->record[0] -
851
 
                                           new_table->s->default_values));
 
1096
    tmp->move_field_offset((ptrdiff_t) (new_table->getInsertRecord() -
 
1097
                                           new_table->getDefaultValues()));
852
1098
  }
853
1099
  return tmp;
854
1100
}
871
1117
{
872
1118
  if (!Field::eq_def(field))
873
1119
    return 0;
 
1120
 
874
1121
  TYPELIB *from_lib=((Field_enum*) field)->typelib;
875
1122
 
876
1123
  if (typelib->count < from_lib->count)
877
1124
    return 0;
 
1125
 
878
1126
  for (uint32_t i=0 ; i < from_lib->count ; i++)
 
1127
  {
879
1128
    if (my_strnncoll(field_charset,
880
1129
                     (const unsigned char*)typelib->type_names[i],
881
1130
                     strlen(typelib->type_names[i]),
882
1131
                     (const unsigned char*)from_lib->type_names[i],
883
1132
                     strlen(from_lib->type_names[i])))
884
1133
      return 0;
 
1134
  }
 
1135
 
885
1136
  return 1;
886
1137
}
887
1138
 
889
1140
{
890
1141
  switch (type) {
891
1142
  case DRIZZLE_TYPE_VARCHAR: return (length + (length < 256 ? 1: 2));
892
 
  case DRIZZLE_TYPE_DATE: return 3;
893
 
  case DRIZZLE_TYPE_TIMESTAMP:
 
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
  case DRIZZLE_TYPE_DATE:
 
1148
  case DRIZZLE_TYPE_ENUM:
894
1149
  case DRIZZLE_TYPE_LONG: return 4;
895
1150
  case DRIZZLE_TYPE_DOUBLE: return sizeof(double);
 
1151
  case DRIZZLE_TYPE_TIME:
896
1152
  case DRIZZLE_TYPE_DATETIME:
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
 
  case DRIZZLE_TYPE_ENUM:
901
1156
  case DRIZZLE_TYPE_DECIMAL:
902
 
    abort();
903
 
  default:
904
 
    return 0;
 
1157
                          break;
905
1158
  }
 
1159
 
 
1160
  assert(0);
 
1161
  abort();
906
1162
}
907
1163
 
908
1164
uint32_t pack_length_to_packflag(uint32_t type)
911
1167
    case 1: return 1 << FIELDFLAG_PACK_SHIFT;
912
1168
    case 2: assert(1);
913
1169
    case 3: assert(1);
914
 
    case 4: return f_settype((uint32_t) DRIZZLE_TYPE_LONG);
915
 
    case 8: return f_settype((uint32_t) DRIZZLE_TYPE_LONGLONG);
 
1170
    case 4: return f_settype(DRIZZLE_TYPE_LONG);
 
1171
    case 8: return f_settype(DRIZZLE_TYPE_LONGLONG);
916
1172
  }
917
1173
  return 0;                                     // This shouldn't happen
918
1174
}
919
1175
 
920
 
Field *make_field(TableShare *share,
921
 
                  memory::Root *root,
922
 
                  unsigned char *ptr,
923
 
                  uint32_t field_length,
924
 
                  bool is_nullable,
925
 
                  unsigned char *null_pos,
926
 
                  unsigned char null_bit,
927
 
                  uint8_t decimals,
928
 
                  enum_field_types field_type,
929
 
                  const CHARSET_INFO * field_charset,
930
 
                  Field::utype unireg_check,
931
 
                  TYPELIB *interval,
932
 
                  const char *field_name)
933
 
{
934
 
  if(! root)
935
 
    root= current_mem_root();
936
 
 
937
 
  if (! is_nullable)
938
 
  {
939
 
    null_pos=0;
940
 
    null_bit=0;
941
 
  }
942
 
  else
943
 
  {
944
 
    null_bit= ((unsigned char) 1) << null_bit;
945
 
  }
946
 
 
947
 
  switch (field_type) 
948
 
  {
949
 
  case DRIZZLE_TYPE_DATE:
950
 
  case DRIZZLE_TYPE_DATETIME:
951
 
  case DRIZZLE_TYPE_TIMESTAMP:
952
 
    field_charset= &my_charset_bin;
953
 
  default: break;
954
 
  }
955
 
 
956
 
  if (field_type == DRIZZLE_TYPE_VARCHAR ||
957
 
      field_type == DRIZZLE_TYPE_BLOB ||
958
 
      field_type == DRIZZLE_TYPE_ENUM)
959
 
  {
960
 
    if (field_type == DRIZZLE_TYPE_VARCHAR)
961
 
      return new (root) Field_varstring(ptr,field_length,
962
 
                                  HA_VARCHAR_PACKLENGTH(field_length),
963
 
                                  null_pos,null_bit,
964
 
                                  field_name,
965
 
                                  share,
966
 
                                  field_charset);
967
 
 
968
 
    if (field_type == DRIZZLE_TYPE_BLOB)
969
 
    {
970
 
      return new (root) Field_blob(ptr,
971
 
                                   null_pos,
972
 
                                   null_bit,
973
 
                                   field_name,
974
 
                                   share,
975
 
                                   calc_pack_length(DRIZZLE_TYPE_LONG, 0),
976
 
                                   field_charset);
977
 
    }
978
 
 
979
 
    if (interval)
980
 
    {
981
 
      return new (root) Field_enum(ptr,
982
 
                                   field_length,
983
 
                                   null_pos,
984
 
                                   null_bit,
985
 
                                   field_name,
986
 
                                   get_enum_pack_length(interval->count),
987
 
                                   interval,
988
 
                                   field_charset);
989
 
    }
990
 
  }
991
 
 
992
 
  switch (field_type)
993
 
  {
994
 
  case DRIZZLE_TYPE_DECIMAL:
995
 
    return new (root) Field_decimal(ptr,
996
 
                                    field_length,
997
 
                                    null_pos,
998
 
                                    null_bit,
999
 
                                    unireg_check,
1000
 
                                    field_name,
1001
 
                                    decimals,
1002
 
                                    false,
1003
 
                                    false /* is_unsigned */);
1004
 
  case DRIZZLE_TYPE_DOUBLE:
1005
 
    return new (root) Field_double(ptr,
1006
 
                                   field_length,
1007
 
                                   null_pos,
1008
 
                                   null_bit,
1009
 
                                   unireg_check,
1010
 
                                   field_name,
1011
 
                                   decimals,
1012
 
                                   false,
1013
 
                                   false /* is_unsigned */);
1014
 
  case DRIZZLE_TYPE_LONG:
1015
 
    return new (root) Field_long(ptr,
1016
 
                                 field_length,
1017
 
                                 null_pos,
1018
 
                                 null_bit,
1019
 
                                 unireg_check,
1020
 
                                 field_name,
1021
 
                                 false,
1022
 
                                 false /* is_unsigned */);
1023
 
  case DRIZZLE_TYPE_LONGLONG:
1024
 
    return new (root) Field_int64_t(ptr,
1025
 
                                    field_length,
1026
 
                                    null_pos,
1027
 
                                    null_bit,
1028
 
                                    unireg_check,
1029
 
                                    field_name,
1030
 
                                    false,
1031
 
                                    false /* is_unsigned */);
1032
 
  case DRIZZLE_TYPE_TIMESTAMP:
1033
 
    return new (root) Field_timestamp(ptr,
1034
 
                                      field_length,
1035
 
                                      null_pos,
1036
 
                                      null_bit,
1037
 
                                      unireg_check,
1038
 
                                      field_name,
1039
 
                                      share,
1040
 
                                      field_charset);
1041
 
  case DRIZZLE_TYPE_DATE:
1042
 
    return new (root) Field_date(ptr,
1043
 
                                 null_pos,
1044
 
                                 null_bit,
1045
 
                                 field_name,
1046
 
                                 field_charset);
1047
 
  case DRIZZLE_TYPE_DATETIME:
1048
 
    return new (root) Field_datetime(ptr,
1049
 
                                     null_pos,
1050
 
                                     null_bit,
1051
 
                                     field_name,
1052
 
                                     field_charset);
1053
 
  case DRIZZLE_TYPE_NULL:
1054
 
    return new (root) Field_null(ptr,
1055
 
                                 field_length,
1056
 
                                 field_name,
1057
 
                                 field_charset);
1058
 
  default: // Impossible (Wrong version)
1059
 
    break;
1060
 
  }
1061
 
  return 0;
1062
 
}
1063
 
 
1064
1176
/*****************************************************************************
1065
1177
 Warning handling
1066
1178
*****************************************************************************/
1067
1179
 
1068
1180
bool Field::set_warning(DRIZZLE_ERROR::enum_warning_level level,
1069
 
                        uint32_t code,
 
1181
                        drizzled::error_t code,
1070
1182
                        int cuted_increment)
1071
1183
{
1072
1184
  /*
1086
1198
 
1087
1199
 
1088
1200
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1089
 
                                 unsigned int code,
 
1201
                                 drizzled::error_t code,
1090
1202
                                 const char *str, 
1091
1203
                                 uint32_t str_length,
1092
 
                                 enum enum_drizzle_timestamp_type ts_type, 
 
1204
                                 type::timestamp_t ts_type, 
1093
1205
                                 int cuted_increment)
1094
1206
{
1095
 
  Session *session= table ? table->in_use : current_session;
1096
 
  if ((session->really_abort_on_warning() &&
 
1207
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
 
1208
 
 
1209
  if ((session->abortOnWarning() and
1097
1210
       level >= DRIZZLE_ERROR::WARN_LEVEL_WARN) ||
1098
1211
      set_warning(level, code, cuted_increment))
1099
1212
    make_truncated_value_warning(session, level, str, str_length, ts_type,
1101
1214
}
1102
1215
 
1103
1216
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, 
1104
 
                                 uint32_t code,
 
1217
                                 drizzled::error_t code,
1105
1218
                                 int64_t nr, 
1106
 
                                 enum enum_drizzle_timestamp_type ts_type,
 
1219
                                 type::timestamp_t ts_type,
1107
1220
                                 int cuted_increment)
1108
1221
{
1109
 
  Session *session= table ? table->in_use : current_session;
1110
 
  if (session->really_abort_on_warning() ||
 
1222
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
 
1223
 
 
1224
  if (session->abortOnWarning() or
1111
1225
      set_warning(level, code, cuted_increment))
1112
1226
  {
1113
 
    char str_nr[22];
 
1227
    char str_nr[DECIMAL_LONGLONG_DIGITS];
1114
1228
    char *str_end= internal::int64_t10_to_str(nr, str_nr, -10);
1115
1229
    make_truncated_value_warning(session, level, str_nr, (uint32_t) (str_end - str_nr),
1116
1230
                                 ts_type, field_name);
1118
1232
}
1119
1233
 
1120
1234
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1121
 
                                 const uint32_t code,
 
1235
                                 const drizzled::error_t code,
1122
1236
                                 double nr, 
1123
 
                                 enum enum_drizzle_timestamp_type ts_type)
 
1237
                                 type::timestamp_t ts_type)
1124
1238
{
1125
 
  Session *session= table ? table->in_use : current_session;
1126
 
  if (session->really_abort_on_warning() ||
 
1239
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
 
1240
 
 
1241
  if (session->abortOnWarning() or
1127
1242
      set_warning(level, code, 1))
1128
1243
  {
1129
1244
    /* DBL_DIG is enough to print '-[digits].E+###' */
1160
1275
    table->clearWriteSet(field_index);
1161
1276
}
1162
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
 
1163
1348
} /* namespace drizzled */