← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.cc

  • Committer: Brian Aker
  • Date: 2011-01-25 07:22:15 UTC
  • mfrom: (2109.1.7 drizzle-build)
  • Revision ID: brian@tangent.org-20110125072215-567z6uzy5vdvn4va
Merge in build/timestamp patches/fixes.

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;
836
1017
  if (!(res=val_str_internal(&tmp)) || str_to_datetime_with_warn(res->ptr(), res->length(),
837
 
                                                                 ltime, fuzzydate) <= DRIZZLE_TIMESTAMP_ERROR)
 
1018
                                                                 &ltime, fuzzydate) <= type::DRIZZLE_TIMESTAMP_ERROR)
838
1019
  {
839
1020
    return 1;
840
1021
  }
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;
849
1030
 
850
 
  if (!(res=val_str_internal(&tmp)) || str_to_time_with_warn(res->ptr(), res->length(), ltime))
 
1031
  if (!(res=val_str_internal(&tmp)) || str_to_time_with_warn(res->ptr(), res->length(), &ltime))
851
1032
  {
852
1033
    return 1;
853
1034
  }
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, type::timestamp_t)
859
1040
{
860
 
  char buff[MAX_DATE_STRING_REP_LENGTH];
861
 
  uint32_t length= (uint32_t) my_TIME_to_str(ltime, buff);
862
 
  return store(buff, length, &my_charset_bin);
 
1041
  String tmp;
 
1042
 
 
1043
  ltime.convert(tmp);
 
1044
 
 
1045
  return store(tmp.ptr(), tmp.length(), &my_charset_bin);
863
1046
}
864
1047
 
865
1048
bool Field::optimize_range(uint32_t idx, uint32_t)
930
1113
{
931
1114
  if (!Field::eq_def(field))
932
1115
    return 0;
 
1116
 
933
1117
  TYPELIB *from_lib=((Field_enum*) field)->typelib;
934
1118
 
935
1119
  if (typelib->count < from_lib->count)
936
1120
    return 0;
 
1121
 
937
1122
  for (uint32_t i=0 ; i < from_lib->count ; i++)
 
1123
  {
938
1124
    if (my_strnncoll(field_charset,
939
1125
                     (const unsigned char*)typelib->type_names[i],
940
1126
                     strlen(typelib->type_names[i]),
941
1127
                     (const unsigned char*)from_lib->type_names[i],
942
1128
                     strlen(from_lib->type_names[i])))
943
1129
      return 0;
 
1130
  }
 
1131
 
944
1132
  return 1;
945
1133
}
946
1134
 
949
1137
  switch (type) {
950
1138
  case DRIZZLE_TYPE_VARCHAR: return (length + (length < 256 ? 1: 2));
951
1139
  case DRIZZLE_TYPE_UUID: return field::Uuid::max_string_length();
 
1140
  case DRIZZLE_TYPE_MICROTIME: return field::Microtime::max_string_length();
 
1141
  case DRIZZLE_TYPE_TIMESTAMP: return field::Epoch::max_string_length();
 
1142
  case DRIZZLE_TYPE_BOOLEAN: return field::Boolean::max_string_length();
952
1143
  case DRIZZLE_TYPE_DATE:
953
1144
  case DRIZZLE_TYPE_ENUM:
954
1145
  case DRIZZLE_TYPE_LONG: return 4;
955
1146
  case DRIZZLE_TYPE_DOUBLE: return sizeof(double);
 
1147
  case DRIZZLE_TYPE_TIME:
956
1148
  case DRIZZLE_TYPE_DATETIME:
957
 
  case DRIZZLE_TYPE_TIMESTAMP:
958
1149
  case DRIZZLE_TYPE_LONGLONG: return 8; /* Don't crash if no int64_t */
959
1150
  case DRIZZLE_TYPE_NULL: return 0;
960
1151
  case DRIZZLE_TYPE_BLOB: return 4 + portable_sizeof_char_ptr;
961
1152
  case DRIZZLE_TYPE_DECIMAL:
962
 
                          assert(0);
963
 
                          abort();
 
1153
                          break;
964
1154
  }
965
1155
 
966
1156
  assert(0);
984
1174
*****************************************************************************/
985
1175
 
986
1176
bool Field::set_warning(DRIZZLE_ERROR::enum_warning_level level,
987
 
                        uint32_t code,
 
1177
                        drizzled::error_t code,
988
1178
                        int cuted_increment)
989
1179
{
990
1180
  /*
1004
1194
 
1005
1195
 
1006
1196
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1007
 
                                 unsigned int code,
 
1197
                                 drizzled::error_t code,
1008
1198
                                 const char *str, 
1009
1199
                                 uint32_t str_length,
1010
 
                                 enum enum_drizzle_timestamp_type ts_type, 
 
1200
                                 type::timestamp_t ts_type, 
1011
1201
                                 int cuted_increment)
1012
1202
{
1013
1203
  Session *session= table ? table->in_use : current_session;
1019
1209
}
1020
1210
 
1021
1211
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, 
1022
 
                                 uint32_t code,
 
1212
                                 drizzled::error_t code,
1023
1213
                                 int64_t nr, 
1024
 
                                 enum enum_drizzle_timestamp_type ts_type,
 
1214
                                 type::timestamp_t ts_type,
1025
1215
                                 int cuted_increment)
1026
1216
{
1027
1217
  Session *session= table ? table->in_use : current_session;
1036
1226
}
1037
1227
 
1038
1228
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1039
 
                                 const uint32_t code,
 
1229
                                 const drizzled::error_t code,
1040
1230
                                 double nr, 
1041
 
                                 enum enum_drizzle_timestamp_type ts_type)
 
1231
                                 type::timestamp_t ts_type)
1042
1232
{
1043
1233
  Session *session= table ? table->in_use : current_session;
1044
1234
  if (session->really_abort_on_warning() ||
1078
1268
    table->clearWriteSet(field_index);
1079
1269
}
1080
1270
 
 
1271
void Field::pack_num(uint64_t arg, unsigned char *destination)
 
1272
{
 
1273
  if (not destination)
 
1274
    destination= ptr;
 
1275
 
 
1276
  int64_tstore(destination, arg);
 
1277
}
 
1278
 
 
1279
void Field::pack_num(uint32_t arg, unsigned char *destination)
 
1280
{
 
1281
  if (not destination)
 
1282
    destination= ptr;
 
1283
 
 
1284
  longstore(destination, arg);
 
1285
}
 
1286
 
 
1287
uint64_t Field::unpack_num(uint64_t &destination, const unsigned char *arg) const
 
1288
{
 
1289
  if (not arg)
 
1290
    arg= ptr;
 
1291
 
 
1292
  int64_tget(destination, arg);
 
1293
 
 
1294
  return destination;
 
1295
}
 
1296
 
 
1297
uint32_t Field::unpack_num(uint32_t &destination, const unsigned char *arg) const
 
1298
{
 
1299
  if (not arg)
 
1300
    arg= ptr;
 
1301
 
 
1302
  longget(destination, arg);
 
1303
 
 
1304
  return destination;
 
1305
}
 
1306
 
1081
1307
std::ostream& operator<<(std::ostream& output, const Field &field)
1082
1308
{
1083
1309
  output << "Field:(";
1084
1310
  output <<  field.field_name;
1085
1311
  output << ", ";
1086
1312
  output << drizzled::display::type(field.real_type());
 
1313
  output << ", { ";
 
1314
 
 
1315
  if (field.flags & NOT_NULL_FLAG)
 
1316
    output << " NOT_NULL";
 
1317
 
 
1318
  if (field.flags & PRI_KEY_FLAG)
 
1319
    output << ", PRIMARY KEY";
 
1320
 
 
1321
  if (field.flags & UNIQUE_KEY_FLAG)
 
1322
    output << ", UNIQUE KEY";
 
1323
 
 
1324
  if (field.flags & MULTIPLE_KEY_FLAG)
 
1325
    output << ", MULTIPLE KEY";
 
1326
 
 
1327
  if (field.flags & BLOB_FLAG)
 
1328
    output << ", BLOB";
 
1329
 
 
1330
  if (field.flags & UNSIGNED_FLAG)
 
1331
    output << ", UNSIGNED";
 
1332
 
 
1333
  if (field.flags & BINARY_FLAG)
 
1334
    output << ", BINARY";
 
1335
  output << "}, ";
1087
1336
  output << ")";
1088
1337
 
1089
1338
  return output;  // for multiple << operators.