← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.cc

  • Committer: Stewart Smith
  • Date: 2011-01-14 05:09:04 UTC
  • mto: (2086.1.3 build)
  • mto: This revision was merged to the branch mainline in revision 2087.
  • Revision ID: stewart@flamingspork.com-20110114050904-a98kswwpqnpl413s
add a bit of a note on how variables docs should be expanded

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field.cc
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
 
4
 *  Copyright (C) 2010 Brian Aker
4
5
 *  Copyright (C) 2008 MySQL
5
6
 *
6
7
 *  This program is free software; you can redistribute it and/or modify
31
32
#include "drizzled/field/str.h"
32
33
#include "drizzled/field/num.h"
33
34
#include "drizzled/field/blob.h"
 
35
#include "drizzled/field/boolean.h"
34
36
#include "drizzled/field/enum.h"
35
37
#include "drizzled/field/null.h"
36
38
#include "drizzled/field/date.h"
40
42
#include "drizzled/field/int32.h"
41
43
#include "drizzled/field/int64.h"
42
44
#include "drizzled/field/num.h"
43
 
#include "drizzled/field/timestamp.h"
 
45
#include "drizzled/field/time.h"
 
46
#include "drizzled/field/epoch.h"
44
47
#include "drizzled/field/datetime.h"
 
48
#include "drizzled/field/microtime.h"
45
49
#include "drizzled/field/varstring.h"
46
50
#include "drizzled/field/uuid.h"
47
51
#include "drizzled/time_functions.h"
83
87
    DRIZZLE_TYPE_VARCHAR,
84
88
    //DRIZZLE_TYPE_BLOB
85
89
    DRIZZLE_TYPE_BLOB,
 
90
    //DRIZZLE_TYPE_TIME
 
91
    DRIZZLE_TYPE_TIME,
 
92
    //DRIZZLE_TYPE_BOOLEAN
 
93
    DRIZZLE_TYPE_VARCHAR,
86
94
    //DRIZZLE_TYPE_UUID
87
95
    DRIZZLE_TYPE_VARCHAR,
 
96
    //DRIZZLE_TYPE_MICROTIME
 
97
    DRIZZLE_TYPE_VARCHAR,
88
98
  },
89
99
  /* DRIZZLE_TYPE_DOUBLE -> */
90
100
  {
110
120
    DRIZZLE_TYPE_VARCHAR,
111
121
    //DRIZZLE_TYPE_BLOB
112
122
    DRIZZLE_TYPE_BLOB,
 
123
    //DRIZZLE_TYPE_TIME
 
124
    DRIZZLE_TYPE_TIME,
 
125
    //DRIZZLE_TYPE_BOOLEAN
 
126
    DRIZZLE_TYPE_VARCHAR,
113
127
    //DRIZZLE_TYPE_UUID
114
128
    DRIZZLE_TYPE_VARCHAR,
 
129
    //DRIZZLE_TYPE_MICROTIME
 
130
    DRIZZLE_TYPE_VARCHAR,
115
131
  },
116
132
  /* DRIZZLE_TYPE_NULL -> */
117
133
  {
137
153
    DRIZZLE_TYPE_ENUM,
138
154
    //DRIZZLE_TYPE_BLOB
139
155
    DRIZZLE_TYPE_BLOB,
 
156
    //DRIZZLE_TYPE_TIME
 
157
    DRIZZLE_TYPE_TIME,
 
158
    //DRIZZLE_TYPE_BOOLEAN
 
159
    DRIZZLE_TYPE_BOOLEAN,
140
160
    //DRIZZLE_TYPE_UUID
141
161
    DRIZZLE_TYPE_UUID,
 
162
    //DRIZZLE_TYPE_MICROTIME
 
163
    DRIZZLE_TYPE_MICROTIME,
142
164
  },
143
165
  /* DRIZZLE_TYPE_TIMESTAMP -> */
144
166
  {
164
186
    DRIZZLE_TYPE_VARCHAR,
165
187
    //DRIZZLE_TYPE_BLOB
166
188
    DRIZZLE_TYPE_BLOB,
 
189
    //DRIZZLE_TYPE_TIME
 
190
    DRIZZLE_TYPE_TIME,
 
191
    //DRIZZLE_TYPE_BOOLEAN
 
192
    DRIZZLE_TYPE_VARCHAR,
167
193
    //DRIZZLE_TYPE_UUID
168
194
    DRIZZLE_TYPE_VARCHAR,
 
195
    //DRIZZLE_TYPE_MICROTIME
 
196
    DRIZZLE_TYPE_VARCHAR,
169
197
  },
170
198
  /* DRIZZLE_TYPE_LONGLONG -> */
171
199
  {
190
218
    DRIZZLE_TYPE_VARCHAR,
191
219
    //DRIZZLE_TYPE_BLOB
192
220
    DRIZZLE_TYPE_BLOB,
 
221
    //DRIZZLE_TYPE_TIME
 
222
    DRIZZLE_TYPE_TIME,
 
223
    //DRIZZLE_TYPE_BOOLEAN
 
224
    DRIZZLE_TYPE_VARCHAR,
193
225
    //DRIZZLE_TYPE_UUID
194
226
    DRIZZLE_TYPE_VARCHAR,
 
227
    //DRIZZLE_TYPE_MICROTIME
 
228
    DRIZZLE_TYPE_VARCHAR,
195
229
  },
196
230
  /* DRIZZLE_TYPE_DATETIME -> */
197
231
  {
217
251
    DRIZZLE_TYPE_VARCHAR,
218
252
    //DRIZZLE_TYPE_BLOB
219
253
    DRIZZLE_TYPE_BLOB,
 
254
    //DRIZZLE_TYPE_TIME
 
255
    DRIZZLE_TYPE_TIME,
 
256
    //DRIZZLE_TYPE_BOOLEAN
 
257
    DRIZZLE_TYPE_VARCHAR,
220
258
    //DRIZZLE_TYPE_UUID
221
259
    DRIZZLE_TYPE_VARCHAR,
 
260
    //DRIZZLE_TYPE_MICROTIME
 
261
    DRIZZLE_TYPE_VARCHAR,
222
262
  },
223
263
  /* DRIZZLE_TYPE_DATE -> */
224
264
  {
244
284
    DRIZZLE_TYPE_VARCHAR,
245
285
    //DRIZZLE_TYPE_BLOB
246
286
    DRIZZLE_TYPE_BLOB,
 
287
    //DRIZZLE_TYPE_TIME
 
288
    DRIZZLE_TYPE_TIME,
 
289
    //DRIZZLE_TYPE_BOOLEAN
 
290
    DRIZZLE_TYPE_VARCHAR,
247
291
    //DRIZZLE_TYPE_UUID
248
292
    DRIZZLE_TYPE_VARCHAR,
 
293
    //DRIZZLE_TYPE_MICROTIME
 
294
    DRIZZLE_TYPE_VARCHAR,
249
295
  },
250
296
  /* DRIZZLE_TYPE_VARCHAR -> */
251
297
  {
271
317
    DRIZZLE_TYPE_VARCHAR,
272
318
    //DRIZZLE_TYPE_BLOB
273
319
    DRIZZLE_TYPE_BLOB,
 
320
    //DRIZZLE_TYPE_TIME
 
321
    DRIZZLE_TYPE_TIME,
 
322
    //DRIZZLE_TYPE_BOOLEAN
 
323
    DRIZZLE_TYPE_VARCHAR,
274
324
    //DRIZZLE_TYPE_UUID
275
325
    DRIZZLE_TYPE_VARCHAR,
 
326
    //DRIZZLE_TYPE_MICROTIME
 
327
    DRIZZLE_TYPE_VARCHAR,
276
328
  },
277
329
  /* DRIZZLE_TYPE_DECIMAL -> */
278
330
  {
298
350
    DRIZZLE_TYPE_VARCHAR,
299
351
    //DRIZZLE_TYPE_BLOB
300
352
    DRIZZLE_TYPE_BLOB,
 
353
    //DRIZZLE_TYPE_TIME
 
354
    DRIZZLE_TYPE_TIME,
 
355
    //DRIZZLE_TYPE_BOOLEAN
 
356
    DRIZZLE_TYPE_VARCHAR,
301
357
    //DRIZZLE_TYPE_UUID
302
358
    DRIZZLE_TYPE_VARCHAR,
 
359
    //DRIZZLE_TYPE_MICROTIME
 
360
    DRIZZLE_TYPE_VARCHAR,
303
361
  },
304
362
  /* DRIZZLE_TYPE_ENUM -> */
305
363
  {
325
383
    DRIZZLE_TYPE_VARCHAR,
326
384
    //DRIZZLE_TYPE_BLOB
327
385
    DRIZZLE_TYPE_BLOB,
 
386
    //DRIZZLE_TYPE_TIME
 
387
    DRIZZLE_TYPE_TIME,
 
388
    //DRIZZLE_TYPE_BOOLEAN
 
389
    DRIZZLE_TYPE_VARCHAR,
328
390
    //DRIZZLE_TYPE_UUID
329
391
    DRIZZLE_TYPE_VARCHAR,
 
392
    //DRIZZLE_TYPE_MICROTIME
 
393
    DRIZZLE_TYPE_VARCHAR,
330
394
   },
331
395
  /* DRIZZLE_TYPE_BLOB -> */
332
396
  {
352
416
    DRIZZLE_TYPE_BLOB,
353
417
    //DRIZZLE_TYPE_BLOB
354
418
    DRIZZLE_TYPE_BLOB,
355
 
    //DRIZZLE_TYPE_UUID
 
419
    //DRIZZLE_TYPE_TIME
 
420
    DRIZZLE_TYPE_TIME,
 
421
    //DRIZZLE_TYPE_BOOLEAN
 
422
    DRIZZLE_TYPE_VARCHAR,
 
423
    //DRIZZLE_TYPE_UUID
 
424
    DRIZZLE_TYPE_VARCHAR,
 
425
    //DRIZZLE_TYPE_MICROTIME
 
426
    DRIZZLE_TYPE_VARCHAR,
 
427
  },
 
428
  /* DRIZZLE_TYPE_TIME -> */
 
429
  {
 
430
    //DRIZZLE_TYPE_LONG
 
431
    DRIZZLE_TYPE_VARCHAR,
 
432
    //DRIZZLE_TYPE_DOUBLE
 
433
    DRIZZLE_TYPE_VARCHAR,
 
434
    //DRIZZLE_TYPE_NULL
 
435
    DRIZZLE_TYPE_TIME,
 
436
    //DRIZZLE_TYPE_TIMESTAMP
 
437
    DRIZZLE_TYPE_VARCHAR,
 
438
    //DRIZZLE_TYPE_LONGLONG
 
439
    DRIZZLE_TYPE_VARCHAR,
 
440
    //DRIZZLE_TYPE_DATETIME
 
441
    DRIZZLE_TYPE_VARCHAR,
 
442
    //DRIZZLE_TYPE_DATE
 
443
    DRIZZLE_TYPE_VARCHAR,
 
444
    //DRIZZLE_TYPE_VARCHAR
 
445
    DRIZZLE_TYPE_VARCHAR,
 
446
    //DRIZZLE_TYPE_DECIMAL
 
447
    DRIZZLE_TYPE_VARCHAR,
 
448
    //DRIZZLE_TYPE_VARCHAR,
 
449
    DRIZZLE_TYPE_VARCHAR,
 
450
    //DRIZZLE_TYPE_BLOB
 
451
    DRIZZLE_TYPE_BLOB,
 
452
    //DRIZZLE_TYPE_TIME
 
453
    DRIZZLE_TYPE_TIME,
 
454
    //DRIZZLE_TYPE_BOOLEAN
 
455
    DRIZZLE_TYPE_VARCHAR,
 
456
    //DRIZZLE_TYPE_UUID
 
457
    DRIZZLE_TYPE_UUID,
 
458
    //DRIZZLE_TYPE_MICROTIME
 
459
    DRIZZLE_TYPE_VARCHAR,
 
460
  },
 
461
  /* DRIZZLE_TYPE_BOOLEAN -> */
 
462
  {
 
463
    //DRIZZLE_TYPE_LONG
 
464
    DRIZZLE_TYPE_VARCHAR,
 
465
    //DRIZZLE_TYPE_DOUBLE
 
466
    DRIZZLE_TYPE_VARCHAR,
 
467
    //DRIZZLE_TYPE_NULL
 
468
    DRIZZLE_TYPE_BOOLEAN,
 
469
    //DRIZZLE_TYPE_TIMESTAMP
 
470
    DRIZZLE_TYPE_VARCHAR,
 
471
    //DRIZZLE_TYPE_LONGLONG
 
472
    DRIZZLE_TYPE_VARCHAR,
 
473
    //DRIZZLE_TYPE_DATETIME
 
474
    DRIZZLE_TYPE_VARCHAR,
 
475
    //DRIZZLE_TYPE_DATE
 
476
    DRIZZLE_TYPE_VARCHAR,
 
477
    //DRIZZLE_TYPE_VARCHAR
 
478
    DRIZZLE_TYPE_VARCHAR,
 
479
    //DRIZZLE_TYPE_DECIMAL
 
480
    DRIZZLE_TYPE_VARCHAR,
 
481
    //DRIZZLE_TYPE_VARCHAR,
 
482
    DRIZZLE_TYPE_VARCHAR,
 
483
    //DRIZZLE_TYPE_BLOB
 
484
    DRIZZLE_TYPE_BLOB,
 
485
    //DRIZZLE_TYPE_TIME
 
486
    DRIZZLE_TYPE_TIME,
 
487
    //DRIZZLE_TYPE_BOOLEAN
 
488
    DRIZZLE_TYPE_BOOLEAN,
 
489
    //DRIZZLE_TYPE_UUID
 
490
    DRIZZLE_TYPE_VARCHAR,
 
491
    //DRIZZLE_TYPE_MICROTIME
356
492
    DRIZZLE_TYPE_VARCHAR,
357
493
  },
358
494
  /* DRIZZLE_TYPE_UUID -> */
379
515
    DRIZZLE_TYPE_VARCHAR,
380
516
    //DRIZZLE_TYPE_BLOB
381
517
    DRIZZLE_TYPE_BLOB,
382
 
    //DRIZZLE_TYPE_UUID
383
 
    DRIZZLE_TYPE_UUID,
 
518
    //DRIZZLE_TYPE_TIME
 
519
    DRIZZLE_TYPE_TIME,
 
520
    //DRIZZLE_TYPE_BOOLEAN
 
521
    DRIZZLE_TYPE_VARCHAR,
 
522
    //DRIZZLE_TYPE_UUID
 
523
    DRIZZLE_TYPE_UUID,
 
524
    //DRIZZLE_TYPE_MICROTIME
 
525
    DRIZZLE_TYPE_VARCHAR,
 
526
  },
 
527
  /* DRIZZLE_TYPE_MICROTIME -> */
 
528
  {
 
529
    //DRIZZLE_TYPE_LONG
 
530
    DRIZZLE_TYPE_VARCHAR,
 
531
    //DRIZZLE_TYPE_DOUBLE
 
532
    DRIZZLE_TYPE_VARCHAR,
 
533
    //DRIZZLE_TYPE_NULL
 
534
    DRIZZLE_TYPE_MICROTIME,
 
535
    //DRIZZLE_TYPE_TIMESTAMP
 
536
    DRIZZLE_TYPE_VARCHAR,
 
537
    //DRIZZLE_TYPE_LONGLONG
 
538
    DRIZZLE_TYPE_VARCHAR,
 
539
    //DRIZZLE_TYPE_DATETIME
 
540
    DRIZZLE_TYPE_VARCHAR,
 
541
    //DRIZZLE_TYPE_DATE
 
542
    DRIZZLE_TYPE_VARCHAR,
 
543
    //DRIZZLE_TYPE_VARCHAR
 
544
    DRIZZLE_TYPE_VARCHAR,
 
545
    //DRIZZLE_TYPE_DECIMAL
 
546
    DRIZZLE_TYPE_VARCHAR,
 
547
    //DRIZZLE_TYPE_VARCHAR,
 
548
    DRIZZLE_TYPE_VARCHAR,
 
549
    //DRIZZLE_TYPE_BLOB
 
550
    DRIZZLE_TYPE_BLOB,
 
551
    //DRIZZLE_TYPE_TIME
 
552
    DRIZZLE_TYPE_TIME,
 
553
    //DRIZZLE_TYPE_BOOLEAN
 
554
    DRIZZLE_TYPE_VARCHAR,
 
555
    //DRIZZLE_TYPE_UUID
 
556
    DRIZZLE_TYPE_UUID,
 
557
    //DRIZZLE_TYPE_MICROTIME
 
558
    DRIZZLE_TYPE_MICROTIME,
384
559
  },
385
560
};
386
561
 
408
583
  STRING_RESULT,
409
584
  //DRIZZLE_TYPE_BLOB
410
585
  STRING_RESULT,
 
586
  //DRIZZLE_TYPE_TIME
 
587
  STRING_RESULT,
 
588
  //DRIZZLE_TYPE_BOOLEAN
 
589
  STRING_RESULT,
411
590
  //DRIZZLE_TYPE_UUID
412
591
  STRING_RESULT,
 
592
  //DRIZZLE_TYPE_MICROTIME
 
593
  STRING_RESULT,
413
594
};
414
595
 
415
596
bool test_if_important_data(const CHARSET_INFO * const cs, 
760
941
  return(result);
761
942
}
762
943
 
763
 
my_decimal *Field::val_decimal(my_decimal *)
 
944
type::Decimal *Field::val_decimal(type::Decimal *)
764
945
{
765
946
  /* This never have to be called */
766
947
  assert(0);
795
976
  field->decimals= 0;
796
977
}
797
978
 
798
 
int64_t Field::convert_decimal2int64_t(const my_decimal *val, bool, int *err)
 
979
int64_t Field::convert_decimal2int64_t(const type::Decimal *val, bool, int *err)
799
980
{
800
981
  int64_t i;
801
 
  if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
 
982
  if (warn_if_overflow(val->val_int32(E_DEC_ERROR &
802
983
                                      ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
803
 
                                      val, false, &i)))
 
984
                                      false, &i)))
804
985
  {
805
986
    i= (val->sign() ? INT64_MIN : INT64_MAX);
806
987
    *err= 1;
829
1010
  return copy->length+ store_length;
830
1011
}
831
1012
 
832
 
bool Field::get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
 
1013
bool Field::get_date(type::Time *ltime,uint32_t fuzzydate)
833
1014
{
834
1015
  char buff[40];
835
1016
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
842
1023
  return 0;
843
1024
}
844
1025
 
845
 
bool Field::get_time(DRIZZLE_TIME *ltime)
 
1026
bool Field::get_time(type::Time *ltime)
846
1027
{
847
1028
  char buff[40];
848
1029
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
855
1036
  return 0;
856
1037
}
857
1038
 
858
 
int Field::store_time(DRIZZLE_TIME *ltime, enum enum_drizzle_timestamp_type)
 
1039
int Field::store_time(type::Time *ltime, enum enum_drizzle_timestamp_type)
859
1040
{
860
1041
  char buff[MAX_DATE_STRING_REP_LENGTH];
861
1042
  uint32_t length= (uint32_t) my_TIME_to_str(ltime, buff);
930
1111
{
931
1112
  if (!Field::eq_def(field))
932
1113
    return 0;
 
1114
 
933
1115
  TYPELIB *from_lib=((Field_enum*) field)->typelib;
934
1116
 
935
1117
  if (typelib->count < from_lib->count)
936
1118
    return 0;
 
1119
 
937
1120
  for (uint32_t i=0 ; i < from_lib->count ; i++)
 
1121
  {
938
1122
    if (my_strnncoll(field_charset,
939
1123
                     (const unsigned char*)typelib->type_names[i],
940
1124
                     strlen(typelib->type_names[i]),
941
1125
                     (const unsigned char*)from_lib->type_names[i],
942
1126
                     strlen(from_lib->type_names[i])))
943
1127
      return 0;
 
1128
  }
 
1129
 
944
1130
  return 1;
945
1131
}
946
1132
 
949
1135
  switch (type) {
950
1136
  case DRIZZLE_TYPE_VARCHAR: return (length + (length < 256 ? 1: 2));
951
1137
  case DRIZZLE_TYPE_UUID: return field::Uuid::max_string_length();
 
1138
  case DRIZZLE_TYPE_MICROTIME: return field::Microtime::max_string_length();
 
1139
  case DRIZZLE_TYPE_TIMESTAMP: return field::Epoch::max_string_length();
 
1140
  case DRIZZLE_TYPE_BOOLEAN: return field::Boolean::max_string_length();
952
1141
  case DRIZZLE_TYPE_DATE:
953
1142
  case DRIZZLE_TYPE_ENUM:
954
1143
  case DRIZZLE_TYPE_LONG: return 4;
955
1144
  case DRIZZLE_TYPE_DOUBLE: return sizeof(double);
 
1145
  case DRIZZLE_TYPE_TIME:
956
1146
  case DRIZZLE_TYPE_DATETIME:
957
 
  case DRIZZLE_TYPE_TIMESTAMP:
958
1147
  case DRIZZLE_TYPE_LONGLONG: return 8; /* Don't crash if no int64_t */
959
1148
  case DRIZZLE_TYPE_NULL: return 0;
960
1149
  case DRIZZLE_TYPE_BLOB: return 4 + portable_sizeof_char_ptr;
961
1150
  case DRIZZLE_TYPE_DECIMAL:
962
 
                          assert(0);
963
 
                          abort();
 
1151
                          break;
964
1152
  }
965
1153
 
966
1154
  assert(0);
1078
1266
    table->clearWriteSet(field_index);
1079
1267
}
1080
1268
 
 
1269
void Field::pack_num(uint64_t arg, unsigned char *destination)
 
1270
{
 
1271
  if (not destination)
 
1272
    destination= ptr;
 
1273
 
 
1274
  int64_tstore(destination, arg);
 
1275
}
 
1276
 
 
1277
void Field::pack_num(uint32_t arg, unsigned char *destination)
 
1278
{
 
1279
  if (not destination)
 
1280
    destination= ptr;
 
1281
 
 
1282
  longstore(destination, arg);
 
1283
}
 
1284
 
 
1285
uint64_t Field::unpack_num(uint64_t &destination, const unsigned char *arg) const
 
1286
{
 
1287
  if (not arg)
 
1288
    arg= ptr;
 
1289
 
 
1290
  int64_tget(destination, arg);
 
1291
 
 
1292
  return destination;
 
1293
}
 
1294
 
 
1295
uint32_t Field::unpack_num(uint32_t &destination, const unsigned char *arg) const
 
1296
{
 
1297
  if (not arg)
 
1298
    arg= ptr;
 
1299
 
 
1300
  longget(destination, arg);
 
1301
 
 
1302
  return destination;
 
1303
}
 
1304
 
1081
1305
std::ostream& operator<<(std::ostream& output, const Field &field)
1082
1306
{
1083
1307
  output << "Field:(";
1084
1308
  output <<  field.field_name;
1085
1309
  output << ", ";
1086
1310
  output << drizzled::display::type(field.real_type());
 
1311
  output << ", { ";
 
1312
 
 
1313
  if (field.flags & NOT_NULL_FLAG)
 
1314
    output << " NOT_NULL";
 
1315
 
 
1316
  if (field.flags & PRI_KEY_FLAG)
 
1317
    output << ", PRIMARY KEY";
 
1318
 
 
1319
  if (field.flags & UNIQUE_KEY_FLAG)
 
1320
    output << ", UNIQUE KEY";
 
1321
 
 
1322
  if (field.flags & MULTIPLE_KEY_FLAG)
 
1323
    output << ", MULTIPLE KEY";
 
1324
 
 
1325
  if (field.flags & BLOB_FLAG)
 
1326
    output << ", BLOB";
 
1327
 
 
1328
  if (field.flags & UNSIGNED_FLAG)
 
1329
    output << ", UNSIGNED";
 
1330
 
 
1331
  if (field.flags & BINARY_FLAG)
 
1332
    output << ", BINARY";
 
1333
  output << "}, ";
1087
1334
  output << ")";
1088
1335
 
1089
1336
  return output;  // for multiple << operators.