← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.cc

  • Committer: Jay Pipes
  • Date: 2010-03-09 20:02:29 UTC
  • mto: This revision was merged to the branch mainline in revision 1339.
  • Revision ID: jpipes@serialcoder-20100309200229-dfrliy4fads9vyf4
https://launchpad.net/bugs/535296
Fixes Bug #535296 by only incrementing ha_commit_count when its a normal transaction commit.

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
23
22
 * @file This file implements the Field class and API
24
23
 */
25
24
 
26
 
#include <config.h>
27
 
#include <cstdio>
 
25
#include "config.h"
28
26
#include <errno.h>
29
27
#include <float.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>
 
28
#include "drizzled/sql_select.h"
 
29
#include "drizzled/error.h"
 
30
#include "drizzled/field/str.h"
 
31
#include "drizzled/field/num.h"
 
32
#include "drizzled/field/blob.h"
 
33
#include "drizzled/field/enum.h"
 
34
#include "drizzled/field/null.h"
 
35
#include "drizzled/field/date.h"
 
36
#include "drizzled/field/decimal.h"
 
37
#include "drizzled/field/real.h"
 
38
#include "drizzled/field/double.h"
 
39
#include "drizzled/field/long.h"
 
40
#include "drizzled/field/int64_t.h"
 
41
#include "drizzled/field/num.h"
 
42
#include "drizzled/field/timestamp.h"
 
43
#include "drizzled/field/datetime.h"
 
44
#include "drizzled/field/varstring.h"
 
45
#include "drizzled/time_functions.h"
 
46
#include "drizzled/internal/m_string.h"
59
47
 
60
48
namespace drizzled
61
49
{
65
53
*****************************************************************************/
66
54
 
67
55
static enum_field_types
68
 
field_types_merge_rules [enum_field_types_size][enum_field_types_size]=
 
56
field_types_merge_rules [DRIZZLE_TYPE_MAX+1][DRIZZLE_TYPE_MAX+1]=
69
57
{
70
58
  /* DRIZZLE_TYPE_LONG -> */
71
59
  {
91
79
    DRIZZLE_TYPE_VARCHAR,
92
80
    //DRIZZLE_TYPE_BLOB
93
81
    DRIZZLE_TYPE_BLOB,
94
 
    //DRIZZLE_TYPE_TIME
95
 
    DRIZZLE_TYPE_TIME,
96
 
    //DRIZZLE_TYPE_BOOLEAN
97
 
    DRIZZLE_TYPE_VARCHAR,
98
 
    //DRIZZLE_TYPE_UUID
99
 
    DRIZZLE_TYPE_VARCHAR,
100
 
    //DRIZZLE_TYPE_MICROTIME
101
 
    DRIZZLE_TYPE_VARCHAR,
102
82
  },
103
83
  /* DRIZZLE_TYPE_DOUBLE -> */
104
84
  {
124
104
    DRIZZLE_TYPE_VARCHAR,
125
105
    //DRIZZLE_TYPE_BLOB
126
106
    DRIZZLE_TYPE_BLOB,
127
 
    //DRIZZLE_TYPE_TIME
128
 
    DRIZZLE_TYPE_TIME,
129
 
    //DRIZZLE_TYPE_BOOLEAN
130
 
    DRIZZLE_TYPE_VARCHAR,
131
 
    //DRIZZLE_TYPE_UUID
132
 
    DRIZZLE_TYPE_VARCHAR,
133
 
    //DRIZZLE_TYPE_MICROTIME
134
 
    DRIZZLE_TYPE_VARCHAR,
135
107
  },
136
108
  /* DRIZZLE_TYPE_NULL -> */
137
109
  {
157
129
    DRIZZLE_TYPE_ENUM,
158
130
    //DRIZZLE_TYPE_BLOB
159
131
    DRIZZLE_TYPE_BLOB,
160
 
    //DRIZZLE_TYPE_TIME
161
 
    DRIZZLE_TYPE_TIME,
162
 
    //DRIZZLE_TYPE_BOOLEAN
163
 
    DRIZZLE_TYPE_BOOLEAN,
164
 
    //DRIZZLE_TYPE_UUID
165
 
    DRIZZLE_TYPE_UUID,
166
 
    //DRIZZLE_TYPE_MICROTIME
167
 
    DRIZZLE_TYPE_MICROTIME,
168
132
  },
169
133
  /* DRIZZLE_TYPE_TIMESTAMP -> */
170
134
  {
190
154
    DRIZZLE_TYPE_VARCHAR,
191
155
    //DRIZZLE_TYPE_BLOB
192
156
    DRIZZLE_TYPE_BLOB,
193
 
    //DRIZZLE_TYPE_TIME
194
 
    DRIZZLE_TYPE_TIME,
195
 
    //DRIZZLE_TYPE_BOOLEAN
196
 
    DRIZZLE_TYPE_VARCHAR,
197
 
    //DRIZZLE_TYPE_UUID
198
 
    DRIZZLE_TYPE_VARCHAR,
199
 
    //DRIZZLE_TYPE_MICROTIME
200
 
    DRIZZLE_TYPE_VARCHAR,
201
157
  },
202
158
  /* DRIZZLE_TYPE_LONGLONG -> */
203
159
  {
222
178
    DRIZZLE_TYPE_VARCHAR,
223
179
    //DRIZZLE_TYPE_BLOB
224
180
    DRIZZLE_TYPE_BLOB,
225
 
    //DRIZZLE_TYPE_TIME
226
 
    DRIZZLE_TYPE_TIME,
227
 
    //DRIZZLE_TYPE_BOOLEAN
228
 
    DRIZZLE_TYPE_VARCHAR,
229
 
    //DRIZZLE_TYPE_UUID
230
 
    DRIZZLE_TYPE_VARCHAR,
231
 
    //DRIZZLE_TYPE_MICROTIME
232
 
    DRIZZLE_TYPE_VARCHAR,
233
181
  },
234
182
  /* DRIZZLE_TYPE_DATETIME -> */
235
183
  {
255
203
    DRIZZLE_TYPE_VARCHAR,
256
204
    //DRIZZLE_TYPE_BLOB
257
205
    DRIZZLE_TYPE_BLOB,
258
 
    //DRIZZLE_TYPE_TIME
259
 
    DRIZZLE_TYPE_TIME,
260
 
    //DRIZZLE_TYPE_BOOLEAN
261
 
    DRIZZLE_TYPE_VARCHAR,
262
 
    //DRIZZLE_TYPE_UUID
263
 
    DRIZZLE_TYPE_VARCHAR,
264
 
    //DRIZZLE_TYPE_MICROTIME
265
 
    DRIZZLE_TYPE_VARCHAR,
266
206
  },
267
207
  /* DRIZZLE_TYPE_DATE -> */
268
208
  {
288
228
    DRIZZLE_TYPE_VARCHAR,
289
229
    //DRIZZLE_TYPE_BLOB
290
230
    DRIZZLE_TYPE_BLOB,
291
 
    //DRIZZLE_TYPE_TIME
292
 
    DRIZZLE_TYPE_TIME,
293
 
    //DRIZZLE_TYPE_BOOLEAN
294
 
    DRIZZLE_TYPE_VARCHAR,
295
 
    //DRIZZLE_TYPE_UUID
296
 
    DRIZZLE_TYPE_VARCHAR,
297
 
    //DRIZZLE_TYPE_MICROTIME
298
 
    DRIZZLE_TYPE_VARCHAR,
299
231
  },
300
232
  /* DRIZZLE_TYPE_VARCHAR -> */
301
233
  {
321
253
    DRIZZLE_TYPE_VARCHAR,
322
254
    //DRIZZLE_TYPE_BLOB
323
255
    DRIZZLE_TYPE_BLOB,
324
 
    //DRIZZLE_TYPE_TIME
325
 
    DRIZZLE_TYPE_TIME,
326
 
    //DRIZZLE_TYPE_BOOLEAN
327
 
    DRIZZLE_TYPE_VARCHAR,
328
 
    //DRIZZLE_TYPE_UUID
329
 
    DRIZZLE_TYPE_VARCHAR,
330
 
    //DRIZZLE_TYPE_MICROTIME
331
 
    DRIZZLE_TYPE_VARCHAR,
332
256
  },
333
257
  /* DRIZZLE_TYPE_DECIMAL -> */
334
258
  {
354
278
    DRIZZLE_TYPE_VARCHAR,
355
279
    //DRIZZLE_TYPE_BLOB
356
280
    DRIZZLE_TYPE_BLOB,
357
 
    //DRIZZLE_TYPE_TIME
358
 
    DRIZZLE_TYPE_TIME,
359
 
    //DRIZZLE_TYPE_BOOLEAN
360
 
    DRIZZLE_TYPE_VARCHAR,
361
 
    //DRIZZLE_TYPE_UUID
362
 
    DRIZZLE_TYPE_VARCHAR,
363
 
    //DRIZZLE_TYPE_MICROTIME
364
 
    DRIZZLE_TYPE_VARCHAR,
365
281
  },
366
282
  /* DRIZZLE_TYPE_ENUM -> */
367
283
  {
387
303
    DRIZZLE_TYPE_VARCHAR,
388
304
    //DRIZZLE_TYPE_BLOB
389
305
    DRIZZLE_TYPE_BLOB,
390
 
    //DRIZZLE_TYPE_TIME
391
 
    DRIZZLE_TYPE_TIME,
392
 
    //DRIZZLE_TYPE_BOOLEAN
393
 
    DRIZZLE_TYPE_VARCHAR,
394
 
    //DRIZZLE_TYPE_UUID
395
 
    DRIZZLE_TYPE_VARCHAR,
396
 
    //DRIZZLE_TYPE_MICROTIME
397
 
    DRIZZLE_TYPE_VARCHAR,
398
 
   },
 
306
  },
399
307
  /* DRIZZLE_TYPE_BLOB -> */
400
308
  {
401
309
    //DRIZZLE_TYPE_LONG
420
328
    DRIZZLE_TYPE_BLOB,
421
329
    //DRIZZLE_TYPE_BLOB
422
330
    DRIZZLE_TYPE_BLOB,
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
496
 
    DRIZZLE_TYPE_VARCHAR,
497
 
  },
498
 
  /* DRIZZLE_TYPE_UUID -> */
499
 
  {
500
 
    //DRIZZLE_TYPE_LONG
501
 
    DRIZZLE_TYPE_VARCHAR,
502
 
    //DRIZZLE_TYPE_DOUBLE
503
 
    DRIZZLE_TYPE_VARCHAR,
504
 
    //DRIZZLE_TYPE_NULL
505
 
    DRIZZLE_TYPE_UUID,
506
 
    //DRIZZLE_TYPE_TIMESTAMP
507
 
    DRIZZLE_TYPE_VARCHAR,
508
 
    //DRIZZLE_TYPE_LONGLONG
509
 
    DRIZZLE_TYPE_VARCHAR,
510
 
    //DRIZZLE_TYPE_DATETIME
511
 
    DRIZZLE_TYPE_VARCHAR,
512
 
    //DRIZZLE_TYPE_DATE
513
 
    DRIZZLE_TYPE_VARCHAR,
514
 
    //DRIZZLE_TYPE_VARCHAR
515
 
    DRIZZLE_TYPE_VARCHAR,
516
 
    //DRIZZLE_TYPE_DECIMAL
517
 
    DRIZZLE_TYPE_VARCHAR,
518
 
    //DRIZZLE_TYPE_VARCHAR,
519
 
    DRIZZLE_TYPE_VARCHAR,
520
 
    //DRIZZLE_TYPE_BLOB
521
 
    DRIZZLE_TYPE_BLOB,
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,
563
331
  },
564
332
};
565
333
 
566
 
static Item_result field_types_result_type [enum_field_types_size]=
 
334
static Item_result field_types_result_type [DRIZZLE_TYPE_MAX+1]=
567
335
{
568
336
  //DRIZZLE_TYPE_LONG
569
337
  INT_RESULT,
587
355
  STRING_RESULT,
588
356
  //DRIZZLE_TYPE_BLOB
589
357
  STRING_RESULT,
590
 
  //DRIZZLE_TYPE_TIME
591
 
  STRING_RESULT,
592
 
  //DRIZZLE_TYPE_BOOLEAN
593
 
  STRING_RESULT,
594
 
  //DRIZZLE_TYPE_UUID
595
 
  STRING_RESULT,
596
 
  //DRIZZLE_TYPE_MICROTIME
597
 
  STRING_RESULT,
598
358
};
599
359
 
600
360
bool test_if_important_data(const CHARSET_INFO * const cs, 
613
373
 
614
374
void *Field::operator new(size_t size, memory::Root *mem_root)
615
375
{
616
 
  return mem_root->alloc_root(static_cast<uint32_t>(size));
 
376
  return alloc_root(mem_root, static_cast<uint32_t>(size));
617
377
}
618
378
 
619
379
enum_field_types Field::field_type_merge(enum_field_types a,
620
380
                                         enum_field_types b)
621
381
{
622
 
  assert(a < enum_field_types_size);
623
 
  assert(b < enum_field_types_size);
 
382
  assert(a <= DRIZZLE_TYPE_MAX);
 
383
  assert(b <= DRIZZLE_TYPE_MAX);
624
384
  return field_types_merge_rules[a][b];
625
385
}
626
386
 
627
387
Item_result Field::result_merge_type(enum_field_types field_type)
628
388
{
629
 
  assert(field_type < enum_field_types_size);
 
389
  assert(field_type <= DRIZZLE_TYPE_MAX);
630
390
  return field_types_result_type[field_type];
631
391
}
632
392
 
677
437
 
678
438
void Field::set_default()
679
439
{
680
 
  ptrdiff_t l_offset= (ptrdiff_t) (table->getDefaultValues() - table->getInsertRecord());
 
440
  ptrdiff_t l_offset= (ptrdiff_t) (table->getDefaultValues() - table->record[0]);
681
441
  memcpy(ptr, ptr + l_offset, pack_length());
682
442
  if (null_ptr)
683
443
    *null_ptr= ((*null_ptr & (unsigned char) ~null_bit) | (null_ptr[l_offset] & null_bit));
746
506
  return 0;
747
507
}
748
508
 
749
 
bool Field::is_null(ptrdiff_t row_offset) const
 
509
bool Field::is_null(ptrdiff_t row_offset)
750
510
{
751
511
  return null_ptr ?
752
512
    (null_ptr[row_offset] & null_bit ? true : false) :
753
513
    table->null_row;
754
514
}
755
515
 
756
 
bool Field::is_real_null(ptrdiff_t row_offset) const
 
516
bool Field::is_real_null(ptrdiff_t row_offset)
757
517
{
758
518
  return null_ptr ? (null_ptr[row_offset] & null_bit ? true : false) : false;
759
519
}
760
520
 
761
 
bool Field::is_null_in_record(const unsigned char *record) const
 
521
bool Field::is_null_in_record(const unsigned char *record)
762
522
{
763
523
  if (! null_ptr)
764
524
    return false;
765
 
  return test(record[(uint32_t) (null_ptr -table->getInsertRecord())] & null_bit);
 
525
  return test(record[(uint32_t) (null_ptr -table->record[0])] & null_bit);
766
526
}
767
527
 
768
 
bool Field::is_null_in_record_with_offset(ptrdiff_t with_offset) const
 
528
bool Field::is_null_in_record_with_offset(ptrdiff_t with_offset)
769
529
{
770
530
  if (! null_ptr)
771
531
    return false;
784
544
    null_ptr[row_offset]&= (unsigned char) ~null_bit;
785
545
}
786
546
 
787
 
bool Field::maybe_null(void) const
 
547
bool Field::maybe_null(void)
788
548
{
789
549
  return null_ptr != 0 || table->maybe_null;
790
550
}
791
551
 
792
 
bool Field::real_maybe_null(void) const
 
552
bool Field::real_maybe_null(void)
793
553
{
794
554
  return null_ptr != 0;
795
555
}
823
583
void Field::init(Table *table_arg)
824
584
{
825
585
  orig_table= table= table_arg;
 
586
  table_name= &table_arg->alias;
826
587
}
827
588
 
828
589
/// This is used as a table name when the table structure is not set up
831
592
             unsigned char *null_ptr_arg,
832
593
             unsigned char null_bit_arg,
833
594
             utype unireg_check_arg, 
834
 
             const char *field_name_arg) :
 
595
             const char *field_name_arg)
 
596
  :
835
597
    ptr(ptr_arg),
836
598
    null_ptr(null_ptr_arg),
837
599
    table(NULL),
838
600
    orig_table(NULL),
 
601
    table_name(NULL),
839
602
    field_name(field_name_arg),
840
 
    comment(NULL_LEX_STRING),
841
603
    key_start(0),
842
604
    part_of_key(0),
843
605
    part_of_key_not_clustered(0),
844
606
    part_of_sortkey(0),
845
607
    unireg_check(unireg_check_arg),
846
608
    field_length(length_arg),
847
 
    flags(null_ptr ? 0: NOT_NULL_FLAG),
848
 
    field_index(0),
849
609
    null_bit(null_bit_arg),
850
610
    is_created_from_null_item(false)
851
611
{
 
612
  flags= null_ptr ? 0: NOT_NULL_FLAG;
 
613
  comment.str= (char*) "";
 
614
  comment.length= 0;
 
615
  field_index= 0;
852
616
}
853
617
 
854
 
void Field::hash(uint32_t *nr, uint32_t *nr2) const
 
618
void Field::hash(uint32_t *nr, uint32_t *nr2)
855
619
{
856
620
  if (is_null())
857
621
  {
877
641
  }
878
642
}
879
643
 
880
 
int Field::store_and_check(enum_check_fields check_level,
881
 
                           const char *to, 
882
 
                           uint32_t length,
883
 
                           const CHARSET_INFO * const cs)
884
 
 
 
644
int Field::store(const char *to, 
 
645
                 uint32_t length,
 
646
                 const CHARSET_INFO * const cs,
 
647
                 enum_check_fields check_level)
885
648
{
886
649
  int res;
887
650
  enum_check_fields old_check_level= table->in_use->count_cuted_fields;
901
664
 
902
665
unsigned char *Field::pack(unsigned char *to, const unsigned char *from)
903
666
{
904
 
  unsigned char *result= this->pack(to, from, UINT32_MAX, table->getShare()->db_low_byte_first);
 
667
  unsigned char *result= this->pack(to, from, UINT32_MAX, table->s->db_low_byte_first);
905
668
  return(result);
906
669
}
907
670
 
939
702
 
940
703
const unsigned char *Field::unpack(unsigned char* to, const unsigned char *from)
941
704
{
942
 
  const unsigned char *result= unpack(to, from, 0U, table->getShare()->db_low_byte_first);
 
705
  const unsigned char *result= unpack(to, from, 0U, table->s->db_low_byte_first);
943
706
  return(result);
944
707
}
945
708
 
946
 
type::Decimal *Field::val_decimal(type::Decimal *) const
 
709
my_decimal *Field::val_decimal(my_decimal *)
947
710
{
948
711
  /* This never have to be called */
949
712
  assert(0);
953
716
 
954
717
void Field::make_field(SendField *field)
955
718
{
956
 
  if (orig_table && orig_table->getShare()->getSchemaName() && *orig_table->getShare()->getSchemaName())
 
719
  if (orig_table && orig_table->s->db.str && *orig_table->s->db.str)
957
720
  {
958
 
    field->db_name= orig_table->getShare()->getSchemaName();
959
 
    field->org_table_name= orig_table->getShare()->getTableName();
 
721
    field->db_name= orig_table->s->db.str;
 
722
    field->org_table_name= orig_table->s->table_name.str;
960
723
  }
961
724
  else
962
725
    field->org_table_name= field->db_name= "";
963
726
  if (orig_table)
964
727
  {
965
 
    field->table_name= orig_table->getAlias();
 
728
    field->table_name= orig_table->alias;
966
729
    field->org_col_name= field_name;
967
730
  }
968
731
  else
978
741
  field->decimals= 0;
979
742
}
980
743
 
981
 
int64_t Field::convert_decimal2int64_t(const type::Decimal *val, bool, int *err)
 
744
int64_t Field::convert_decimal2int64_t(const my_decimal *val, bool, int *err)
982
745
{
983
746
  int64_t i;
984
 
  if (warn_if_overflow(val->val_int32(E_DEC_ERROR &
 
747
  if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
985
748
                                      ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
986
 
                                      false, &i)))
 
749
                                      val, false, &i)))
987
750
  {
988
751
    i= (val->sign() ? INT64_MIN : INT64_MAX);
989
752
    *err= 1;
991
754
  return i;
992
755
}
993
756
 
994
 
uint32_t Field::fill_cache_field(CacheField *copy)
 
757
uint32_t Field::fill_cache_field(CACHE_FIELD *copy)
995
758
{
996
759
  uint32_t store_length;
997
760
  copy->str=ptr;
1001
764
  {
1002
765
    copy->blob_field=(Field_blob*) this;
1003
766
    copy->strip=0;
1004
 
    copy->length-= table->getShare()->sizeBlobPtr();
 
767
    copy->length-= table->s->blob_ptr_size;
1005
768
    return copy->length;
1006
769
  }
1007
770
  else
1012
775
  return copy->length+ store_length;
1013
776
}
1014
777
 
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);
 
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);
1054
804
}
1055
805
 
1056
806
bool Field::optimize_range(uint32_t idx, uint32_t)
1061
811
Field *Field::new_field(memory::Root *root, Table *new_table, bool)
1062
812
{
1063
813
  Field *tmp;
1064
 
  if (!(tmp= (Field*) root->memdup_root((char*) this,size_of())))
 
814
  if (!(tmp= (Field*) memdup_root(root,(char*) this,size_of())))
1065
815
    return 0;
1066
816
 
1067
817
  if (tmp->table->maybe_null)
1094
844
Field *Field::clone(memory::Root *root, Table *new_table)
1095
845
{
1096
846
  Field *tmp;
1097
 
  if ((tmp= (Field*) root->memdup_root((char*) this,size_of())))
 
847
  if ((tmp= (Field*) memdup_root(root,(char*) this,size_of())))
1098
848
  {
1099
849
    tmp->init(new_table);
1100
 
    tmp->move_field_offset((ptrdiff_t) (new_table->getInsertRecord() -
1101
 
                                           new_table->getDefaultValues()));
 
850
    tmp->move_field_offset((ptrdiff_t) (new_table->record[0] -
 
851
                                           new_table->s->default_values));
1102
852
  }
1103
853
  return tmp;
1104
854
}
1121
871
{
1122
872
  if (!Field::eq_def(field))
1123
873
    return 0;
1124
 
 
1125
874
  TYPELIB *from_lib=((Field_enum*) field)->typelib;
1126
875
 
1127
876
  if (typelib->count < from_lib->count)
1128
877
    return 0;
1129
 
 
1130
878
  for (uint32_t i=0 ; i < from_lib->count ; i++)
1131
 
  {
1132
879
    if (my_strnncoll(field_charset,
1133
880
                     (const unsigned char*)typelib->type_names[i],
1134
881
                     strlen(typelib->type_names[i]),
1135
882
                     (const unsigned char*)from_lib->type_names[i],
1136
883
                     strlen(from_lib->type_names[i])))
1137
884
      return 0;
1138
 
  }
1139
 
 
1140
885
  return 1;
1141
886
}
1142
887
 
1144
889
{
1145
890
  switch (type) {
1146
891
  case DRIZZLE_TYPE_VARCHAR: return (length + (length < 256 ? 1: 2));
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();
1151
 
  case DRIZZLE_TYPE_DATE:
1152
 
  case DRIZZLE_TYPE_ENUM:
 
892
  case DRIZZLE_TYPE_DATE: return 3;
 
893
  case DRIZZLE_TYPE_TIMESTAMP:
1153
894
  case DRIZZLE_TYPE_LONG: return 4;
1154
895
  case DRIZZLE_TYPE_DOUBLE: return sizeof(double);
1155
 
  case DRIZZLE_TYPE_TIME:
1156
896
  case DRIZZLE_TYPE_DATETIME:
1157
897
  case DRIZZLE_TYPE_LONGLONG: return 8; /* Don't crash if no int64_t */
1158
898
  case DRIZZLE_TYPE_NULL: return 0;
1159
899
  case DRIZZLE_TYPE_BLOB: return 4 + portable_sizeof_char_ptr;
 
900
  case DRIZZLE_TYPE_ENUM:
1160
901
  case DRIZZLE_TYPE_DECIMAL:
1161
 
                          break;
 
902
    abort();
 
903
  default:
 
904
    return 0;
1162
905
  }
1163
 
 
1164
 
  assert(0);
1165
 
  abort();
1166
906
}
1167
907
 
1168
908
uint32_t pack_length_to_packflag(uint32_t type)
1171
911
    case 1: return 1 << FIELDFLAG_PACK_SHIFT;
1172
912
    case 2: assert(1);
1173
913
    case 3: assert(1);
1174
 
    case 4: return f_settype(DRIZZLE_TYPE_LONG);
1175
 
    case 8: return f_settype(DRIZZLE_TYPE_LONGLONG);
 
914
    case 4: return f_settype((uint32_t) DRIZZLE_TYPE_LONG);
 
915
    case 8: return f_settype((uint32_t) DRIZZLE_TYPE_LONGLONG);
1176
916
  }
1177
917
  return 0;                                     // This shouldn't happen
1178
918
}
1179
919
 
 
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
 
1180
1064
/*****************************************************************************
1181
1065
 Warning handling
1182
1066
*****************************************************************************/
1183
1067
 
1184
1068
bool Field::set_warning(DRIZZLE_ERROR::enum_warning_level level,
1185
 
                        drizzled::error_t code,
 
1069
                        uint32_t code,
1186
1070
                        int cuted_increment)
1187
1071
{
1188
1072
  /*
1202
1086
 
1203
1087
 
1204
1088
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1205
 
                                 drizzled::error_t code,
 
1089
                                 unsigned int code,
1206
1090
                                 const char *str, 
1207
1091
                                 uint32_t str_length,
1208
 
                                 type::timestamp_t ts_type, 
 
1092
                                 enum enum_drizzle_timestamp_type ts_type, 
1209
1093
                                 int cuted_increment)
1210
1094
{
1211
 
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
1212
 
 
1213
 
  if ((session->abortOnWarning() and
 
1095
  Session *session= table ? table->in_use : current_session;
 
1096
  if ((session->really_abort_on_warning() &&
1214
1097
       level >= DRIZZLE_ERROR::WARN_LEVEL_WARN) ||
1215
1098
      set_warning(level, code, cuted_increment))
1216
1099
    make_truncated_value_warning(session, level, str, str_length, ts_type,
1218
1101
}
1219
1102
 
1220
1103
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, 
1221
 
                                 drizzled::error_t code,
 
1104
                                 uint32_t code,
1222
1105
                                 int64_t nr, 
1223
 
                                 type::timestamp_t ts_type,
 
1106
                                 enum enum_drizzle_timestamp_type ts_type,
1224
1107
                                 int cuted_increment)
1225
1108
{
1226
 
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
1227
 
 
1228
 
  if (session->abortOnWarning() or
 
1109
  Session *session= table ? table->in_use : current_session;
 
1110
  if (session->really_abort_on_warning() ||
1229
1111
      set_warning(level, code, cuted_increment))
1230
1112
  {
1231
 
    char str_nr[DECIMAL_LONGLONG_DIGITS];
 
1113
    char str_nr[22];
1232
1114
    char *str_end= internal::int64_t10_to_str(nr, str_nr, -10);
1233
1115
    make_truncated_value_warning(session, level, str_nr, (uint32_t) (str_end - str_nr),
1234
1116
                                 ts_type, field_name);
1236
1118
}
1237
1119
 
1238
1120
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1239
 
                                 const drizzled::error_t code,
 
1121
                                 const uint32_t code,
1240
1122
                                 double nr, 
1241
 
                                 type::timestamp_t ts_type)
 
1123
                                 enum enum_drizzle_timestamp_type ts_type)
1242
1124
{
1243
 
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
1244
 
 
1245
 
  if (session->abortOnWarning() or
 
1125
  Session *session= table ? table->in_use : current_session;
 
1126
  if (session->really_abort_on_warning() ||
1246
1127
      set_warning(level, code, 1))
1247
1128
  {
1248
1129
    /* DBL_DIG is enough to print '-[digits].E+###' */
1249
1130
    char str_nr[DBL_DIG + 8];
1250
 
    uint32_t str_len= snprintf(str_nr, sizeof(str_nr), "%g", nr);
 
1131
    uint32_t str_len= sprintf(str_nr, "%g", nr);
1251
1132
    make_truncated_value_warning(session, level, str_nr, str_len, ts_type,
1252
1133
                                 field_name);
1253
1134
  }
1254
1135
}
1255
1136
 
1256
 
bool Field::isReadSet() const 
 
1137
bool Field::isReadSet() 
1257
1138
{ 
1258
1139
  return table->isReadSet(field_index); 
1259
1140
}
1279
1160
    table->clearWriteSet(field_index);
1280
1161
}
1281
1162
 
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
 
 
1318
 
std::ostream& operator<<(std::ostream& output, const Field &field)
1319
 
{
1320
 
  output << "Field:(";
1321
 
  output <<  field.field_name;
1322
 
  output << ", ";
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 << "}, ";
1347
 
  output << ")";
1348
 
 
1349
 
  return output;  // for multiple << operators.
1350
 
}
1351
 
 
1352
1163
} /* namespace drizzled */