← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.cc

Merged in changes from Andrey.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field.cc
62
62
  {
63
63
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
64
64
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_NEWDECIMAL,
65
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
66
 
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_NEWDECIMAL,
 
65
  //DRIZZLE_TYPE_LONG
 
66
    DRIZZLE_TYPE_NEWDECIMAL,
67
67
  //DRIZZLE_TYPE_DOUBLE
68
68
    DRIZZLE_TYPE_DOUBLE,
69
69
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
70
70
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
71
71
  //DRIZZLE_TYPE_LONGLONG
72
72
    DRIZZLE_TYPE_NEWDECIMAL,
73
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
74
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
73
  //DRIZZLE_TYPE_TIME
 
74
    DRIZZLE_TYPE_VARCHAR,
75
75
  //DRIZZLE_TYPE_DATETIME
76
76
    DRIZZLE_TYPE_VARCHAR,
77
77
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
87
87
  {
88
88
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
89
89
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_TINY,
90
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
91
 
    DRIZZLE_TYPE_SHORT,       DRIZZLE_TYPE_LONG,
 
90
  //DRIZZLE_TYPE_LONG
 
91
    DRIZZLE_TYPE_LONG,
92
92
  //DRIZZLE_TYPE_DOUBLE
93
93
    DRIZZLE_TYPE_DOUBLE,
94
94
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
95
95
    DRIZZLE_TYPE_TINY,        DRIZZLE_TYPE_VARCHAR,
96
96
  //DRIZZLE_TYPE_LONGLONG
97
97
    DRIZZLE_TYPE_LONGLONG,
98
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
99
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
100
 
  //DRIZZLE_TYPE_DATETIME
 
98
  //DRIZZLE_TYPE_TIME
101
99
    DRIZZLE_TYPE_VARCHAR,
102
 
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
103
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
104
 
  // DRIZZLE_TYPE_VIRTUAL
105
 
    DRIZZLE_TYPE_VIRTUAL,
106
 
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
107
 
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
108
 
  //DRIZZLE_TYPE_BLOB
109
 
    DRIZZLE_TYPE_BLOB,
110
 
  },
111
 
  /* DRIZZLE_TYPE_SHORT -> */
112
 
  {
113
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
114
 
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_SHORT,
115
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
116
 
    DRIZZLE_TYPE_SHORT,       DRIZZLE_TYPE_LONG,
117
 
  //DRIZZLE_TYPE_DOUBLE
118
 
    DRIZZLE_TYPE_DOUBLE,
119
 
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
120
 
    DRIZZLE_TYPE_SHORT,       DRIZZLE_TYPE_VARCHAR,
121
 
  //DRIZZLE_TYPE_LONGLONG
122
 
    DRIZZLE_TYPE_LONGLONG,
123
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
124
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
125
100
  //DRIZZLE_TYPE_DATETIME
126
101
    DRIZZLE_TYPE_VARCHAR,
127
102
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
137
112
  {
138
113
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
139
114
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_LONG,
140
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
141
 
    DRIZZLE_TYPE_LONG,        DRIZZLE_TYPE_LONG,
 
115
  //DRIZZLE_TYPE_LONG
 
116
    DRIZZLE_TYPE_LONG,
142
117
  //DRIZZLE_TYPE_DOUBLE
143
118
    DRIZZLE_TYPE_DOUBLE,
144
119
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
145
120
    DRIZZLE_TYPE_LONG,         DRIZZLE_TYPE_VARCHAR,
146
121
  //DRIZZLE_TYPE_LONGLONG
147
122
    DRIZZLE_TYPE_LONGLONG,
148
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
149
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
123
  //DRIZZLE_TYPE_TIME
 
124
    DRIZZLE_TYPE_VARCHAR,
150
125
  //DRIZZLE_TYPE_DATETIME
151
126
    DRIZZLE_TYPE_VARCHAR,
152
127
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
162
137
  {
163
138
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
164
139
    DRIZZLE_TYPE_DOUBLE,      DRIZZLE_TYPE_DOUBLE,
165
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
166
 
    DRIZZLE_TYPE_DOUBLE,      DRIZZLE_TYPE_DOUBLE,
 
140
  //DRIZZLE_TYPE_LONG
 
141
    DRIZZLE_TYPE_DOUBLE,
167
142
  //DRIZZLE_TYPE_DOUBLE
168
143
    DRIZZLE_TYPE_DOUBLE,
169
144
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
170
145
    DRIZZLE_TYPE_DOUBLE,      DRIZZLE_TYPE_VARCHAR,
171
146
  //DRIZZLE_TYPE_LONGLONG
172
147
    DRIZZLE_TYPE_DOUBLE,
173
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
174
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
148
  //DRIZZLE_TYPE_TIME
 
149
    DRIZZLE_TYPE_VARCHAR,
175
150
  //DRIZZLE_TYPE_DATETIME
176
151
    DRIZZLE_TYPE_VARCHAR,
177
152
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
187
162
  {
188
163
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
189
164
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_TINY,
190
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
191
 
    DRIZZLE_TYPE_SHORT,       DRIZZLE_TYPE_LONG,
 
165
  //DRIZZLE_TYPE_LONG
 
166
    DRIZZLE_TYPE_LONG,
192
167
  //DRIZZLE_TYPE_DOUBLE
193
168
    DRIZZLE_TYPE_DOUBLE,
194
169
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
195
170
    DRIZZLE_TYPE_NULL,        DRIZZLE_TYPE_TIMESTAMP,
196
171
  //DRIZZLE_TYPE_LONGLONG
197
172
    DRIZZLE_TYPE_LONGLONG,
198
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
199
 
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_TIME,
 
173
  //DRIZZLE_TYPE_TIME
 
174
    DRIZZLE_TYPE_TIME,
200
175
  //DRIZZLE_TYPE_DATETIME
201
176
    DRIZZLE_TYPE_DATETIME,
202
177
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
212
187
  {
213
188
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
214
189
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
215
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
216
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
190
  //DRIZZLE_TYPE_LONG
 
191
    DRIZZLE_TYPE_VARCHAR,
217
192
  //DRIZZLE_TYPE_DOUBLE
218
193
    DRIZZLE_TYPE_VARCHAR,
219
194
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
220
195
    DRIZZLE_TYPE_TIMESTAMP,   DRIZZLE_TYPE_TIMESTAMP,
221
196
  //DRIZZLE_TYPE_LONGLONG
222
197
    DRIZZLE_TYPE_VARCHAR,
223
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
224
 
    DRIZZLE_TYPE_DATETIME,    DRIZZLE_TYPE_DATETIME,
 
198
  //DRIZZLE_TYPE_TIME
 
199
    DRIZZLE_TYPE_DATETIME,
225
200
  //DRIZZLE_TYPE_DATETIME
226
201
    DRIZZLE_TYPE_DATETIME,
227
202
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
237
212
  {
238
213
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
239
214
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_LONGLONG,
240
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
241
 
    DRIZZLE_TYPE_LONGLONG,    DRIZZLE_TYPE_LONGLONG,
 
215
  //DRIZZLE_TYPE_LONG
 
216
    DRIZZLE_TYPE_LONGLONG,
242
217
  //DRIZZLE_TYPE_DOUBLE
243
218
    DRIZZLE_TYPE_DOUBLE,
244
219
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
245
220
    DRIZZLE_TYPE_LONGLONG,    DRIZZLE_TYPE_VARCHAR,
246
221
  //DRIZZLE_TYPE_LONGLONG
247
222
    DRIZZLE_TYPE_LONGLONG,
248
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
249
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
223
  //DRIZZLE_TYPE_TIME
 
224
    DRIZZLE_TYPE_VARCHAR,
250
225
  //DRIZZLE_TYPE_DATETIME
251
226
    DRIZZLE_TYPE_VARCHAR,
252
227
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
258
233
  //DRIZZLE_TYPE_BLOB
259
234
    DRIZZLE_TYPE_BLOB,
260
235
  },
261
 
  /* DRIZZLE_TYPE_DATE -> */
262
 
  {
263
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
264
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
265
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
266
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
267
 
  //DRIZZLE_TYPE_DOUBLE
268
 
    DRIZZLE_TYPE_VARCHAR,
269
 
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
270
 
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_DATETIME,
271
 
  //DRIZZLE_TYPE_LONGLONG
272
 
    DRIZZLE_TYPE_VARCHAR,
273
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
274
 
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_DATETIME,
275
 
  //DRIZZLE_TYPE_DATETIME
276
 
    DRIZZLE_TYPE_DATETIME,
277
 
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
278
 
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_VARCHAR,
279
 
  // DRIZZLE_TYPE_VIRTUAL
280
 
    DRIZZLE_TYPE_VIRTUAL,
281
 
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
282
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
283
 
  //DRIZZLE_TYPE_BLOB
284
 
    DRIZZLE_TYPE_BLOB,
285
 
  },
286
236
  /* DRIZZLE_TYPE_TIME -> */
287
237
  {
288
238
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
289
239
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
290
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
291
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
240
  //DRIZZLE_TYPE_LONG
 
241
    DRIZZLE_TYPE_VARCHAR,
292
242
  //DRIZZLE_TYPE_DOUBLE
293
243
    DRIZZLE_TYPE_VARCHAR,
294
244
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
295
245
    DRIZZLE_TYPE_TIME,        DRIZZLE_TYPE_DATETIME,
296
246
  //DRIZZLE_TYPE_LONGLONG
297
247
    DRIZZLE_TYPE_VARCHAR,
298
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
299
 
    DRIZZLE_TYPE_DATETIME,    DRIZZLE_TYPE_TIME,
 
248
  //DRIZZLE_TYPE_TIME
 
249
    DRIZZLE_TYPE_TIME,
300
250
  //DRIZZLE_TYPE_DATETIME
301
251
    DRIZZLE_TYPE_DATETIME,
302
252
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
312
262
  {
313
263
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
314
264
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
315
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
316
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
265
  //DRIZZLE_TYPE_LONG
 
266
    DRIZZLE_TYPE_VARCHAR,
317
267
  //DRIZZLE_TYPE_DOUBLE
318
268
    DRIZZLE_TYPE_VARCHAR,
319
269
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
320
270
    DRIZZLE_TYPE_DATETIME,    DRIZZLE_TYPE_DATETIME,
321
271
  //DRIZZLE_TYPE_LONGLONG
322
272
    DRIZZLE_TYPE_VARCHAR,
323
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
324
 
    DRIZZLE_TYPE_DATETIME,    DRIZZLE_TYPE_DATETIME,
 
273
  //DRIZZLE_TYPE_TIME
 
274
    DRIZZLE_TYPE_DATETIME,
325
275
  //DRIZZLE_TYPE_DATETIME
326
276
    DRIZZLE_TYPE_DATETIME,
327
277
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
337
287
  {
338
288
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
339
289
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
340
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
341
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
290
  //DRIZZLE_TYPE_LONG
 
291
    DRIZZLE_TYPE_VARCHAR,
342
292
  //DRIZZLE_TYPE_DOUBLE
343
293
    DRIZZLE_TYPE_VARCHAR,
344
294
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
345
295
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_DATETIME,
346
296
  //DRIZZLE_TYPE_LONGLONG
347
297
    DRIZZLE_TYPE_VARCHAR,
348
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
349
 
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_DATETIME,
 
298
  //DRIZZLE_TYPE_TIME
 
299
    DRIZZLE_TYPE_DATETIME,
350
300
  //DRIZZLE_TYPE_DATETIME
351
301
    DRIZZLE_TYPE_DATETIME,
352
302
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
362
312
  {
363
313
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
364
314
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
365
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
366
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
315
  //DRIZZLE_TYPE_LONG
 
316
    DRIZZLE_TYPE_VARCHAR,
367
317
  //DRIZZLE_TYPE_DOUBLE
368
318
    DRIZZLE_TYPE_VARCHAR,
369
319
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
370
320
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
371
321
  //DRIZZLE_TYPE_LONGLONG
372
322
    DRIZZLE_TYPE_VARCHAR,
373
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
374
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
323
  //DRIZZLE_TYPE_TIME
 
324
    DRIZZLE_TYPE_VARCHAR,
375
325
  //DRIZZLE_TYPE_DATETIME
376
326
    DRIZZLE_TYPE_VARCHAR,
377
327
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
387
337
  {
388
338
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
389
339
    DRIZZLE_TYPE_VIRTUAL,  DRIZZLE_TYPE_VIRTUAL,
390
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
391
 
    DRIZZLE_TYPE_VIRTUAL,  DRIZZLE_TYPE_VIRTUAL,
 
340
  //DRIZZLE_TYPE_LONG
 
341
    DRIZZLE_TYPE_VIRTUAL,
392
342
  //DRIZZLE_TYPE_DOUBLE
393
343
    DRIZZLE_TYPE_VIRTUAL,
394
344
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
395
345
    DRIZZLE_TYPE_VIRTUAL,  DRIZZLE_TYPE_VIRTUAL,
396
346
  //DRIZZLE_TYPE_LONGLONG
397
347
    DRIZZLE_TYPE_VIRTUAL,
398
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
399
 
    DRIZZLE_TYPE_VIRTUAL,     DRIZZLE_TYPE_VIRTUAL,
 
348
  //DRIZZLE_TYPE_TIME
 
349
    DRIZZLE_TYPE_VIRTUAL,
400
350
  //DRIZZLE_TYPE_DATETIME
401
351
    DRIZZLE_TYPE_VIRTUAL,
402
352
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
412
362
  {
413
363
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
414
364
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_NEWDECIMAL,
415
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
416
 
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_NEWDECIMAL,
 
365
  //DRIZZLE_TYPE_LONG
 
366
    DRIZZLE_TYPE_NEWDECIMAL,
417
367
  //DRIZZLE_TYPE_DOUBLE
418
368
    DRIZZLE_TYPE_DOUBLE,
419
369
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
420
370
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
421
371
  //DRIZZLE_TYPE_LONGLONG
422
372
    DRIZZLE_TYPE_NEWDECIMAL,
423
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
424
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
373
  //DRIZZLE_TYPE_TIME
 
374
    DRIZZLE_TYPE_VARCHAR,
425
375
  //DRIZZLE_TYPE_DATETIME
426
376
    DRIZZLE_TYPE_VARCHAR,
427
377
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
437
387
  {
438
388
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
439
389
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
440
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
441
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
390
  //DRIZZLE_TYPE_LONG
 
391
    DRIZZLE_TYPE_VARCHAR,
442
392
  //DRIZZLE_TYPE_DOUBLE
443
393
    DRIZZLE_TYPE_VARCHAR,
444
394
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
445
395
    DRIZZLE_TYPE_ENUM,        DRIZZLE_TYPE_VARCHAR,
446
396
  //DRIZZLE_TYPE_LONGLONG
447
397
    DRIZZLE_TYPE_VARCHAR,
448
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
449
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
398
  //DRIZZLE_TYPE_TIME
 
399
    DRIZZLE_TYPE_VARCHAR,
450
400
  //DRIZZLE_TYPE_DATETIME
451
401
    DRIZZLE_TYPE_VARCHAR,
452
402
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
462
412
  {
463
413
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
464
414
    DRIZZLE_TYPE_BLOB,        DRIZZLE_TYPE_BLOB,
465
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
466
 
    DRIZZLE_TYPE_BLOB,        DRIZZLE_TYPE_BLOB,
 
415
  //DRIZZLE_TYPE_LONG
 
416
    DRIZZLE_TYPE_BLOB,
467
417
  //DRIZZLE_TYPE_DOUBLE
468
418
    DRIZZLE_TYPE_BLOB,
469
419
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
470
420
    DRIZZLE_TYPE_BLOB,        DRIZZLE_TYPE_BLOB,
471
421
  //DRIZZLE_TYPE_LONGLONG
472
422
    DRIZZLE_TYPE_BLOB,
473
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
474
 
    DRIZZLE_TYPE_BLOB,        DRIZZLE_TYPE_BLOB,
 
423
  //DRIZZLE_TYPE_TIME
 
424
    DRIZZLE_TYPE_BLOB,
475
425
  //DRIZZLE_TYPE_DATETIME
476
426
    DRIZZLE_TYPE_BLOB,
477
427
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
509
459
{
510
460
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
511
461
  DECIMAL_RESULT,           INT_RESULT,
512
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
513
 
  INT_RESULT,               INT_RESULT,
 
462
  //DRIZZLE_TYPE_LONG
 
463
  INT_RESULT,
514
464
  //DRIZZLE_TYPE_DOUBLE
515
465
  REAL_RESULT,
516
466
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
517
467
  STRING_RESULT,            STRING_RESULT,
518
468
  //DRIZZLE_TYPE_LONGLONG
519
469
  INT_RESULT,
520
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
521
 
  STRING_RESULT,            STRING_RESULT,
 
470
  //DRIZZLE_TYPE_TIME
 
471
  STRING_RESULT,
522
472
  //DRIZZLE_TYPE_DATETIME
523
473
  STRING_RESULT,
524
474
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
608
558
/**
609
559
  Numeric fields base class constructor.
610
560
*/
611
 
Field_num::Field_num(uchar *ptr_arg,uint32_t len_arg, uchar *null_ptr_arg,
612
 
                     uchar null_bit_arg, utype unireg_check_arg,
 
561
Field_num::Field_num(unsigned char *ptr_arg,uint32_t len_arg, unsigned char *null_ptr_arg,
 
562
                     unsigned char null_bit_arg, utype unireg_check_arg,
613
563
                     const char *field_name_arg,
614
564
                     uint8_t dec_arg, bool zero_arg, bool unsigned_arg)
615
565
  :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
692
642
    1   error
693
643
*/
694
644
 
695
 
bool Field_num::get_int(const CHARSET_INFO * const cs, const char *from, uint len,
 
645
bool Field_num::get_int(const CHARSET_INFO * const cs, const char *from, uint32_t len,
696
646
                        int64_t *rnd, uint64_t unsigned_max, 
697
647
                        int64_t signed_min, int64_t signed_max)
698
648
{
826
776
String *Field::val_int_as_str(String *val_buffer, bool unsigned_val)
827
777
{
828
778
  const CHARSET_INFO * const cs= &my_charset_bin;
829
 
  uint length;
 
779
  uint32_t length;
830
780
  int64_t value= val_int();
831
781
 
832
782
  if (val_buffer->alloc(MY_INT64_NUM_DECIMAL_DIGITS))
833
783
    return 0;
834
 
  length= (uint) (*cs->cset->int64_t10_to_str)(cs, (char*) val_buffer->ptr(),
 
784
  length= (uint32_t) (*cs->cset->int64_t10_to_str)(cs, (char*) val_buffer->ptr(),
835
785
                                                MY_INT64_NUM_DECIMAL_DIGITS,
836
786
                                                unsigned_val ? 10 : -10,
837
787
                                                value);
841
791
 
842
792
 
843
793
/// This is used as a table name when the table structure is not set up
844
 
Field::Field(uchar *ptr_arg,uint32_t length_arg,uchar *null_ptr_arg,
845
 
             uchar null_bit_arg,
 
794
Field::Field(unsigned char *ptr_arg,uint32_t length_arg,unsigned char *null_ptr_arg,
 
795
             unsigned char null_bit_arg,
846
796
             utype unireg_check_arg, const char *field_name_arg)
847
797
  :ptr(ptr_arg), null_ptr(null_ptr_arg),
848
798
   table(0), orig_table(0), table_name(0),
868
818
  }
869
819
  else
870
820
  {
871
 
    uint len= pack_length();
 
821
    uint32_t len= pack_length();
872
822
    const CHARSET_INFO * const cs= charset();
873
823
    cs->coll->hash_sort(cs, ptr, len, nr, nr2);
874
824
  }
889
839
  memcpy(ptr,ptr+row_offset,pack_length());
890
840
  if (null_ptr)
891
841
  {
892
 
    *null_ptr= (uchar) ((null_ptr[0] & (uchar) ~(uint) null_bit) | (null_ptr[row_offset] & (uchar) null_bit));
 
842
    *null_ptr= (unsigned char) ((null_ptr[0] & (unsigned char) ~(uint32_t) null_bit) | (null_ptr[row_offset] & (unsigned char) null_bit));
893
843
  }
894
844
}
895
845
 
916
866
   @retval 0 if this field's size is < the source field's size
917
867
   @retval 1 if this field's size is >= the source field's size
918
868
*/
919
 
int Field::compatible_field_size(uint field_metadata)
 
869
int Field::compatible_field_size(uint32_t field_metadata)
920
870
{
921
 
  uint const source_size= pack_length_from_metadata(field_metadata);
922
 
  uint const destination_size= row_pack_length();
 
871
  uint32_t const source_size= pack_length_from_metadata(field_metadata);
 
872
  uint32_t const destination_size= row_pack_length();
923
873
  return (source_size <= destination_size);
924
874
}
925
875
 
926
876
 
927
 
int Field::store(const char *to, uint length, const CHARSET_INFO * const cs,
 
877
int Field::store(const char *to, uint32_t length, const CHARSET_INFO * const cs,
928
878
                 enum_check_fields check_level)
929
879
{
930
880
  int res;
973
923
   the value of this flag is a moot point since the native format is
974
924
   little-endian.
975
925
*/
976
 
uchar *
977
 
Field::pack(uchar *to, const uchar *from, uint max_length,
 
926
unsigned char *
 
927
Field::pack(unsigned char *to, const unsigned char *from, uint32_t max_length,
978
928
            bool low_byte_first __attribute__((unused)))
979
929
{
980
930
  uint32_t length= pack_length();
1013
963
 
1014
964
   @return  New pointer into memory based on from + length of the data
1015
965
*/
1016
 
const uchar *
1017
 
Field::unpack(uchar* to, const uchar *from, uint param_data,
 
966
const unsigned char *
 
967
Field::unpack(unsigned char* to, const unsigned char *from, uint32_t param_data,
1018
968
              bool low_byte_first __attribute__((unused)))
1019
969
{
1020
 
  uint length=pack_length();
 
970
  uint32_t length=pack_length();
1021
971
  int from_type= 0;
1022
972
  /*
1023
973
    If from length is > 255, it has encoded data in the upper bits. Need
1037
987
    return from+length;
1038
988
  }
1039
989
 
1040
 
  uint len= (param_data && (param_data < length)) ?
 
990
  uint32_t len= (param_data && (param_data < length)) ?
1041
991
            param_data : length;
1042
992
 
1043
993
  memcpy(to, from, param_data > length ? length : len);
1175
1125
}
1176
1126
 
1177
1127
 
1178
 
Field_str::Field_str(uchar *ptr_arg,uint32_t len_arg, uchar *null_ptr_arg,
1179
 
                     uchar null_bit_arg, utype unireg_check_arg,
 
1128
Field_str::Field_str(unsigned char *ptr_arg,uint32_t len_arg, unsigned char *null_ptr_arg,
 
1129
                     unsigned char null_bit_arg, utype unireg_check_arg,
1180
1130
                     const char *field_name_arg, const CHARSET_INFO * const charset_arg)
1181
1131
  :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
1182
1132
         unireg_check_arg, field_name_arg)
1232
1182
}
1233
1183
 
1234
1184
 
1235
 
uint Field::fill_cache_field(CACHE_FIELD *copy)
 
1185
uint32_t Field::fill_cache_field(CACHE_FIELD *copy)
1236
1186
{
1237
 
  uint store_length;
 
1187
  uint32_t store_length;
1238
1188
  copy->str=ptr;
1239
1189
  copy->length=pack_length();
1240
1190
  copy->blob_field=0;
1254
1204
}
1255
1205
 
1256
1206
 
1257
 
bool Field::get_date(DRIZZLE_TIME *ltime,uint fuzzydate)
 
1207
bool Field::get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
1258
1208
{
1259
1209
  char buff[40];
1260
1210
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
1283
1233
*/
1284
1234
 
1285
1235
int Field::store_time(DRIZZLE_TIME *ltime,
1286
 
                      timestamp_type type_arg __attribute__((unused)))
 
1236
                      enum enum_drizzle_timestamp_type type_arg __attribute__((unused)))
1287
1237
{
1288
1238
  char buff[MAX_DATE_STRING_REP_LENGTH];
1289
 
  uint length= (uint) my_TIME_to_str(ltime, buff);
 
1239
  uint32_t length= (uint32_t) my_TIME_to_str(ltime, buff);
1290
1240
  return store(buff, length, &my_charset_bin);
1291
1241
}
1292
1242
 
1293
1243
 
1294
 
bool Field::optimize_range(uint idx, uint part)
 
1244
bool Field::optimize_range(uint32_t idx, uint32_t part)
1295
1245
{
1296
1246
  return test(table->file->index_flags(idx, part, 1) & HA_READ_RANGE);
1297
1247
}
1318
1268
 
1319
1269
 
1320
1270
Field *Field::new_key_field(MEM_ROOT *root, Table *new_table,
1321
 
                            uchar *new_ptr, uchar *new_null_ptr,
1322
 
                            uint new_null_bit)
 
1271
                            unsigned char *new_ptr, unsigned char *new_null_ptr,
 
1272
                            uint32_t new_null_bit)
1323
1273
{
1324
1274
  Field *tmp;
1325
1275
  if ((tmp= new_field(root, new_table, table == new_table)))
1351
1301
** tiny int
1352
1302
****************************************************************************/
1353
1303
 
1354
 
int Field_tiny::store(const char *from,uint len, const CHARSET_INFO * const cs)
 
1304
int Field_tiny::store(const char *from,uint32_t len, const CHARSET_INFO * const cs)
1355
1305
{
1356
1306
  int error;
1357
1307
  int64_t rnd;
1468
1418
                            String *val_ptr __attribute__((unused)))
1469
1419
{
1470
1420
  const CHARSET_INFO * const cs= &my_charset_bin;
1471
 
  uint length;
1472
 
  uint mlength=max(field_length+1,5*cs->mbmaxlen);
 
1421
  uint32_t length;
 
1422
  uint32_t mlength=cmax(field_length+1,5*cs->mbmaxlen);
1473
1423
  val_buffer->alloc(mlength);
1474
1424
  char *to=(char*) val_buffer->ptr();
1475
1425
 
1476
1426
  if (unsigned_flag)
1477
 
    length= (uint) cs->cset->long10_to_str(cs,to,mlength, 10,
 
1427
    length= (uint32_t) cs->cset->long10_to_str(cs,to,mlength, 10,
1478
1428
                                           (long) *ptr);
1479
1429
  else
1480
 
    length= (uint) cs->cset->long10_to_str(cs,to,mlength,-10,
 
1430
    length= (uint32_t) cs->cset->long10_to_str(cs,to,mlength,-10,
1481
1431
                                           (long) *((signed char*) ptr));
1482
1432
  
1483
1433
  val_buffer->length(length);
1490
1440
  return protocol->store_tiny((int64_t) (int8_t) ptr[0]);
1491
1441
}
1492
1442
 
1493
 
int Field_tiny::cmp(const uchar *a_ptr, const uchar *b_ptr)
 
1443
int Field_tiny::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)
1494
1444
{
1495
1445
  signed char a,b;
1496
1446
  a=(signed char) a_ptr[0]; b= (signed char) b_ptr[0];
1497
1447
  if (unsigned_flag)
1498
 
    return ((uchar) a < (uchar) b) ? -1 : ((uchar) a > (uchar) b) ? 1 : 0;
 
1448
    return ((unsigned char) a < (unsigned char) b) ? -1 : ((unsigned char) a > (unsigned char) b) ? 1 : 0;
1499
1449
  return (a < b) ? -1 : (a > b) ? 1 : 0;
1500
1450
}
1501
1451
 
1502
 
void Field_tiny::sort_string(uchar *to,uint length __attribute__((unused)))
 
1452
void Field_tiny::sort_string(unsigned char *to,uint32_t length __attribute__((unused)))
1503
1453
{
1504
1454
  if (unsigned_flag)
1505
1455
    *to= *ptr;
1506
1456
  else
1507
 
    to[0] = (char) (ptr[0] ^ (uchar) 128);      /* Revers signbit */
 
1457
    to[0] = (char) (ptr[0] ^ (unsigned char) 128);      /* Revers signbit */
1508
1458
}
1509
1459
 
1510
1460
void Field_tiny::sql_type(String &res) const
1652
1602
int Field_str::store(double nr)
1653
1603
{
1654
1604
  char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
1655
 
  uint local_char_length= field_length / charset()->mbmaxlen;
 
1605
  uint32_t local_char_length= field_length / charset()->mbmaxlen;
1656
1606
  size_t length;
1657
1607
  bool error;
1658
1608
 
1668
1618
}
1669
1619
 
1670
1620
 
1671
 
uint Field::is_equal(Create_field *new_field)
 
1621
uint32_t Field::is_equal(Create_field *new_field)
1672
1622
{
1673
1623
  return (new_field->sql_type == real_type());
1674
1624
}
1685
1635
}
1686
1636
 
1687
1637
 
1688
 
uint Field_str::is_equal(Create_field *new_field)
 
1638
uint32_t Field_str::is_equal(Create_field *new_field)
1689
1639
{
1690
1640
  if (compare_str_field_flags(new_field, flags))
1691
1641
    return 0;
1710
1660
}
1711
1661
 
1712
1662
 
1713
 
/****************************************************************************
1714
 
** enum type.
1715
 
** This is a string which only can have a selection of different values.
1716
 
** If one uses this string in a number context one gets the type number.
1717
 
****************************************************************************/
1718
 
 
1719
 
enum ha_base_keytype Field_enum::key_type() const
1720
 
{
1721
 
  switch (packlength) {
1722
 
  default: return HA_KEYTYPE_BINARY;
1723
 
  case 2: return HA_KEYTYPE_USHORT_INT;
1724
 
  case 3: return HA_KEYTYPE_UINT24;
1725
 
  case 4: return HA_KEYTYPE_ULONG_INT;
1726
 
  case 8: return HA_KEYTYPE_ULONGLONG;
1727
 
  }
1728
 
}
1729
 
 
1730
 
void Field_enum::store_type(uint64_t value)
1731
 
{
1732
 
  switch (packlength) {
1733
 
  case 1: ptr[0]= (uchar) value;  break;
1734
 
  case 2:
1735
 
#ifdef WORDS_BIGENDIAN
1736
 
  if (table->s->db_low_byte_first)
1737
 
  {
1738
 
    int2store(ptr,(unsigned short) value);
1739
 
  }
1740
 
  else
1741
 
#endif
1742
 
    shortstore(ptr,(unsigned short) value);
1743
 
  break;
1744
 
  case 3: int3store(ptr,(long) value); break;
1745
 
  case 4:
1746
 
#ifdef WORDS_BIGENDIAN
1747
 
  if (table->s->db_low_byte_first)
1748
 
  {
1749
 
    int4store(ptr,value);
1750
 
  }
1751
 
  else
1752
 
#endif
1753
 
    longstore(ptr,(long) value);
1754
 
  break;
1755
 
  case 8:
1756
 
#ifdef WORDS_BIGENDIAN
1757
 
  if (table->s->db_low_byte_first)
1758
 
  {
1759
 
    int8store(ptr,value);
1760
 
  }
1761
 
  else
1762
 
#endif
1763
 
    int64_tstore(ptr,value); break;
1764
 
  }
1765
 
}
1766
 
 
1767
 
 
1768
 
/**
1769
 
  @note
1770
 
    Storing a empty string in a enum field gives a warning
1771
 
    (if there isn't a empty value in the enum)
1772
 
*/
1773
 
 
1774
 
int Field_enum::store(const char *from, uint length, const CHARSET_INFO * const cs)
1775
 
{
1776
 
  int err= 0;
1777
 
  uint32_t not_used;
1778
 
  char buff[STRING_BUFFER_USUAL_SIZE];
1779
 
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
1780
 
 
1781
 
  /* Convert character set if necessary */
1782
 
  if (String::needs_conversion(length, cs, field_charset, &not_used))
1783
 
  { 
1784
 
    uint dummy_errors;
1785
 
    tmpstr.copy(from, length, cs, field_charset, &dummy_errors);
1786
 
    from= tmpstr.ptr();
1787
 
    length=  tmpstr.length();
1788
 
  }
1789
 
 
1790
 
  /* Remove end space */
1791
 
  length= field_charset->cset->lengthsp(field_charset, from, length);
1792
 
  uint tmp=find_type2(typelib, from, length, field_charset);
1793
 
  if (!tmp)
1794
 
  {
1795
 
    if (length < 6) // Can't be more than 99999 enums
1796
 
    {
1797
 
      /* This is for reading numbers with LOAD DATA INFILE */
1798
 
      char *end;
1799
 
      tmp=(uint) my_strntoul(cs,from,length,10,&end,&err);
1800
 
      if (err || end != from+length || tmp > typelib->count)
1801
 
      {
1802
 
        tmp=0;
1803
 
        set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
1804
 
      }
1805
 
      if (!table->in_use->count_cuted_fields)
1806
 
        err= 0;
1807
 
    }
1808
 
    else
1809
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
1810
 
  }
1811
 
  store_type((uint64_t) tmp);
1812
 
  return err;
1813
 
}
1814
 
 
1815
 
 
1816
 
int Field_enum::store(double nr)
1817
 
{
1818
 
  return Field_enum::store((int64_t) nr, false);
1819
 
}
1820
 
 
1821
 
 
1822
 
int Field_enum::store(int64_t nr,
1823
 
                      bool unsigned_val __attribute__((unused)))
1824
 
{
1825
 
  int error= 0;
1826
 
  if ((uint64_t) nr > typelib->count || nr == 0)
1827
 
  {
1828
 
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
1829
 
    if (nr != 0 || table->in_use->count_cuted_fields)
1830
 
    {
1831
 
      nr= 0;
1832
 
      error= 1;
1833
 
    }
1834
 
  }
1835
 
  store_type((uint64_t) (uint) nr);
1836
 
  return error;
1837
 
}
1838
 
 
1839
 
 
1840
 
double Field_enum::val_real(void)
1841
 
{
1842
 
  return (double) Field_enum::val_int();
1843
 
}
1844
 
 
1845
 
 
1846
 
int64_t Field_enum::val_int(void)
1847
 
{
1848
 
  switch (packlength) {
1849
 
  case 1:
1850
 
    return (int64_t) ptr[0];
1851
 
  case 2:
1852
 
  {
1853
 
    uint16_t tmp;
1854
 
#ifdef WORDS_BIGENDIAN
1855
 
    if (table->s->db_low_byte_first)
1856
 
      tmp=sint2korr(ptr);
1857
 
    else
1858
 
#endif
1859
 
      shortget(tmp,ptr);
1860
 
    return (int64_t) tmp;
1861
 
  }
1862
 
  case 3:
1863
 
    return (int64_t) uint3korr(ptr);
1864
 
  case 4:
1865
 
  {
1866
 
    uint32_t tmp;
1867
 
#ifdef WORDS_BIGENDIAN
1868
 
    if (table->s->db_low_byte_first)
1869
 
      tmp=uint4korr(ptr);
1870
 
    else
1871
 
#endif
1872
 
      longget(tmp,ptr);
1873
 
    return (int64_t) tmp;
1874
 
  }
1875
 
  case 8:
1876
 
  {
1877
 
    int64_t tmp;
1878
 
#ifdef WORDS_BIGENDIAN
1879
 
    if (table->s->db_low_byte_first)
1880
 
      tmp=sint8korr(ptr);
1881
 
    else
1882
 
#endif
1883
 
      int64_tget(tmp,ptr);
1884
 
    return tmp;
1885
 
  }
1886
 
  }
1887
 
  return 0;                                     // impossible
1888
 
}
1889
 
 
1890
 
 
1891
 
/**
1892
 
   Save the field metadata for enum fields.
1893
 
 
1894
 
   Saves the real type in the first byte and the pack length in the 
1895
 
   second byte of the field metadata array at index of *metadata_ptr and
1896
 
   *(metadata_ptr + 1).
1897
 
 
1898
 
   @param   metadata_ptr   First byte of field metadata
1899
 
 
1900
 
   @returns number of bytes written to metadata_ptr
1901
 
*/
1902
 
int Field_enum::do_save_field_metadata(uchar *metadata_ptr)
1903
 
{
1904
 
  *metadata_ptr= real_type();
1905
 
  *(metadata_ptr + 1)= pack_length();
1906
 
  return 2;
1907
 
}
1908
 
 
1909
 
 
1910
 
String *Field_enum::val_str(String *val_buffer __attribute__((unused)),
1911
 
                            String *val_ptr)
1912
 
{
1913
 
  uint tmp=(uint) Field_enum::val_int();
1914
 
  if (!tmp || tmp > typelib->count)
1915
 
    val_ptr->set("", 0, field_charset);
1916
 
  else
1917
 
    val_ptr->set((const char*) typelib->type_names[tmp-1],
1918
 
                 typelib->type_lengths[tmp-1],
1919
 
                 field_charset);
1920
 
  return val_ptr;
1921
 
}
1922
 
 
1923
 
int Field_enum::cmp(const uchar *a_ptr, const uchar *b_ptr)
1924
 
{
1925
 
  uchar *old= ptr;
1926
 
  ptr= (uchar*) a_ptr;
1927
 
  uint64_t a=Field_enum::val_int();
1928
 
  ptr= (uchar*) b_ptr;
1929
 
  uint64_t b=Field_enum::val_int();
1930
 
  ptr= old;
1931
 
  return (a < b) ? -1 : (a > b) ? 1 : 0;
1932
 
}
1933
 
 
1934
 
void Field_enum::sort_string(uchar *to,uint length __attribute__((unused)))
1935
 
{
1936
 
  uint64_t value=Field_enum::val_int();
1937
 
  to+=packlength-1;
1938
 
  for (uint i=0 ; i < packlength ; i++)
1939
 
  {
1940
 
    *to-- = (uchar) (value & 255);
1941
 
    value>>=8;
1942
 
  }
1943
 
}
1944
 
 
1945
 
 
1946
 
void Field_enum::sql_type(String &res) const
1947
 
{
1948
 
  char buffer[255];
1949
 
  String enum_item(buffer, sizeof(buffer), res.charset());
1950
 
 
1951
 
  res.length(0);
1952
 
  res.append(STRING_WITH_LEN("enum("));
1953
 
 
1954
 
  bool flag=0;
1955
 
  uint *len= typelib->type_lengths;
1956
 
  for (const char **pos= typelib->type_names; *pos; pos++, len++)
1957
 
  {
1958
 
    uint dummy_errors;
1959
 
    if (flag)
1960
 
      res.append(',');
1961
 
    /* convert to res.charset() == utf8, then quote */
1962
 
    enum_item.copy(*pos, *len, charset(), res.charset(), &dummy_errors);
1963
 
    append_unescaped(&res, enum_item.ptr(), enum_item.length());
1964
 
    flag= 1;
1965
 
  }
1966
 
  res.append(')');
1967
 
}
1968
 
 
1969
 
 
1970
 
Field *Field_enum::new_field(MEM_ROOT *root, Table *new_table,
1971
 
                             bool keep_type)
1972
 
{
1973
 
  Field_enum *res= (Field_enum*) Field::new_field(root, new_table, keep_type);
1974
 
  if (res)
1975
 
    res->typelib= copy_typelib(root, typelib);
1976
 
  return res;
1977
 
}
1978
 
 
1979
 
 
1980
1663
/**
1981
1664
  @retval
1982
1665
    1  if the fields are equally defined
2004
1687
 
2005
1688
  if (typelib->count < from_lib->count)
2006
1689
    return 0;
2007
 
  for (uint i=0 ; i < from_lib->count ; i++)
 
1690
  for (uint32_t i=0 ; i < from_lib->count ; i++)
2008
1691
    if (my_strnncoll(field_charset,
2009
 
                     (const uchar*)typelib->type_names[i],
 
1692
                     (const unsigned char*)typelib->type_names[i],
2010
1693
                     strlen(typelib->type_names[i]),
2011
 
                     (const uchar*)from_lib->type_names[i],
 
1694
                     (const unsigned char*)from_lib->type_names[i],
2012
1695
                     strlen(from_lib->type_names[i])))
2013
1696
      return 0;
2014
1697
  return 1;
2031
1714
}
2032
1715
 
2033
1716
 
2034
 
uint Field_num::is_equal(Create_field *new_field)
 
1717
uint32_t Field_num::is_equal(Create_field *new_field)
2035
1718
{
2036
1719
  return ((new_field->sql_type == real_type()) &&
2037
 
          ((new_field->flags & UNSIGNED_FLAG) == (uint) (flags &
 
1720
          ((new_field->flags & UNSIGNED_FLAG) == (uint32_t) (flags &
2038
1721
                                                         UNSIGNED_FLAG)) &&
2039
1722
          ((new_field->flags & AUTO_INCREMENT_FLAG) ==
2040
 
           (uint) (flags & AUTO_INCREMENT_FLAG)) &&
 
1723
           (uint32_t) (flags & AUTO_INCREMENT_FLAG)) &&
2041
1724
          (new_field->length <= max_display_length()));
2042
1725
}
2043
1726
 
2126
1809
 
2127
1810
bool Create_field::init(THD *thd __attribute__((unused)), char *fld_name, enum_field_types fld_type,
2128
1811
                        char *fld_length, char *fld_decimals,
2129
 
                        uint fld_type_modifier, Item *fld_default_value,
 
1812
                        uint32_t fld_type_modifier, Item *fld_default_value,
2130
1813
                        Item *fld_on_update_value, LEX_STRING *fld_comment,
2131
1814
                        char *fld_change, List<String> *fld_interval_list,
2132
1815
                        const CHARSET_INFO * const fld_charset,
2133
 
                        uint fld_geom_type __attribute__((unused)),
 
1816
                        uint32_t fld_geom_type __attribute__((unused)),
2134
1817
                        enum column_format_type column_format,
2135
1818
                        virtual_column_info *fld_vcol_info)
2136
1819
{
2137
 
  uint sign_len, allowed_type_modifier= 0;
 
1820
  uint32_t sign_len, allowed_type_modifier= 0;
2138
1821
  uint32_t max_field_charlength= MAX_FIELD_CHARLENGTH;
2139
1822
 
2140
1823
  field= 0;
2141
1824
  field_name= fld_name;
2142
1825
  def= fld_default_value;
2143
1826
  flags= fld_type_modifier;
2144
 
  flags|= (((uint)column_format & COLUMN_FORMAT_MASK) << COLUMN_FORMAT_FLAGS);
 
1827
  flags|= (((uint32_t)column_format & COLUMN_FORMAT_MASK) << COLUMN_FORMAT_FLAGS);
2145
1828
  unireg_check= (fld_type_modifier & AUTO_INCREMENT_FLAG ?
2146
1829
                 Field::NEXT_NUMBER : Field::NONE);
2147
 
  decimals= fld_decimals ? (uint)atoi(fld_decimals) : 0;
 
1830
  decimals= fld_decimals ? (uint32_t)atoi(fld_decimals) : 0;
2148
1831
  if (decimals >= NOT_FIXED_DEC)
2149
1832
  {
2150
1833
    my_error(ER_TOO_BIG_SCALE, MYF(0), decimals, fld_name,
2219
1902
      (fld_type_modifier & NOT_NULL_FLAG) && fld_type != DRIZZLE_TYPE_TIMESTAMP)
2220
1903
    flags|= NO_DEFAULT_VALUE_FLAG;
2221
1904
 
2222
 
  if (fld_length && !(length= (uint) atoi(fld_length)))
 
1905
  if (fld_length && !(length= (uint32_t) atoi(fld_length)))
2223
1906
    fld_length= 0; /* purecov: inspected */
2224
1907
  sign_len= fld_type_modifier & UNSIGNED_FLAG ? 0 : 1;
2225
1908
 
2229
1912
      length= MAX_TINYINT_WIDTH+sign_len;
2230
1913
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
2231
1914
    break;
2232
 
  case DRIZZLE_TYPE_SHORT:
2233
 
    if (!fld_length)
2234
 
      length= MAX_SMALLINT_WIDTH+sign_len;
2235
 
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
2236
 
    break;
2237
1915
  case DRIZZLE_TYPE_LONG:
2238
1916
    if (!fld_length)
2239
1917
      length= MAX_INT_WIDTH+sign_len;
2308
1986
        and 19 as length of 4.1 compatible representation.
2309
1987
      */
2310
1988
      length= ((length+1)/2)*2; /* purecov: inspected */
2311
 
      length= min(length, (uint32_t)MAX_DATETIME_COMPRESSED_WIDTH); /* purecov: inspected */
 
1989
      length= cmin(length, (uint32_t)MAX_DATETIME_COMPRESSED_WIDTH); /* purecov: inspected */
2312
1990
    }
2313
1991
    flags|= UNSIGNED_FLAG;
2314
1992
    if (fld_default_value)
2349
2027
                                              Field::NONE));
2350
2028
    }
2351
2029
    break;
2352
 
  case DRIZZLE_TYPE_DATE:
2353
 
    /* Old date type. */
2354
 
    sql_type= DRIZZLE_TYPE_NEWDATE;
2355
 
    /* fall trough */
2356
2030
  case DRIZZLE_TYPE_NEWDATE:
2357
2031
    length= 10;
2358
2032
    break;
2421
2095
  switch (type) {
2422
2096
  case DRIZZLE_TYPE_VARCHAR:     return (length + (length < 256 ? 1: 2));
2423
2097
  case DRIZZLE_TYPE_TINY        : return 1;
2424
 
  case DRIZZLE_TYPE_SHORT : return 2;
2425
 
  case DRIZZLE_TYPE_DATE:
2426
2098
  case DRIZZLE_TYPE_NEWDATE:
2427
2099
  case DRIZZLE_TYPE_TIME:   return 3;
2428
2100
  case DRIZZLE_TYPE_TIMESTAMP:
2441
2113
}
2442
2114
 
2443
2115
 
2444
 
uint pack_length_to_packflag(uint type)
 
2116
uint32_t pack_length_to_packflag(uint32_t type)
2445
2117
{
2446
2118
  switch (type) {
2447
 
    case 1: return f_settype((uint) DRIZZLE_TYPE_TINY);
2448
 
    case 2: return f_settype((uint) DRIZZLE_TYPE_SHORT);
 
2119
    case 1: return f_settype((uint32_t) DRIZZLE_TYPE_TINY);
 
2120
    case 2: assert(1);
2449
2121
    case 3: assert(1);
2450
 
    case 4: return f_settype((uint) DRIZZLE_TYPE_LONG);
2451
 
    case 8: return f_settype((uint) DRIZZLE_TYPE_LONGLONG);
 
2122
    case 4: return f_settype((uint32_t) DRIZZLE_TYPE_LONG);
 
2123
    case 8: return f_settype((uint32_t) DRIZZLE_TYPE_LONGLONG);
2452
2124
  }
2453
2125
  return 0;                                     // This shouldn't happen
2454
2126
}
2455
2127
 
2456
2128
 
2457
 
Field *make_field(TABLE_SHARE *share, uchar *ptr, uint32_t field_length,
2458
 
                  uchar *null_pos, uchar null_bit,
2459
 
                  uint pack_flag,
 
2129
Field *make_field(TABLE_SHARE *share, unsigned char *ptr, uint32_t field_length,
 
2130
                  unsigned char *null_pos, unsigned char null_bit,
 
2131
                  uint32_t pack_flag,
2460
2132
                  enum_field_types field_type,
2461
2133
                  const CHARSET_INFO * field_charset,
2462
2134
                  Field::utype unireg_check,
2470
2142
  }
2471
2143
  else
2472
2144
  {
2473
 
    null_bit= ((uchar) 1) << null_bit;
 
2145
    null_bit= ((unsigned char) 1) << null_bit;
2474
2146
  }
2475
2147
 
2476
2148
  switch (field_type) {
2477
 
  case DRIZZLE_TYPE_DATE:
2478
2149
  case DRIZZLE_TYPE_NEWDATE:
2479
2150
  case DRIZZLE_TYPE_TIME:
2480
2151
  case DRIZZLE_TYPE_DATETIME:
2497
2168
      return 0;                                 // Error
2498
2169
    }
2499
2170
 
2500
 
    uint pack_length=calc_pack_length((enum_field_types)
 
2171
    uint32_t pack_length=calc_pack_length((enum_field_types)
2501
2172
                                      f_packtype(pack_flag),
2502
2173
                                      field_length);
2503
2174
 
2532
2203
                          unireg_check, field_name,
2533
2204
                          false,
2534
2205
                          f_is_dec(pack_flag) == 0);
2535
 
  case DRIZZLE_TYPE_SHORT:
2536
 
    return new Field_short(ptr,field_length,null_pos,null_bit,
2537
 
                           unireg_check, field_name,
2538
 
                           false,
2539
 
                           f_is_dec(pack_flag) == 0);
2540
2206
  case DRIZZLE_TYPE_LONG:
2541
2207
    return new Field_long(ptr,field_length,null_pos,null_bit,
2542
2208
                           unireg_check, field_name,
2551
2217
    return new Field_timestamp(ptr,field_length, null_pos, null_bit,
2552
2218
                               unireg_check, field_name, share,
2553
2219
                               field_charset);
2554
 
  case DRIZZLE_TYPE_DATE:
2555
2220
  case DRIZZLE_TYPE_NEWDATE:
2556
2221
    return new Field_newdate(ptr,null_pos,null_bit,
2557
2222
                             unireg_check, field_name, field_charset);
2671
2336
*/
2672
2337
 
2673
2338
bool 
2674
 
Field::set_warning(DRIZZLE_ERROR::enum_warning_level level, uint code,
 
2339
Field::set_warning(DRIZZLE_ERROR::enum_warning_level level, uint32_t code,
2675
2340
                   int cuted_increment)
2676
2341
{
2677
2342
  /*
2709
2374
void 
2710
2375
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, 
2711
2376
                            unsigned int code, 
2712
 
                            const char *str, uint str_length, 
2713
 
                            timestamp_type ts_type, int cuted_increment)
 
2377
                            const char *str, uint32_t str_length, 
 
2378
                            enum enum_drizzle_timestamp_type ts_type, int cuted_increment)
2714
2379
{
2715
2380
  THD *thd= table ? table->in_use : current_thd;
2716
2381
  if ((thd->really_abort_on_warning() &&
2737
2402
*/
2738
2403
 
2739
2404
void 
2740
 
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, uint code, 
2741
 
                            int64_t nr, timestamp_type ts_type,
 
2405
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, uint32_t code, 
 
2406
                            int64_t nr, enum enum_drizzle_timestamp_type ts_type,
2742
2407
                            int cuted_increment)
2743
2408
{
2744
2409
  THD *thd= table ? table->in_use : current_thd;
2747
2412
  {
2748
2413
    char str_nr[22];
2749
2414
    char *str_end= int64_t10_to_str(nr, str_nr, -10);
2750
 
    make_truncated_value_warning(thd, level, str_nr, (uint) (str_end - str_nr), 
 
2415
    make_truncated_value_warning(thd, level, str_nr, (uint32_t) (str_end - str_nr), 
2751
2416
                                 ts_type, field_name);
2752
2417
  }
2753
2418
}
2768
2433
*/
2769
2434
 
2770
2435
void 
2771
 
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, uint code, 
2772
 
                            double nr, timestamp_type ts_type)
 
2436
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, uint32_t code, 
 
2437
                            double nr, enum enum_drizzle_timestamp_type ts_type)
2773
2438
{
2774
2439
  THD *thd= table ? table->in_use : current_thd;
2775
2440
  if (thd->really_abort_on_warning() ||
2777
2442
  {
2778
2443
    /* DBL_DIG is enough to print '-[digits].E+###' */
2779
2444
    char str_nr[DBL_DIG + 8];
2780
 
    uint str_len= sprintf(str_nr, "%g", nr);
 
2445
    uint32_t str_len= sprintf(str_nr, "%g", nr);
2781
2446
    make_truncated_value_warning(thd, level, str_nr, str_len, ts_type,
2782
2447
                                 field_name);
2783
2448
  }