« back to all changes in this revision
Viewing changes to server/field.cc
- browse files at revision 77.1.66
- compare with another revision
- compare with revision 77.3.19
- download diff
- download tarball
- view history from revision 77.1.66
- Committer: Monty Taylor
- Date: 2008-07-11 10:33:22 UTC
- mfrom: (132 drizzle)
- mto: (77.6.1 glibclient-merge)
- mto: This revision was merged to the branch mainline in revision 134.
- Revision ID: monty@inaugust.com-20080711103322-0a3sppn0usxty41l
Merged from trunk.
- files removed:
- client/mysqlshow.c
- files modified:
- client/Makefile.am
added
removed
server/field.cc
51
51
#define BLOB_PACK_LENGTH_TO_MAX_LENGH(arg) \
52
52
((ulong) ((1LL << min(arg, 4) * 8) - 1LL))
53
53
54
#define ASSERT_COLUMN_MARKED_FOR_READ DBUG_ASSERT(!table || (!table->read_set || bitmap_is_set(table->read_set, field_index)))
55
#define ASSERT_COLUMN_MARKED_FOR_WRITE DBUG_ASSERT(!table || (!table->write_set || bitmap_is_set(table->write_set, field_index)))
56
57
54
/*
58
55
Rules for merging different types of fields in UNION
59
56
94
91
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
95
92
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
96
93
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
97
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
98
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
99
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
100
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
94
//MYSQL_TYPE_SET
95
MYSQL_TYPE_VARCHAR,
101
96
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
102
97
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
103
98
//MYSQL_TYPE_STRING
123
118
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
124
119
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
125
120
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
126
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
127
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
128
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
129
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
121
//MYSQL_TYPE_SET
122
MYSQL_TYPE_VARCHAR,
130
123
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
131
124
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
132
125
//MYSQL_TYPE_STRING
152
145
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
153
146
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
154
147
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
155
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
156
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
157
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
158
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
148
//MYSQL_TYPE_SET
149
MYSQL_TYPE_VARCHAR,
159
150
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
160
151
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
161
152
//MYSQL_TYPE_STRING
181
172
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
182
173
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
183
174
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
184
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
185
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
186
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
187
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
175
//MYSQL_TYPE_SET
176
MYSQL_TYPE_VARCHAR,
188
177
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
189
178
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
190
179
//MYSQL_TYPE_STRING
210
199
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
211
200
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
212
201
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_VARCHAR,
213
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
214
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
215
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
216
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
202
//MYSQL_TYPE_SET
203
MYSQL_TYPE_VARCHAR,
217
204
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
218
205
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
219
206
//MYSQL_TYPE_STRING
239
226
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
240
227
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
241
228
MYSQL_TYPE_DOUBLE, MYSQL_TYPE_VARCHAR,
242
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
243
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
244
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
245
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
229
//MYSQL_TYPE_SET
230
MYSQL_TYPE_VARCHAR,
246
231
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
247
232
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
248
233
//MYSQL_TYPE_STRING
268
253
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
269
254
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
270
255
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_ENUM,
271
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
272
MYSQL_TYPE_SET, MYSQL_TYPE_TINY_BLOB,
273
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
274
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
256
//MYSQL_TYPE_SET
257
MYSQL_TYPE_SET,
275
258
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
276
259
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
277
260
//MYSQL_TYPE_STRING
297
280
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
298
281
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
299
282
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
300
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
301
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
302
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
303
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
283
//MYSQL_TYPE_SET
284
MYSQL_TYPE_VARCHAR,
304
285
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
305
286
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
306
287
//MYSQL_TYPE_STRING
326
307
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
327
308
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
328
309
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
329
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
330
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
331
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
332
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
310
//MYSQL_TYPE_SET
311
MYSQL_TYPE_VARCHAR,
333
312
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
334
313
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
335
314
//MYSQL_TYPE_STRING
355
334
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
356
335
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
357
336
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
358
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
359
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
360
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
361
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
337
//MYSQL_TYPE_SET
338
MYSQL_TYPE_VARCHAR,
362
339
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
363
340
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
364
341
//MYSQL_TYPE_STRING
384
361
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
385
362
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
386
363
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
387
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
388
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
389
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
390
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
364
//MYSQL_TYPE_SET
365
MYSQL_TYPE_VARCHAR,
391
366
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
392
367
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
393
368
//MYSQL_TYPE_STRING
413
388
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
414
389
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
415
390
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
416
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
417
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
418
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
419
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
391
//MYSQL_TYPE_SET
392
MYSQL_TYPE_VARCHAR,
420
393
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
421
394
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
422
395
//MYSQL_TYPE_STRING
442
415
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
443
416
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
444
417
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
445
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
446
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
447
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
448
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
418
//MYSQL_TYPE_SET
419
MYSQL_TYPE_VARCHAR,
449
420
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
450
421
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
451
422
//MYSQL_TYPE_STRING
471
442
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
472
443
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
473
444
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
474
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
475
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
476
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
477
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
445
//MYSQL_TYPE_SET
446
MYSQL_TYPE_VARCHAR,
478
447
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
479
448
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
480
449
//MYSQL_TYPE_STRING
500
469
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
501
470
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
502
471
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
503
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
504
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
505
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
506
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
472
//MYSQL_TYPE_SET
473
MYSQL_TYPE_VARCHAR,
507
474
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
508
475
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
509
476
//MYSQL_TYPE_STRING
529
496
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
530
497
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
531
498
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
532
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
533
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
534
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
535
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
499
//MYSQL_TYPE_SET
500
MYSQL_TYPE_VARCHAR,
536
501
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
537
502
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
538
503
//MYSQL_TYPE_STRING
558
523
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
559
524
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
560
525
MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_VARCHAR,
561
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
562
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
563
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
564
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
526
//MYSQL_TYPE_SET
527
MYSQL_TYPE_VARCHAR,
565
528
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
566
529
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
567
530
//MYSQL_TYPE_STRING
587
550
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
588
551
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
589
552
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
590
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
591
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
592
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
593
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
553
//MYSQL_TYPE_SET
554
MYSQL_TYPE_VARCHAR,
594
555
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
595
556
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
596
557
//MYSQL_TYPE_STRING
616
577
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
617
578
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
618
579
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
619
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
620
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
621
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
622
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
580
//MYSQL_TYPE_SET
581
MYSQL_TYPE_VARCHAR,
623
582
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
624
583
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
625
584
//MYSQL_TYPE_STRING
626
585
MYSQL_TYPE_STRING
627
586
},
628
/* MYSQL_TYPE_TINY_BLOB -> */
629
{
630
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
631
MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_TINY_BLOB,
632
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
633
MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_TINY_BLOB,
634
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
635
MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_TINY_BLOB,
636
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
637
MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_TINY_BLOB,
638
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
639
MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_TINY_BLOB,
640
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
641
MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_TINY_BLOB,
642
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
643
MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_TINY_BLOB,
644
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
645
MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_TINY_BLOB,
646
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
647
MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_TINY_BLOB,
648
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
649
MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_TINY_BLOB,
650
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
651
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
652
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
653
MYSQL_TYPE_BLOB, MYSQL_TYPE_TINY_BLOB,
654
//MYSQL_TYPE_STRING
655
MYSQL_TYPE_TINY_BLOB
656
},
657
/* MYSQL_TYPE_MEDIUM_BLOB -> */
658
{
659
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
660
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
661
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
662
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
663
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
664
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
665
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
666
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
667
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
668
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
669
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
670
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
671
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
672
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
673
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
674
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
675
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
676
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
677
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
678
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
679
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
680
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
681
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
682
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
683
//MYSQL_TYPE_STRING
684
MYSQL_TYPE_MEDIUM_BLOB
685
},
686
/* MYSQL_TYPE_LONG_BLOB -> */
687
{
688
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
689
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
690
//MYSQL_TYPE_SHORT MYSQL_TYPE_LONG
691
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
692
//MYSQL_TYPE_FLOAT MYSQL_TYPE_DOUBLE
693
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
694
//MYSQL_TYPE_NULL MYSQL_TYPE_TIMESTAMP
695
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
696
//MYSQL_TYPE_LONGLONG MYSQL_TYPE_INT24
697
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
698
//MYSQL_TYPE_DATE MYSQL_TYPE_TIME
699
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
700
//MYSQL_TYPE_DATETIME MYSQL_TYPE_YEAR
701
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
702
//MYSQL_TYPE_NEWDATE MYSQL_TYPE_VARCHAR
703
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
704
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
705
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
706
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
707
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
708
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
709
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
710
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
711
MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_LONG_BLOB,
712
//MYSQL_TYPE_STRING
713
MYSQL_TYPE_LONG_BLOB
714
},
715
587
/* MYSQL_TYPE_BLOB -> */
716
588
{
717
589
//MYSQL_TYPE_DECIMAL MYSQL_TYPE_TINY
732
604
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
733
605
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
734
606
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
735
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
736
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
737
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
738
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
607
//MYSQL_TYPE_SET
608
MYSQL_TYPE_BLOB,
739
609
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
740
610
MYSQL_TYPE_BLOB, MYSQL_TYPE_BLOB,
741
611
//MYSQL_TYPE_STRING
761
631
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
762
632
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
763
633
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_VARCHAR,
764
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
765
MYSQL_TYPE_VARCHAR, MYSQL_TYPE_TINY_BLOB,
766
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
767
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
634
//MYSQL_TYPE_SET
635
MYSQL_TYPE_VARCHAR,
768
636
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
769
637
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
770
638
//MYSQL_TYPE_STRING
790
658
MYSQL_TYPE_STRING, MYSQL_TYPE_VARCHAR,
791
659
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
792
660
MYSQL_TYPE_STRING, MYSQL_TYPE_STRING,
793
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
794
MYSQL_TYPE_STRING, MYSQL_TYPE_TINY_BLOB,
795
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
796
MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
661
//MYSQL_TYPE_SET
662
MYSQL_TYPE_STRING,
797
663
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
798
664
MYSQL_TYPE_BLOB, MYSQL_TYPE_VARCHAR,
799
665
//MYSQL_TYPE_STRING
814
680
enum_field_types Field::field_type_merge(enum_field_types a,
815
681
enum_field_types b)
816
682
{
817
DBUG_ASSERT(a < FIELDTYPE_TEAR_FROM || a > FIELDTYPE_TEAR_TO);
818
DBUG_ASSERT(b < FIELDTYPE_TEAR_FROM || b > FIELDTYPE_TEAR_TO);
683
assert(a < FIELDTYPE_TEAR_FROM || a > FIELDTYPE_TEAR_TO);
684
assert(b < FIELDTYPE_TEAR_FROM || b > FIELDTYPE_TEAR_TO);
819
685
return field_types_merge_rules[field_type2index(a)]
820
686
[field_type2index(b)];
821
687
}
841
707
STRING_RESULT, STRING_RESULT,
842
708
//MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_ENUM
843
709
DECIMAL_RESULT, STRING_RESULT,
844
//MYSQL_TYPE_SET MYSQL_TYPE_TINY_BLOB
845
STRING_RESULT, STRING_RESULT,
846
//MYSQL_TYPE_MEDIUM_BLOB MYSQL_TYPE_LONG_BLOB
847
STRING_RESULT, STRING_RESULT,
710
//MYSQL_TYPE_SET
711
STRING_RESULT,
848
712
//MYSQL_TYPE_BLOB MYSQL_TYPE_VAR_STRING
849
713
STRING_RESULT, STRING_RESULT,
850
714
//MYSQL_TYPE_STRING
864
728
strend String end
865
729
866
730
RETURN
867
FALSE - If string does not have important data
868
TRUE - If string has some important data
731
false - If string does not have important data
732
true - If string has some important data
869
733
*/
870
734
871
735
static bool
888
752
889
753
Item_result Field::result_merge_type(enum_field_types field_type)
890
754
{
891
DBUG_ASSERT(field_type < FIELDTYPE_TEAR_FROM || field_type
755
assert(field_type < FIELDTYPE_TEAR_FROM || field_type
892
756
> FIELDTYPE_TEAR_TO);
893
757
return field_types_result_type[field_type2index(field_type)];
894
758
}
907
771
@param type field type
908
772
909
773
@retval
910
TRUE Type can have a prefixed key
774
true Type can have a prefixed key
911
775
@retval
912
FALSE Type can not have a prefixed key
776
false Type can not have a prefixed key
913
777
*/
914
778
915
779
bool Field::type_can_have_key_part(enum enum_field_types type)
916
780
{
917
781
switch (type) {
918
782
case MYSQL_TYPE_VARCHAR:
919
case MYSQL_TYPE_TINY_BLOB:
920
case MYSQL_TYPE_MEDIUM_BLOB:
921
case MYSQL_TYPE_LONG_BLOB:
922
783
case MYSQL_TYPE_BLOB:
923
784
case MYSQL_TYPE_VAR_STRING:
924
785
case MYSQL_TYPE_STRING:
925
return TRUE;
786
return true;
926
787
default:
927
return FALSE;
788
return false;
928
789
}
929
790
}
930
791
1165
1026
1166
1027
String *Field::val_int_as_str(String *val_buffer, my_bool unsigned_val)
1167
1028
{
1168
ASSERT_COLUMN_MARKED_FOR_READ;
1169
1029
CHARSET_INFO *cs= &my_charset_bin;
1170
1030
uint length;
1171
1031
longlong value= val_int();
1191
1051
key_start(0), part_of_key(0), part_of_key_not_clustered(0),
1192
1052
part_of_sortkey(0), unireg_check(unireg_check_arg),
1193
1053
field_length(length_arg), null_bit(null_bit_arg),
1194
is_created_from_null_item(FALSE)
1054
is_created_from_null_item(false)
1195
1055
{
1196
1056
flags=null_ptr ? 0: NOT_NULL_FLAG;
1197
1057
comment.str= (char*) "";
1217
1077
size_t
1218
1078
Field::do_last_null_byte() const
1219
1079
{
1220
DBUG_ASSERT(null_ptr == NULL || null_ptr >= table->record[0]);
1080
assert(null_ptr == NULL || null_ptr >= table->record[0]);
1221
1081
if (null_ptr)
1222
1082
return (size_t) (null_ptr - table->record[0]) + 1;
1223
1083
return LAST_NULL_BYTE_UNDEF;
1308
1168
the data.
1309
1169
1310
1170
@param low_byte_first
1311
@c TRUE if integers should be stored little-endian, @c FALSE if
1171
@c true if integers should be stored little-endian, @c false if
1312
1172
native format should be used. Note that for little-endian machines,
1313
1173
the value of this flag is a moot point since the native format is
1314
1174
little-endian.
1388
1248
my_decimal *Field::val_decimal(my_decimal *decimal __attribute__((__unused__)))
1389
1249
{
1390
1250
/* This never have to be called */
1391
DBUG_ASSERT(0);
1251
assert(0);
1392
1252
return 0;
1393
1253
}
1394
1254
1455
1315
}
1456
1316
else if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
1457
1317
~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
1458
val, TRUE, &i)))
1318
val, true, &i)))
1459
1319
{
1460
1320
i= ~(longlong) 0;
1461
1321
*err= 1;
1463
1323
}
1464
1324
else if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
1465
1325
~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
1466
val, FALSE, &i)))
1326
val, false, &i)))
1467
1327
{
1468
1328
i= (val->sign() ? LONGLONG_MIN : LONGLONG_MAX);
1469
1329
*err= 1;
1488
1348
1489
1349
int Field_num::store_decimal(const my_decimal *val)
1490
1350
{
1491
ASSERT_COLUMN_MARKED_FOR_WRITE;
1492
1351
int err= 0;
1493
1352
longlong i= convert_decimal2longlong(val, unsigned_flag, &err);
1494
1353
return test(err | store(i, unsigned_flag));
1511
1370
1512
1371
my_decimal* Field_num::val_decimal(my_decimal *decimal_value)
1513
1372
{
1514
ASSERT_COLUMN_MARKED_FOR_READ;
1515
DBUG_ASSERT(result_type() == INT_RESULT);
1373
assert(result_type() == INT_RESULT);
1516
1374
longlong nr= val_int();
1517
1375
int2my_decimal(E_DEC_FATAL_ERROR, nr, unsigned_flag, decimal_value);
1518
1376
return decimal_value;
1560
1418
1561
1419
int Field_str::store_decimal(const my_decimal *d)
1562
1420
{
1563
ASSERT_COLUMN_MARKED_FOR_WRITE;
1564
1421
double val;
1565
1422
/* TODO: use decimal2string? */
1566
1423
int err= warn_if_overflow(my_decimal2double(E_DEC_FATAL_ERROR &
1571
1428
1572
1429
my_decimal *Field_str::val_decimal(my_decimal *decimal_value)
1573
1430
{
1574
ASSERT_COLUMN_MARKED_FOR_READ;
1575
1431
longlong nr= val_int();
1576
1432
int2my_decimal(E_DEC_FATAL_ERROR, nr, 0, decimal_value);
1577
1433
return decimal_value;
1638
1494
int Field::store_time(MYSQL_TIME *ltime,
1639
1495
timestamp_type type_arg __attribute__((__unused__)))
1640
1496
{
1641
ASSERT_COLUMN_MARKED_FOR_WRITE;
1642
1497
char buff[MAX_DATE_STRING_REP_LENGTH];
1643
1498
uint length= (uint) my_TIME_to_str(ltime, buff);
1644
1499
return store(buff, length, &my_charset_bin);
1728
1583
{
1729
1584
precision= my_decimal_length_to_precision(len_arg, dec_arg, unsigned_arg);
1730
1585
set_if_smaller(precision, DECIMAL_MAX_PRECISION);
1731
DBUG_ASSERT((precision <= DECIMAL_MAX_PRECISION) &&
1586
assert((precision <= DECIMAL_MAX_PRECISION) &&
1732
1587
(dec <= DECIMAL_MAX_SCALE));
1733
1588
bin_size= my_decimal_get_binary_size(precision, dec);
1734
1589
}
1745
1600
{
1746
1601
precision= my_decimal_length_to_precision(len_arg, dec_arg, unsigned_arg);
1747
1602
set_if_smaller(precision, DECIMAL_MAX_PRECISION);
1748
DBUG_ASSERT((precision <= DECIMAL_MAX_PRECISION) &&
1603
assert((precision <= DECIMAL_MAX_PRECISION) &&
1749
1604
(dec <= DECIMAL_MAX_SCALE));
1750
1605
bin_size= my_decimal_get_binary_size(precision, dec);
1751
1606
}
1768
1623
void Field_new_decimal::set_value_on_overflow(my_decimal *decimal_value,
1769
1624
bool sign)
1770
1625
{
1771
DBUG_ENTER("Field_new_decimal::set_value_on_overflow");
1772
1626
max_my_decimal(decimal_value, precision, decimals());
1773
1627
if (sign)
1774
1628
{
1775
1629
if (unsigned_flag)
1776
1630
my_decimal_set_zero(decimal_value);
1777
1631
else
1778
decimal_value->sign(TRUE);
1632
decimal_value->sign(true);
1779
1633
}
1780
DBUG_VOID_RETURN;
1634
return;
1781
1635
}
1782
1636
1783
1637
1798
1652
1799
1653
bool Field_new_decimal::store_value(const my_decimal *decimal_value)
1800
1654
{
1801
ASSERT_COLUMN_MARKED_FOR_WRITE;
1802
1655
int error= 0;
1803
DBUG_ENTER("Field_new_decimal::store_value");
1804
#ifndef DBUG_OFF
1805
{
1806
char dbug_buff[DECIMAL_MAX_STR_LENGTH+1];
1807
DBUG_PRINT("enter", ("value: %s", dbug_decimal_as_string(dbug_buff, decimal_value)));
1808
}
1809
#endif
1810
1656
1811
1657
/* check that we do not try to write negative value in unsigned field */
1812
1658
if (unsigned_flag && decimal_value->sign())
1813
1659
{
1814
DBUG_PRINT("info", ("unsigned overflow"));
1815
1660
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1816
1661
error= 1;
1817
1662
decimal_value= &decimal_zero;
1818
1663
}
1819
#ifndef DBUG_OFF
1820
{
1821
char dbug_buff[DECIMAL_MAX_STR_LENGTH+1];
1822
DBUG_PRINT("info", ("saving with precision %d scale: %d value %s",
1823
(int)precision, (int)dec,
1824
dbug_decimal_as_string(dbug_buff, decimal_value)));
1825
}
1826
#endif
1827
1664
1828
1665
if (warn_if_overflow(my_decimal2binary(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW,
1829
1666
decimal_value, ptr, precision, dec)))
1830
1667
{
1831
1668
my_decimal buff;
1832
DBUG_PRINT("info", ("overflow"));
1833
1669
set_value_on_overflow(&buff, decimal_value->sign());
1834
1670
my_decimal2binary(E_DEC_FATAL_ERROR, &buff, ptr, precision, dec);
1835
1671
error= 1;
1836
1672
}
1837
DBUG_EXECUTE("info", print_decimal_buff(decimal_value, (uchar *) ptr,
1838
bin_size););
1839
DBUG_RETURN(error);
1673
return(error);
1840
1674
}
1841
1675
1842
1676
1843
1677
int Field_new_decimal::store(const char *from, uint length,
1844
1678
CHARSET_INFO *charset_arg)
1845
1679
{
1846
ASSERT_COLUMN_MARKED_FOR_WRITE;
1847
1680
int err;
1848
1681
my_decimal decimal_value;
1849
DBUG_ENTER("Field_new_decimal::store(char*)");
1850
1682
1851
1683
if ((err= str2my_decimal(E_DEC_FATAL_ERROR &
1852
1684
~(E_DEC_OVERFLOW | E_DEC_BAD_NUM),
1864
1696
"decimal", from_as_str.c_ptr(), field_name,
1865
1697
(ulong) table->in_use->row_count);
1866
1698
1867
DBUG_RETURN(err);
1699
return(err);
1868
1700
}
1869
1701
1870
1702
switch (err) {
1892
1724
}
1893
1725
}
1894
1726
1895
#ifndef DBUG_OFF
1896
char dbug_buff[DECIMAL_MAX_STR_LENGTH+1];
1897
DBUG_PRINT("enter", ("value: %s",
1898
dbug_decimal_as_string(dbug_buff, &decimal_value)));
1899
#endif
1900
1727
store_value(&decimal_value);
1901
DBUG_RETURN(err);
1728
return(err);
1902
1729
}
1903
1730
1904
1731
1910
1737
1911
1738
int Field_new_decimal::store(double nr)
1912
1739
{
1913
ASSERT_COLUMN_MARKED_FOR_WRITE;
1914
1740
my_decimal decimal_value;
1915
1741
int err;
1916
DBUG_ENTER("Field_new_decimal::store(double)");
1917
1742
1918
1743
err= double2my_decimal(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW, nr,
1919
1744
&decimal_value);
1928
1753
err= 1;
1929
1754
else if (err && !table->in_use->got_warning)
1930
1755
err= warn_if_overflow(err);
1931
DBUG_RETURN(err);
1756
return(err);
1932
1757
}
1933
1758
1934
1759
1935
1760
int Field_new_decimal::store(longlong nr, bool unsigned_val)
1936
1761
{
1937
ASSERT_COLUMN_MARKED_FOR_WRITE;
1938
1762
my_decimal decimal_value;
1939
1763
int err;
1940
1764
1956
1780
1957
1781
int Field_new_decimal::store_decimal(const my_decimal *decimal_value)
1958
1782
{
1959
ASSERT_COLUMN_MARKED_FOR_WRITE;
1960
1783
return store_value(decimal_value);
1961
1784
}
1962
1785
1971
1794
1972
1795
double Field_new_decimal::val_real(void)
1973
1796
{
1974
ASSERT_COLUMN_MARKED_FOR_READ;
1975
1797
double dbl;
1976
1798
my_decimal decimal_value;
1977
1799
my_decimal2double(E_DEC_FATAL_ERROR, val_decimal(&decimal_value), &dbl);
1981
1803
1982
1804
longlong Field_new_decimal::val_int(void)
1983
1805
{
1984
ASSERT_COLUMN_MARKED_FOR_READ;
1985
1806
longlong i;
1986
1807
my_decimal decimal_value;
1987
1808
my_decimal2int(E_DEC_FATAL_ERROR, val_decimal(&decimal_value),
1992
1813
1993
1814
my_decimal* Field_new_decimal::val_decimal(my_decimal *decimal_value)
1994
1815
{
1995
ASSERT_COLUMN_MARKED_FOR_READ;
1996
DBUG_ENTER("Field_new_decimal::val_decimal");
1997
1816
binary2my_decimal(E_DEC_FATAL_ERROR, ptr, decimal_value,
1998
1817
precision, dec);
1999
DBUG_EXECUTE("info", print_decimal_buff(decimal_value, (uchar *) ptr,
2000
bin_size););
2001
DBUG_RETURN(decimal_value);
1818
return(decimal_value);
2002
1819
}
2003
1820
2004
1821
2005
1822
String *Field_new_decimal::val_str(String *val_buffer,
2006
1823
String *val_ptr __attribute__((unused)))
2007
1824
{
2008
ASSERT_COLUMN_MARKED_FOR_READ;
2009
1825
my_decimal decimal_value;
2010
1826
uint fixed_precision= zerofill ? precision : 0;
2011
1827
my_decimal2string(E_DEC_FATAL_ERROR, val_decimal(&decimal_value),
2177
1993
2178
1994
int Field_tiny::store(const char *from,uint len,CHARSET_INFO *cs)
2179
1995
{
2180
ASSERT_COLUMN_MARKED_FOR_WRITE;
2181
1996
int error;
2182
1997
longlong rnd;
2183
1998
2189
2004
2190
2005
int Field_tiny::store(double nr)
2191
2006
{
2192
ASSERT_COLUMN_MARKED_FOR_WRITE;
2193
2007
int error= 0;
2194
2008
nr=rint(nr);
2195
2009
if (unsigned_flag)
2232
2046
2233
2047
int Field_tiny::store(longlong nr, bool unsigned_val)
2234
2048
{
2235
ASSERT_COLUMN_MARKED_FOR_WRITE;
2236
2049
int error= 0;
2237
2050
2238
2051
if (unsigned_flag)
2277
2090
2278
2091
double Field_tiny::val_real(void)
2279
2092
{
2280
ASSERT_COLUMN_MARKED_FOR_READ;
2281
2093
int tmp= unsigned_flag ? (int) ptr[0] :
2282
2094
(int) ((signed char*) ptr)[0];
2283
2095
return (double) tmp;
2286
2098
2287
2099
longlong Field_tiny::val_int(void)
2288
2100
{
2289
ASSERT_COLUMN_MARKED_FOR_READ;
2290
2101
int tmp= unsigned_flag ? (int) ptr[0] :
2291
2102
(int) ((signed char*) ptr)[0];
2292
2103
return (longlong) tmp;
2296
2107
String *Field_tiny::val_str(String *val_buffer,
2297
2108
String *val_ptr __attribute__((unused)))
2298
2109
{
2299
ASSERT_COLUMN_MARKED_FOR_READ;
2300
2110
CHARSET_INFO *cs= &my_charset_bin;
2301
2111
uint length;
2302
2112
uint mlength=max(field_length+1,5*cs->mbmaxlen);
2352
2162
2353
2163
int Field_short::store(const char *from,uint len,CHARSET_INFO *cs)
2354
2164
{
2355
ASSERT_COLUMN_MARKED_FOR_WRITE;
2356
2165
int store_tmp;
2357
2166
int error;
2358
2167
longlong rnd;
2373
2182
2374
2183
int Field_short::store(double nr)
2375
2184
{
2376
ASSERT_COLUMN_MARKED_FOR_WRITE;
2377
2185
int error= 0;
2378
2186
int16 res;
2379
2187
nr=rint(nr);
2425
2233
2426
2234
int Field_short::store(longlong nr, bool unsigned_val)
2427
2235
{
2428
ASSERT_COLUMN_MARKED_FOR_WRITE;
2429
2236
int error= 0;
2430
2237
int16 res;
2431
2238
2480
2287
2481
2288
double Field_short::val_real(void)
2482
2289
{
2483
ASSERT_COLUMN_MARKED_FOR_READ;
2484
2290
short j;
2485
2291
#ifdef WORDS_BIGENDIAN
2486
2292
if (table->s->db_low_byte_first)
2493
2299
2494
2300
longlong Field_short::val_int(void)
2495
2301
{
2496
ASSERT_COLUMN_MARKED_FOR_READ;
2497
2302
short j;
2498
2303
#ifdef WORDS_BIGENDIAN
2499
2304
if (table->s->db_low_byte_first)
2508
2313
String *Field_short::val_str(String *val_buffer,
2509
2314
String *val_ptr __attribute__((unused)))
2510
2315
{
2511
ASSERT_COLUMN_MARKED_FOR_READ;
2512
2316
CHARSET_INFO *cs= &my_charset_bin;
2513
2317
uint length;
2514
2318
uint mlength=max(field_length+1,7*cs->mbmaxlen);
2594
2398
2595
2399
2596
2400
/****************************************************************************
2597
Field type medium int (3 byte)
2598
****************************************************************************/
2599
2600
int Field_medium::store(const char *from,uint len,CHARSET_INFO *cs)
2601
{
2602
ASSERT_COLUMN_MARKED_FOR_WRITE;
2603
int store_tmp;
2604
int error;
2605
longlong rnd;
2606
2607
error= get_int(cs, from, len, &rnd, UINT_MAX24, INT_MIN24, INT_MAX24);
2608
store_tmp= unsigned_flag ? (int) (uint64_t) rnd : (int) rnd;
2609
int3store(ptr, store_tmp);
2610
return error;
2611
}
2612
2613
2614
int Field_medium::store(double nr)
2615
{
2616
ASSERT_COLUMN_MARKED_FOR_WRITE;
2617
int error= 0;
2618
nr=rint(nr);
2619
if (unsigned_flag)
2620
{
2621
if (nr < 0)
2622
{
2623
int3store(ptr,0);
2624
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2625
error= 1;
2626
}
2627
else if (nr >= (double) (long) (1L << 24))
2628
{
2629
uint32 tmp=(uint32) (1L << 24)-1L;
2630
int3store(ptr,tmp);
2631
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2632
error= 1;
2633
}
2634
else
2635
int3store(ptr,(uint32) nr);
2636
}
2637
else
2638
{
2639
if (nr < (double) INT_MIN24)
2640
{
2641
long tmp=(long) INT_MIN24;
2642
int3store(ptr,tmp);
2643
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2644
error= 1;
2645
}
2646
else if (nr > (double) INT_MAX24)
2647
{
2648
long tmp=(long) INT_MAX24;
2649
int3store(ptr,tmp);
2650
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2651
error= 1;
2652
}
2653
else
2654
int3store(ptr,(long) nr);
2655
}
2656
return error;
2657
}
2658
2659
2660
int Field_medium::store(longlong nr, bool unsigned_val)
2661
{
2662
ASSERT_COLUMN_MARKED_FOR_WRITE;
2663
int error= 0;
2664
2665
if (unsigned_flag)
2666
{
2667
if (nr < 0 && !unsigned_val)
2668
{
2669
int3store(ptr,0);
2670
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2671
error= 1;
2672
}
2673
else if ((uint64_t) nr >= (uint64_t) (long) (1L << 24))
2674
{
2675
long tmp= (long) (1L << 24)-1L;
2676
int3store(ptr,tmp);
2677
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2678
error= 1;
2679
}
2680
else
2681
int3store(ptr,(uint32) nr);
2682
}
2683
else
2684
{
2685
if (nr < 0 && unsigned_val)
2686
nr= (uint64_t) (long) (1L << 24); // Generate overflow
2687
2688
if (nr < (longlong) INT_MIN24)
2689
{
2690
long tmp= (long) INT_MIN24;
2691
int3store(ptr,tmp);
2692
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2693
error= 1;
2694
}
2695
else if (nr > (longlong) INT_MAX24)
2696
{
2697
long tmp=(long) INT_MAX24;
2698
int3store(ptr,tmp);
2699
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2700
error= 1;
2701
}
2702
else
2703
int3store(ptr,(long) nr);
2704
}
2705
return error;
2706
}
2707
2708
2709
double Field_medium::val_real(void)
2710
{
2711
ASSERT_COLUMN_MARKED_FOR_READ;
2712
long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
2713
return (double) j;
2714
}
2715
2716
2717
longlong Field_medium::val_int(void)
2718
{
2719
ASSERT_COLUMN_MARKED_FOR_READ;
2720
long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
2721
return (longlong) j;
2722
}
2723
2724
2725
String *Field_medium::val_str(String *val_buffer,
2726
String *val_ptr __attribute__((unused)))
2727
{
2728
ASSERT_COLUMN_MARKED_FOR_READ;
2729
CHARSET_INFO *cs= &my_charset_bin;
2730
uint length;
2731
uint mlength=max(field_length+1,10*cs->mbmaxlen);
2732
val_buffer->alloc(mlength);
2733
char *to=(char*) val_buffer->ptr();
2734
long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
2735
2736
length=(uint) cs->cset->long10_to_str(cs,to,mlength,-10,j);
2737
val_buffer->length(length);
2738
if (zerofill)
2739
prepend_zeros(val_buffer); /* purecov: inspected */
2740
return val_buffer;
2741
}
2742
2743
2744
bool Field_medium::send_binary(Protocol *protocol)
2745
{
2746
ASSERT_COLUMN_MARKED_FOR_READ;
2747
return protocol->store_long(Field_medium::val_int());
2748
}
2749
2750
2751
int Field_medium::cmp(const uchar *a_ptr, const uchar *b_ptr)
2752
{
2753
long a,b;
2754
if (unsigned_flag)
2755
{
2756
a=uint3korr(a_ptr);
2757
b=uint3korr(b_ptr);
2758
}
2759
else
2760
{
2761
a=sint3korr(a_ptr);
2762
b=sint3korr(b_ptr);
2763
}
2764
return (a < b) ? -1 : (a > b) ? 1 : 0;
2765
}
2766
2767
void Field_medium::sort_string(uchar *to,uint length __attribute__((unused)))
2768
{
2769
if (unsigned_flag)
2770
to[0] = ptr[2];
2771
else
2772
to[0] = (uchar) (ptr[2] ^ 128); /* Revers signbit */
2773
to[1] = ptr[1];
2774
to[2] = ptr[0];
2775
}
2776
2777
2778
void Field_medium::sql_type(String &res) const
2779
{
2780
CHARSET_INFO *cs=res.charset();
2781
res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
2782
"mediumint(%d)",(int) field_length));
2783
add_zerofill_and_unsigned(res);
2784
}
2785
2786
/****************************************************************************
2787
2401
** long int
2788
2402
****************************************************************************/
2789
2403
2790
2404
int Field_long::store(const char *from,uint len,CHARSET_INFO *cs)
2791
2405
{
2792
ASSERT_COLUMN_MARKED_FOR_WRITE;
2793
2406
long store_tmp;
2794
2407
int error;
2795
2408
longlong rnd;
2810
2423
2811
2424
int Field_long::store(double nr)
2812
2425
{
2813
ASSERT_COLUMN_MARKED_FOR_WRITE;
2814
2426
int error= 0;
2815
2427
int32 res;
2816
2428
nr=rint(nr);
2862
2474
2863
2475
int Field_long::store(longlong nr, bool unsigned_val)
2864
2476
{
2865
ASSERT_COLUMN_MARKED_FOR_WRITE;
2866
2477
int error= 0;
2867
2478
int32 res;
2868
2479
2915
2526
2916
2527
double Field_long::val_real(void)
2917
2528
{
2918
ASSERT_COLUMN_MARKED_FOR_READ;
2919
2529
int32 j;
2920
2530
#ifdef WORDS_BIGENDIAN
2921
2531
if (table->s->db_low_byte_first)
2928
2538
2929
2539
longlong Field_long::val_int(void)
2930
2540
{
2931
ASSERT_COLUMN_MARKED_FOR_READ;
2932
2541
int32 j;
2933
2542
/* See the comment in Field_long::store(long long) */
2934
DBUG_ASSERT(table->in_use == current_thd);
2543
assert(table->in_use == current_thd);
2935
2544
#ifdef WORDS_BIGENDIAN
2936
2545
if (table->s->db_low_byte_first)
2937
2546
j=sint4korr(ptr);
2944
2553
String *Field_long::val_str(String *val_buffer,
2945
2554
String *val_ptr __attribute__((unused)))
2946
2555
{
2947
ASSERT_COLUMN_MARKED_FOR_READ;
2948
2556
CHARSET_INFO *cs= &my_charset_bin;
2949
2557
uint length;
2950
2558
uint mlength=max(field_length+1,12*cs->mbmaxlen);
2971
2579
2972
2580
bool Field_long::send_binary(Protocol *protocol)
2973
2581
{
2974
ASSERT_COLUMN_MARKED_FOR_READ;
2975
2582
return protocol->store_long(Field_long::val_int());
2976
2583
}
2977
2584
3036
2643
3037
2644
int Field_longlong::store(const char *from,uint len,CHARSET_INFO *cs)
3038
2645
{
3039
ASSERT_COLUMN_MARKED_FOR_WRITE;
3040
2646
int error= 0;
3041
2647
char *end;
3042
2648
uint64_t tmp;
3066
2672
3067
2673
int Field_longlong::store(double nr)
3068
2674
{
3069
ASSERT_COLUMN_MARKED_FOR_WRITE;
3070
2675
int error= 0;
3071
2676
longlong res;
3072
2677
3118
2723
3119
2724
int Field_longlong::store(longlong nr, bool unsigned_val)
3120
2725
{
3121
ASSERT_COLUMN_MARKED_FOR_WRITE;
3122
2726
int error= 0;
3123
2727
3124
2728
if (nr < 0) // Only possible error
3149
2753
3150
2754
double Field_longlong::val_real(void)
3151
2755
{
3152
ASSERT_COLUMN_MARKED_FOR_READ;
3153
2756
longlong j;
3154
2757
#ifdef WORDS_BIGENDIAN
3155
2758
if (table->s->db_low_byte_first)
3171
2774
3172
2775
longlong Field_longlong::val_int(void)
3173
2776
{
3174
ASSERT_COLUMN_MARKED_FOR_READ;
3175
2777
longlong j;
3176
2778
#ifdef WORDS_BIGENDIAN
3177
2779
if (table->s->db_low_byte_first)
3210
2812
3211
2813
bool Field_longlong::send_binary(Protocol *protocol)
3212
2814
{
3213
ASSERT_COLUMN_MARKED_FOR_READ;
3214
2815
return protocol->store_longlong(Field_longlong::val_int(), unsigned_flag);
3215
2816
}
3216
2817
3288
2889
Field_real::pack(uchar *to, const uchar *from,
3289
2890
uint max_length, bool low_byte_first)
3290
2891
{
3291
DBUG_ENTER("Field_real::pack");
3292
DBUG_ASSERT(max_length >= pack_length());
3293
DBUG_PRINT("debug", ("pack_length(): %u", pack_length()));
2892
assert(max_length >= pack_length());
3294
2893
#ifdef WORDS_BIGENDIAN
3295
2894
if (low_byte_first != table->s->db_low_byte_first)
3296
2895
{
3297
2896
const uchar *dptr= from + pack_length();
3298
2897
while (dptr-- > from)
3299
2898
*to++ = *dptr;
3300
DBUG_RETURN(to);
2899
return(to);
3301
2900
}
3302
2901
else
3303
2902
#endif
3304
DBUG_RETURN(Field::pack(to, from, max_length, low_byte_first));
2903
return(Field::pack(to, from, max_length, low_byte_first));
3305
2904
}
3306
2905
3307
2906
const uchar *
3308
2907
Field_real::unpack(uchar *to, const uchar *from,
3309
2908
uint param_data, bool low_byte_first)
3310
2909
{
3311
DBUG_ENTER("Field_real::unpack");
3312
DBUG_PRINT("debug", ("pack_length(): %u", pack_length()));
3313
2910
#ifdef WORDS_BIGENDIAN
3314
2911
if (low_byte_first != table->s->db_low_byte_first)
3315
2912
{
3316
2913
const uchar *dptr= from + pack_length();
3317
2914
while (dptr-- > from)
3318
2915
*to++ = *dptr;
3319
DBUG_RETURN(from + pack_length());
2916
return(from + pack_length());
3320
2917
}
3321
2918
else
3322
2919
#endif
3323
DBUG_RETURN(Field::unpack(to, from, param_data, low_byte_first));
2920
return(Field::unpack(to, from, param_data, low_byte_first));
3324
2921
}
3325
2922
3326
2923
/****************************************************************************
3345
2942
3346
2943
int Field_float::store(double nr)
3347
2944
{
3348
ASSERT_COLUMN_MARKED_FOR_WRITE;
3349
2945
int error= truncate(&nr, FLT_MAX);
3350
2946
float j= (float)nr;
3351
2947
3370
2966
3371
2967
double Field_float::val_real(void)
3372
2968
{
3373
ASSERT_COLUMN_MARKED_FOR_READ;
3374
2969
float j;
3375
2970
#ifdef WORDS_BIGENDIAN
3376
2971
if (table->s->db_low_byte_first)
3401
2996
String *Field_float::val_str(String *val_buffer,
3402
2997
String *val_ptr __attribute__((unused)))
3403
2998
{
3404
ASSERT_COLUMN_MARKED_FOR_READ;
3405
2999
float nr;
3406
3000
#ifdef WORDS_BIGENDIAN
3407
3001
if (table->s->db_low_byte_first)
3500
3094
3501
3095
bool Field_float::send_binary(Protocol *protocol)
3502
3096
{
3503
ASSERT_COLUMN_MARKED_FOR_READ;
3504
3097
return protocol->store((float) Field_float::val_real(), dec, (String*) 0);
3505
3098
}
3506
3099
3559
3152
3560
3153
int Field_double::store(double nr)
3561
3154
{
3562
ASSERT_COLUMN_MARKED_FOR_WRITE;
3563
3155
int error= truncate(&nr, DBL_MAX);
3564
3156
3565
3157
#ifdef WORDS_BIGENDIAN
3651
3243
3652
3244
double Field_double::val_real(void)
3653
3245
{
3654
ASSERT_COLUMN_MARKED_FOR_READ;
3655
3246
double j;
3656
3247
#ifdef WORDS_BIGENDIAN
3657
3248
if (table->s->db_low_byte_first)
3666
3257
3667
3258
longlong Field_double::val_int(void)
3668
3259
{
3669
ASSERT_COLUMN_MARKED_FOR_READ;
3670
3260
double j;
3671
3261
longlong res;
3672
3262
#ifdef WORDS_BIGENDIAN
3706
3296
3707
3297
my_decimal *Field_real::val_decimal(my_decimal *decimal_value)
3708
3298
{
3709
ASSERT_COLUMN_MARKED_FOR_READ;
3710
3299
double2my_decimal(E_DEC_FATAL_ERROR, val_real(), decimal_value);
3711
3300
return decimal_value;
3712
3301
}
3715
3304
String *Field_double::val_str(String *val_buffer,
3716
3305
String *val_ptr __attribute__((unused)))
3717
3306
{
3718
ASSERT_COLUMN_MARKED_FOR_READ;
3719
3307
double nr;
3720
3308
#ifdef WORDS_BIGENDIAN
3721
3309
if (table->s->db_low_byte_first)
3750
3338
3751
3339
int Field_double::cmp(const uchar *a_ptr, const uchar *b_ptr)
3752
3340
{
3753
ASSERT_COLUMN_MARKED_FOR_READ;
3754
3341
double a,b;
3755
3342
#ifdef WORDS_BIGENDIAN
3756
3343
if (table->s->db_low_byte_first)
3921
3508
function should be called only for first of them (i.e. the one
3922
3509
having auto-set property).
3923
3510
*/
3924
DBUG_ASSERT(table->timestamp_field == this);
3511
assert(table->timestamp_field == this);
3925
3512
/* Fall-through */
3926
3513
case TIMESTAMP_DNUN_FIELD:
3927
3514
return TIMESTAMP_AUTO_SET_ON_BOTH;
3930
3517
Normally this function should not be called for TIMESTAMPs without
3931
3518
auto-set property.
3932
3519
*/
3933
DBUG_ASSERT(0);
3520
assert(0);
3934
3521
return TIMESTAMP_NO_AUTO_SET;
3935
3522
}
3936
3523
}
3940
3527
uint len,
3941
3528
CHARSET_INFO *cs __attribute__((__unused__)))
3942
3529
{
3943
ASSERT_COLUMN_MARKED_FOR_WRITE;
3944
3530
MYSQL_TIME l_time;
3945
3531
my_time_t tmp= 0;
3946
3532
int error;
3993
3579
nr= 0; // Avoid overflow on buff
3994
3580
error= 1;
3995
3581
}
3996
error|= Field_timestamp::store((longlong) rint(nr), FALSE);
3582
error|= Field_timestamp::store((longlong) rint(nr), false);
3997
3583
return error;
3998
3584
}
3999
3585
4001
3587
int Field_timestamp::store(longlong nr,
4002
3588
bool unsigned_val __attribute__((__unused__)))
4003
3589
{
4004
ASSERT_COLUMN_MARKED_FOR_WRITE;
4005
3590
MYSQL_TIME l_time;
4006
3591
my_time_t timestamp= 0;
4007
3592
int error;
4044
3629
4045
3630
double Field_timestamp::val_real(void)
4046
3631
{
4047
ASSERT_COLUMN_MARKED_FOR_READ;
4048
3632
return (double) Field_timestamp::val_int();
4049
3633
}
4050
3634
4051
3635
longlong Field_timestamp::val_int(void)
4052
3636
{
4053
ASSERT_COLUMN_MARKED_FOR_READ;
4054
3637
uint32 temp;
4055
3638
MYSQL_TIME time_tmp;
4056
3639
THD *thd= table ? table->in_use : current_thd;
4076
3659
4077
3660
String *Field_timestamp::val_str(String *val_buffer, String *val_ptr)
4078
3661
{
4079
ASSERT_COLUMN_MARKED_FOR_READ;
4080
3662
uint32 temp, temp2;
4081
3663
MYSQL_TIME time_tmp;
4082
3664
THD *thd= table ? table->in_use : current_thd;
4297
3879
(ltime->minute * 100 + ltime->second);
4298
3880
if (ltime->neg)
4299
3881
tmp= -tmp;
4300
return Field_time::store((longlong) tmp, FALSE);
3882
return Field_time::store((longlong) tmp, false);
4301
3883
}
4302
3884
4303
3885
4304
3886
int Field_time::store(double nr)
4305
3887
{
4306
ASSERT_COLUMN_MARKED_FOR_WRITE;
4307
3888
long tmp;
4308
3889
int error= 0;
4309
3890
if (nr > (double)TIME_MAX_VALUE)
4341
3922
4342
3923
int Field_time::store(longlong nr, bool unsigned_val)
4343
3924
{
4344
ASSERT_COLUMN_MARKED_FOR_WRITE;
4345
3925
long tmp;
4346
3926
int error= 0;
4347
3927
if (nr < (longlong) -TIME_MAX_VALUE && !unsigned_val)
4379
3959
4380
3960
double Field_time::val_real(void)
4381
3961
{
4382
ASSERT_COLUMN_MARKED_FOR_READ;
4383
3962
uint32 j= (uint32) uint3korr(ptr);
4384
3963
return (double) j;
4385
3964
}
4386
3965
4387
3966
longlong Field_time::val_int(void)
4388
3967
{
4389
ASSERT_COLUMN_MARKED_FOR_READ;
4390
3968
return (longlong) sint3korr(ptr);
4391
3969
}
4392
3970
4400
3978
String *Field_time::val_str(String *val_buffer,
4401
3979
String *val_ptr __attribute__((unused)))
4402
3980
{
4403
ASSERT_COLUMN_MARKED_FOR_READ;
4404
3981
MYSQL_TIME ltime;
4405
3982
val_buffer->alloc(MAX_DATE_STRING_REP_LENGTH);
4406
3983
long tmp=(long) sint3korr(ptr);
4512
4089
4513
4090
int Field_year::store(const char *from, uint len,CHARSET_INFO *cs)
4514
4091
{
4515
ASSERT_COLUMN_MARKED_FOR_WRITE;
4516
4092
char *end;
4517
4093
int error;
4518
4094
longlong nr= cs->cset->strntoull10rnd(cs, from, len, 0, &end, &error);
4551
4127
{
4552
4128
if (nr < 0.0 || nr >= 2155.0)
4553
4129
{
4554
(void) Field_year::store((longlong) -1, FALSE);
4130
(void) Field_year::store((longlong) -1, false);
4555
4131
return 1;
4556
4132
}
4557
return Field_year::store((longlong) nr, FALSE);
4133
return Field_year::store((longlong) nr, false);
4558
4134
}
4559
4135
4560
4136
4561
4137
int Field_year::store(longlong nr,
4562
4138
bool unsigned_val __attribute__((__unused__)))
4563
4139
{
4564
ASSERT_COLUMN_MARKED_FOR_WRITE;
4565
4140
if (nr < 0 || (nr >= 100 && nr <= 1900) || nr > 2155)
4566
4141
{
4567
4142
*ptr= 0;
4582
4157
4583
4158
bool Field_year::send_binary(Protocol *protocol)
4584
4159
{
4585
ASSERT_COLUMN_MARKED_FOR_READ;
4586
4160
uint64_t tmp= Field_year::val_int();
4587
4161
return protocol->store_short(tmp);
4588
4162
}
4596
4170
4597
4171
longlong Field_year::val_int(void)
4598
4172
{
4599
ASSERT_COLUMN_MARKED_FOR_READ;
4600
4173
int tmp= (int) ptr[0];
4601
4174
if (field_length != 4)
4602
4175
tmp%=100; // Return last 2 char
4654
4227
uint len,
4655
4228
CHARSET_INFO *cs __attribute__((__unused__)))
4656
4229
{
4657
ASSERT_COLUMN_MARKED_FOR_WRITE;
4658
4230
long tmp;
4659
4231
MYSQL_TIME l_time;
4660
4232
int error;
4698
4270
WARN_DATA_TRUNCATED, nr, MYSQL_TIMESTAMP_DATE);
4699
4271
return 1;
4700
4272
}
4701
return Field_newdate::store((longlong) rint(nr), FALSE);
4273
return Field_newdate::store((longlong) rint(nr), false);
4702
4274
}
4703
4275
4704
4276
4705
4277
int Field_newdate::store(longlong nr,
4706
4278
bool unsigned_val __attribute__((__unused__)))
4707
4279
{
4708
ASSERT_COLUMN_MARKED_FOR_WRITE;
4709
4280
MYSQL_TIME l_time;
4710
4281
longlong tmp;
4711
4282
int error;
4741
4312
4742
4313
int Field_newdate::store_time(MYSQL_TIME *ltime,timestamp_type time_type)
4743
4314
{
4744
ASSERT_COLUMN_MARKED_FOR_WRITE;
4745
4315
long tmp;
4746
4316
int error= 0;
4747
4317
if (time_type == MYSQL_TIMESTAMP_DATE ||
4793
4363
4794
4364
double Field_newdate::val_real(void)
4795
4365
{
4796
ASSERT_COLUMN_MARKED_FOR_READ;
4797
4366
return (double) Field_newdate::val_int();
4798
4367
}
4799
4368
4800
4369
4801
4370
longlong Field_newdate::val_int(void)
4802
4371
{
4803
ASSERT_COLUMN_MARKED_FOR_READ;
4804
4372
ulong j= uint3korr(ptr);
4805
4373
j= (j % 32L)+(j / 32L % 16L)*100L + (j/(16L*32L))*10000L;
4806
4374
return (longlong) j;
4810
4378
String *Field_newdate::val_str(String *val_buffer,
4811
4379
String *val_ptr __attribute__((unused)))
4812
4380
{
4813
ASSERT_COLUMN_MARKED_FOR_READ;
4814
4381
val_buffer->alloc(field_length);
4815
4382
val_buffer->length(field_length);
4816
4383
uint32 tmp=(uint32) uint3korr(ptr);
4889
4456
uint len,
4890
4457
CHARSET_INFO *cs __attribute__((__unused__)))
4891
4458
{
4892
ASSERT_COLUMN_MARKED_FOR_WRITE;
4893
4459
MYSQL_TIME time_tmp;
4894
4460
int error;
4895
4461
uint64_t tmp= 0;
4935
4501
nr= 0.0;
4936
4502
error= 1;
4937
4503
}
4938
error|= Field_datetime::store((longlong) rint(nr), FALSE);
4504
error|= Field_datetime::store((longlong) rint(nr), false);
4939
4505
return error;
4940
4506
}
4941
4507
4943
4509
int Field_datetime::store(longlong nr,
4944
4510
bool unsigned_val __attribute__((__unused__)))
4945
4511
{
4946
ASSERT_COLUMN_MARKED_FOR_WRITE;
4947
4512
MYSQL_TIME not_used;
4948
4513
int error;
4949
4514
longlong initial_nr= nr;
4981
4546
4982
4547
int Field_datetime::store_time(MYSQL_TIME *ltime,timestamp_type time_type)
4983
4548
{
4984
ASSERT_COLUMN_MARKED_FOR_WRITE;
4985
4549
longlong tmp;
4986
4550
int error= 0;
4987
4551
/*
5038
4602
5039
4603
longlong Field_datetime::val_int(void)
5040
4604
{
5041
ASSERT_COLUMN_MARKED_FOR_READ;
5042
4605
longlong j;
5043
4606
#ifdef WORDS_BIGENDIAN
5044
4607
if (table && table->s->db_low_byte_first)
5053
4616
String *Field_datetime::val_str(String *val_buffer,
5054
4617
String *val_ptr __attribute__((unused)))
5055
4618
{
5056
ASSERT_COLUMN_MARKED_FOR_READ;
5057
4619
val_buffer->alloc(field_length);
5058
4620
val_buffer->length(field_length);
5059
4621
uint64_t tmp;
5203
4765
"Cannot convert character string: 'xxx' for column 't' at row 1"
5204
4766
5205
4767
RETURN
5206
FALSE - If errors didn't happen
5207
TRUE - If an error happened
4768
false - If errors didn't happen
4769
true - If an error happened
5208
4770
*/
5209
4771
5210
4772
static bool
5219
4781
5220
4782
if (!(pos= well_formed_error_pos) &&
5221
4783
!(pos= cannot_convert_error_pos))
5222
return FALSE;
4784
return false;
5223
4785
5224
4786
end_orig= end;
5225
4787
set_if_smaller(end, pos + 6);
5264
4826
ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
5265
4827
"string", tmp, field->field_name,
5266
4828
(ulong) field->table->in_use->row_count);
5267
return TRUE;
4829
return true;
5268
4830
}
5269
4831
5270
4832
5310
4872
5311
4873
int Field_string::store(const char *from,uint length,CHARSET_INFO *cs)
5312
4874
{
5313
ASSERT_COLUMN_MARKED_FOR_WRITE;
5314
4875
uint copy_length;
5315
4876
const char *well_formed_error_pos;
5316
4877
const char *cannot_convert_error_pos;
5317
4878
const char *from_end_pos;
5318
4879
5319
4880
/* See the comment for Field_long::store(long long) */
5320
DBUG_ASSERT(table->in_use == current_thd);
4881
assert(table->in_use == current_thd);
5321
4882
5322
4883
copy_length= well_formed_copy_nchars(field_charset,
5323
4884
(char*) ptr, field_length,
5351
4912
5352
4913
int Field_str::store(double nr)
5353
4914
{
5354
ASSERT_COLUMN_MARKED_FOR_WRITE;
5355
4915
char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
5356
4916
uint local_char_length= field_length / charset()->mbmaxlen;
5357
4917
size_t length;
5424
4984
5425
4985
double Field_string::val_real(void)
5426
4986
{
5427
ASSERT_COLUMN_MARKED_FOR_READ;
5428
4987
int error;
5429
4988
char *end;
5430
4989
CHARSET_INFO *cs= charset();
5450
5009
5451
5010
longlong Field_string::val_int(void)
5452
5011
{
5453
ASSERT_COLUMN_MARKED_FOR_READ;
5454
5012
int error;
5455
5013
char *end;
5456
5014
CHARSET_INFO *cs= charset();
5477
5035
String *Field_string::val_str(String *val_buffer __attribute__((unused)),
5478
5036
String *val_ptr)
5479
5037
{
5480
ASSERT_COLUMN_MARKED_FOR_READ;
5481
5038
/* See the comment for Field_long::store(long long) */
5482
DBUG_ASSERT(table->in_use == current_thd);
5039
assert(table->in_use == current_thd);
5483
5040
uint length;
5484
5041
if (table->in_use->variables.sql_mode &
5485
5042
MODE_PAD_CHAR_TO_FULL_LENGTH)
5494
5051
5495
5052
my_decimal *Field_string::val_decimal(my_decimal *decimal_value)
5496
5053
{
5497
ASSERT_COLUMN_MARKED_FOR_READ;
5498
5054
int err= str2my_decimal(E_DEC_FATAL_ERROR, (char*) ptr, field_length,
5499
5055
charset(), decimal_value);
5500
5056
if (!table->in_use->no_errors && err)
5538
5094
5539
5095
void Field_string::sort_string(uchar *to,uint length)
5540
5096
{
5541
IF_DBUG(uint tmp=) my_strnxfrm(field_charset,
5097
uint tmp= my_strnxfrm(field_charset,
5542
5098
to, length,
5543
5099
ptr, field_length);
5544
DBUG_ASSERT(tmp == length);
5100
assert(tmp == length);
5545
5101
}
5546
5102
5547
5103
5817
5373
int Field_varstring::do_save_field_metadata(uchar *metadata_ptr)
5818
5374
{
5819
5375
char *ptr= (char *)metadata_ptr;
5820
DBUG_ASSERT(field_length <= 65535);
5376
assert(field_length <= 65535);
5821
5377
int2store(ptr, field_length);
5822
5378
return 2;
5823
5379
}
5824
5380
5825
5381
int Field_varstring::store(const char *from,uint length,CHARSET_INFO *cs)
5826
5382
{
5827
ASSERT_COLUMN_MARKED_FOR_WRITE;
5828
5383
uint copy_length;
5829
5384
const char *well_formed_error_pos;
5830
5385
const char *cannot_convert_error_pos;
5868
5423
5869
5424
double Field_varstring::val_real(void)
5870
5425
{
5871
ASSERT_COLUMN_MARKED_FOR_READ;
5872
5426
int not_used;
5873
5427
char *end_not_used;
5874
5428
uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
5879
5433
5880
5434
longlong Field_varstring::val_int(void)
5881
5435
{
5882
ASSERT_COLUMN_MARKED_FOR_READ;
5883
5436
int not_used;
5884
5437
char *end_not_used;
5885
5438
uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
5890
5443
String *Field_varstring::val_str(String *val_buffer __attribute__((unused)),
5891
5444
String *val_ptr)
5892
5445
{
5893
ASSERT_COLUMN_MARKED_FOR_READ;
5894
5446
uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
5895
5447
val_ptr->set((const char*) ptr+length_bytes, length, field_charset);
5896
5448
return val_ptr;
5899
5451
5900
5452
my_decimal *Field_varstring::val_decimal(my_decimal *decimal_value)
5901
5453
{
5902
ASSERT_COLUMN_MARKED_FOR_READ;
5903
5454
uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
5904
5455
str2my_decimal(E_DEC_FATAL_ERROR, (char*) ptr+length_bytes, length,
5905
5456
charset(), decimal_value);
5994
5545
tot_length= my_strnxfrm(field_charset,
5995
5546
to, length, ptr + length_bytes,
5996
5547
tot_length);
5997
DBUG_ASSERT(tot_length == length);
5548
assert(tot_length == length);
5998
5549
}
5999
5550
6000
5551
6497
6048
6498
6049
int Field_blob::store(const char *from,uint length,CHARSET_INFO *cs)
6499
6050
{
6500
ASSERT_COLUMN_MARKED_FOR_WRITE;
6501
6051
uint copy_length, new_length;
6502
6052
const char *well_formed_error_pos;
6503
6053
const char *cannot_convert_error_pos;
6588
6138
6589
6139
double Field_blob::val_real(void)
6590
6140
{
6591
ASSERT_COLUMN_MARKED_FOR_READ;
6592
6141
int not_used;
6593
6142
char *end_not_used, *blob;
6594
6143
uint32 length;
6605
6154
6606
6155
longlong Field_blob::val_int(void)
6607
6156
{
6608
ASSERT_COLUMN_MARKED_FOR_READ;
6609
6157
int not_used;
6610
6158
char *blob;
6611
6159
memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
6618
6166
String *Field_blob::val_str(String *val_buffer __attribute__((unused)),
6619
6167
String *val_ptr)
6620
6168
{
6621
ASSERT_COLUMN_MARKED_FOR_READ;
6622
6169
char *blob;
6623
6170
memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
6624
6171
if (!blob)
6631
6178
6632
6179
my_decimal *Field_blob::val_decimal(my_decimal *decimal_value)
6633
6180
{
6634
ASSERT_COLUMN_MARKED_FOR_READ;
6635
6181
const char *blob;
6636
6182
size_t length;
6637
6183
memcpy_fixed(&blob, ptr+packlength, sizeof(const uchar*));
6812
6358
6813
6359
blob_length=my_strnxfrm(field_charset,
6814
6360
to, length, blob, blob_length);
6815
DBUG_ASSERT(blob_length == length);
6361
assert(blob_length == length);
6816
6362
}
6817
6363
}
6818
6364
6839
6385
uchar *Field_blob::pack(uchar *to, const uchar *from,
6840
6386
uint max_length, bool low_byte_first)
6841
6387
{
6842
DBUG_ENTER("Field_blob::pack");
6843
DBUG_PRINT("enter", ("to: 0x%lx; from: 0x%lx;"
6844
" max_length: %u; low_byte_first: %d",
6845
(ulong) to, (ulong) from,
6846
max_length, low_byte_first));
6847
DBUG_DUMP("record", from, table->s->reclength);
6848
6388
uchar *save= ptr;
6849
6389
ptr= (uchar*) from;
6850
6390
uint32 length=get_length(); // Length of from string
6865
6405
memcpy(to+packlength, from,length);
6866
6406
}
6867
6407
ptr=save; // Restore org row pointer
6868
DBUG_DUMP("packed", to, packlength + length);
6869
DBUG_RETURN(to+packlength+length);
6408
return(to+packlength+length);
6870
6409
}
6871
6410
6872
6411
6881
6420
6882
6421
@param to Destination of the data
6883
6422
@param from Source of the data
6884
@param param_data @c TRUE if base types should be stored in little-
6885
endian format, @c FALSE if native format should
6423
@param param_data @c true if base types should be stored in little-
6424
endian format, @c false if native format should
6886
6425
be used.
6887
6426
6888
6427
@return New pointer into memory based on from + length of the data
6892
6431
uint param_data,
6893
6432
bool low_byte_first)
6894
6433
{
6895
DBUG_ENTER("Field_blob::unpack");
6896
DBUG_PRINT("enter", ("to: 0x%lx; from: 0x%lx;"
6897
" param_data: %u; low_byte_first: %d",
6898
(ulong) to, (ulong) from, param_data, low_byte_first));
6899
6434
uint const master_packlength=
6900
6435
param_data > 0 ? param_data & 0xFF : packlength;
6901
6436
uint32 const length= get_length(from, master_packlength, low_byte_first);
6902
DBUG_DUMP("packed", from, length + master_packlength);
6903
6437
bitmap_set_bit(table->write_set, field_index);
6904
6438
store(reinterpret_cast<const char*>(from) + master_packlength,
6905
6439
length, field_charset);
6906
DBUG_DUMP("record", to, table->s->reclength);
6907
DBUG_RETURN(from + master_packlength + length);
6440
return(from + master_packlength + length);
6908
6441
}
6909
6442
6910
6443
/* Keys for blobs are like keys on varchars */
7129
6662
7130
6663
int Field_enum::store(const char *from,uint length,CHARSET_INFO *cs)
7131
6664
{
7132
ASSERT_COLUMN_MARKED_FOR_WRITE;
7133
6665
int err= 0;
7134
6666
uint32 not_used;
7135
6667
char buff[STRING_BUFFER_USUAL_SIZE];
7172
6704
7173
6705
int Field_enum::store(double nr)
7174
6706
{
7175
return Field_enum::store((longlong) nr, FALSE);
6707
return Field_enum::store((longlong) nr, false);
7176
6708
}
7177
6709
7178
6710
7179
6711
int Field_enum::store(longlong nr,
7180
6712
bool unsigned_val __attribute__((__unused__)))
7181
6713
{
7182
ASSERT_COLUMN_MARKED_FOR_WRITE;
7183
6714
int error= 0;
7184
6715
if ((uint64_t) nr > typelib->count || nr == 0)
7185
6716
{
7203
6734
7204
6735
longlong Field_enum::val_int(void)
7205
6736
{
7206
ASSERT_COLUMN_MARKED_FOR_READ;
7207
6737
switch (packlength) {
7208
6738
case 1:
7209
6739
return (longlong) ptr[0];
7348
6878
7349
6879
int Field_set::store(const char *from,uint length,CHARSET_INFO *cs)
7350
6880
{
7351
ASSERT_COLUMN_MARKED_FOR_WRITE;
7352
6881
bool got_warning= 0;
7353
6882
int err= 0;
7354
6883
char *not_used;
7389
6918
int Field_set::store(longlong nr,
7390
6919
bool unsigned_val __attribute__((__unused__)))
7391
6920
{
7392
ASSERT_COLUMN_MARKED_FOR_WRITE;
7393
6921
int error= 0;
7394
6922
uint64_t max_nr= set_bits(uint64_t, typelib->count);
7395
6923
if ((uint64_t) nr > max_nr)
7529
7057
void Create_field::create_length_to_internal_length(void)
7530
7058
{
7531
7059
switch (sql_type) {
7532
case MYSQL_TYPE_TINY_BLOB:
7533
case MYSQL_TYPE_MEDIUM_BLOB:
7534
case MYSQL_TYPE_LONG_BLOB:
7535
7060
case MYSQL_TYPE_BLOB:
7536
7061
case MYSQL_TYPE_VAR_STRING:
7537
7062
case MYSQL_TYPE_STRING:
7598
7123
@param fld_charset Field charset
7599
7124
7600
7125
@retval
7601
FALSE on success
7126
false on success
7602
7127
@retval
7603
TRUE on error
7128
true on error
7604
7129
*/
7605
7130
7606
7131
bool Create_field::init(THD *thd, char *fld_name, enum_field_types fld_type,
7615
7140
uint sign_len, allowed_type_modifier= 0;
7616
7141
ulong max_field_charlength= MAX_FIELD_CHARLENGTH;
7617
7142
7618
DBUG_ENTER("Create_field::init()");
7619
7620
7143
field= 0;
7621
7144
field_name= fld_name;
7622
7145
def= fld_default_value;
7629
7152
{
7630
7153
my_error(ER_TOO_BIG_SCALE, MYF(0), decimals, fld_name,
7631
7154
NOT_FIXED_DEC-1);
7632
DBUG_RETURN(TRUE);
7155
return(true);
7633
7156
}
7634
7157
7635
7158
sql_type= fld_type;
7664
7187
length= MAX_SMALLINT_WIDTH+sign_len;
7665
7188
allowed_type_modifier= AUTO_INCREMENT_FLAG;
7666
7189
break;
7667
case MYSQL_TYPE_INT24:
7668
if (!fld_length)
7669
length= MAX_MEDIUMINT_WIDTH+sign_len;
7670
allowed_type_modifier= AUTO_INCREMENT_FLAG;
7671
break;
7672
7190
case MYSQL_TYPE_LONG:
7673
7191
if (!fld_length)
7674
7192
length= MAX_INT_WIDTH+sign_len;
7687
7205
{
7688
7206
my_error(ER_TOO_BIG_PRECISION, MYF(0), length, fld_name,
7689
7207
DECIMAL_MAX_PRECISION);
7690
DBUG_RETURN(TRUE);
7208
return(true);
7691
7209
}
7692
7210
if (length < decimals)
7693
7211
{
7694
7212
my_error(ER_M_BIGGER_THAN_D, MYF(0), fld_name);
7695
DBUG_RETURN(TRUE);
7213
return(true);
7696
7214
}
7697
7215
length=
7698
7216
my_decimal_precision_to_length(length, decimals,
7710
7228
case MYSQL_TYPE_STRING:
7711
7229
break;
7712
7230
case MYSQL_TYPE_BLOB:
7713
case MYSQL_TYPE_TINY_BLOB:
7714
case MYSQL_TYPE_LONG_BLOB:
7715
case MYSQL_TYPE_MEDIUM_BLOB:
7716
7231
if (fld_default_value)
7717
7232
{
7718
7233
/* Allow empty as default value. */
7728
7243
{
7729
7244
my_error(ER_BLOB_CANT_HAVE_DEFAULT, MYF(0),
7730
7245
fld_name); /* purecov: inspected */
7731
DBUG_RETURN(TRUE);
7246
return(true);
7732
7247
}
7733
7248
else
7734
7249
{
7758
7273
if (tmp_length > PRECISION_FOR_DOUBLE)
7759
7274
{
7760
7275
my_error(ER_WRONG_FIELD_SPEC, MYF(0), fld_name);
7761
DBUG_RETURN(TRUE);
7276
return(true);
7762
7277
}
7763
7278
else if (tmp_length > PRECISION_FOR_FLOAT)
7764
7279
{
7779
7294
decimals != NOT_FIXED_DEC)
7780
7295
{
7781
7296
my_error(ER_M_BIGGER_THAN_D, MYF(0), fld_name);
7782
DBUG_RETURN(TRUE);
7297
return(true);
7783
7298
}
7784
7299
break;
7785
7300
case MYSQL_TYPE_DOUBLE:
7793
7308
decimals != NOT_FIXED_DEC)
7794
7309
{
7795
7310
my_error(ER_M_BIGGER_THAN_D, MYF(0), fld_name);
7796
DBUG_RETURN(TRUE);
7311
return(true);
7797
7312
}
7798
7313
break;
7799
7314
case MYSQL_TYPE_TIMESTAMP:
7892
7407
break;
7893
7408
}
7894
7409
case MYSQL_TYPE_VAR_STRING:
7895
DBUG_ASSERT(0); /* Impossible. */
7410
assert(0); /* Impossible. */
7896
7411
break;
7897
7412
}
7898
7413
/* Remember the value of length */
7912
7427
ER_TOO_BIG_DISPLAYWIDTH,
7913
7428
MYF(0),
7914
7429
fld_name, max_field_charlength); /* purecov: inspected */
7915
DBUG_RETURN(TRUE);
7430
return(true);
7916
7431
}
7917
7432
fld_type_modifier&= AUTO_INCREMENT_FLAG;
7918
7433
if ((~allowed_type_modifier) & fld_type_modifier)
7919
7434
{
7920
7435
my_error(ER_WRONG_FIELD_SPEC, MYF(0), fld_name);
7921
DBUG_RETURN(TRUE);
7436
return(true);
7922
7437
}
7923
7438
7924
DBUG_RETURN(FALSE); /* success */
7439
return(false); /* success */
7925
7440
}
7926
7441
7927
7442
7948
7463
case MYSQL_TYPE_YEAR:
7949
7464
case MYSQL_TYPE_TINY : return 1;
7950
7465
case MYSQL_TYPE_SHORT : return 2;
7951
case MYSQL_TYPE_INT24:
7952
7466
case MYSQL_TYPE_DATE:
7953
7467
case MYSQL_TYPE_NEWDATE:
7954
7468
case MYSQL_TYPE_TIME: return 3;
7975
7489
switch (type) {
7976
7490
case 1: return f_settype((uint) MYSQL_TYPE_TINY);
7977
7491
case 2: return f_settype((uint) MYSQL_TYPE_SHORT);
7978
case 3: return f_settype((uint) MYSQL_TYPE_INT24);
7492
case 3: assert(1);
7979
7493
case 4: return f_settype((uint) MYSQL_TYPE_LONG);
7980
7494
case 8: return f_settype((uint) MYSQL_TYPE_LONGLONG);
7981
7495
}
8081
7595
unireg_check, field_name,
8082
7596
f_is_zerofill(pack_flag) != 0,
8083
7597
f_is_dec(pack_flag) == 0);
8084
case MYSQL_TYPE_INT24:
8085
return new Field_medium(ptr,field_length,null_pos,null_bit,
8086
unireg_check, field_name,
8087
f_is_zerofill(pack_flag) != 0,
8088
f_is_dec(pack_flag) == 0);
8089
7598
case MYSQL_TYPE_LONG:
8090
7599
return new Field_long(ptr,field_length,null_pos,null_bit,
8091
7600
unireg_check, field_name,
8221
7730
case 4:
8222
7731
return (uint32) 4294967295U;
8223
7732
default:
8224
DBUG_ASSERT(0); // we should never go here
7733
assert(0); // we should never go here
8225
7734
return 0;
8226
7735
}
8227
7736
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1