← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.cc

  • Committer: Lee Bieber
  • Date: 2010-12-23 23:11:00 UTC
  • mfrom: (2024.1.1 clean)
  • Revision ID: kalebral@gmail.com-20101223231100-0rqirgz7ugkl10yp
Merge Brian - session list cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field.cc
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2010 Brian Aker
5
4
 *  Copyright (C) 2008 MySQL
6
5
 *
7
6
 *  This program is free software; you can redistribute it and/or modify
32
31
#include "drizzled/field/str.h"
33
32
#include "drizzled/field/num.h"
34
33
#include "drizzled/field/blob.h"
35
 
#include "drizzled/field/boolean.h"
36
34
#include "drizzled/field/enum.h"
37
35
#include "drizzled/field/null.h"
38
36
#include "drizzled/field/date.h"
45
43
#include "drizzled/field/time.h"
46
44
#include "drizzled/field/epoch.h"
47
45
#include "drizzled/field/datetime.h"
48
 
#include "drizzled/field/microtime.h"
49
46
#include "drizzled/field/varstring.h"
50
47
#include "drizzled/field/uuid.h"
51
48
#include "drizzled/time_functions.h"
89
86
    DRIZZLE_TYPE_BLOB,
90
87
    //DRIZZLE_TYPE_TIME
91
88
    DRIZZLE_TYPE_TIME,
92
 
    //DRIZZLE_TYPE_BOOLEAN
93
 
    DRIZZLE_TYPE_VARCHAR,
94
89
    //DRIZZLE_TYPE_UUID
95
90
    DRIZZLE_TYPE_VARCHAR,
96
 
    //DRIZZLE_TYPE_MICROTIME
97
 
    DRIZZLE_TYPE_VARCHAR,
98
91
  },
99
92
  /* DRIZZLE_TYPE_DOUBLE -> */
100
93
  {
122
115
    DRIZZLE_TYPE_BLOB,
123
116
    //DRIZZLE_TYPE_TIME
124
117
    DRIZZLE_TYPE_TIME,
125
 
    //DRIZZLE_TYPE_BOOLEAN
126
 
    DRIZZLE_TYPE_VARCHAR,
127
118
    //DRIZZLE_TYPE_UUID
128
119
    DRIZZLE_TYPE_VARCHAR,
129
 
    //DRIZZLE_TYPE_MICROTIME
130
 
    DRIZZLE_TYPE_VARCHAR,
131
120
  },
132
121
  /* DRIZZLE_TYPE_NULL -> */
133
122
  {
155
144
    DRIZZLE_TYPE_BLOB,
156
145
    //DRIZZLE_TYPE_TIME
157
146
    DRIZZLE_TYPE_TIME,
158
 
    //DRIZZLE_TYPE_BOOLEAN
159
 
    DRIZZLE_TYPE_BOOLEAN,
160
147
    //DRIZZLE_TYPE_UUID
161
148
    DRIZZLE_TYPE_UUID,
162
 
    //DRIZZLE_TYPE_MICROTIME
163
 
    DRIZZLE_TYPE_MICROTIME,
164
149
  },
165
150
  /* DRIZZLE_TYPE_TIMESTAMP -> */
166
151
  {
188
173
    DRIZZLE_TYPE_BLOB,
189
174
    //DRIZZLE_TYPE_TIME
190
175
    DRIZZLE_TYPE_TIME,
191
 
    //DRIZZLE_TYPE_BOOLEAN
192
 
    DRIZZLE_TYPE_VARCHAR,
193
176
    //DRIZZLE_TYPE_UUID
194
177
    DRIZZLE_TYPE_VARCHAR,
195
 
    //DRIZZLE_TYPE_MICROTIME
196
 
    DRIZZLE_TYPE_VARCHAR,
197
178
  },
198
179
  /* DRIZZLE_TYPE_LONGLONG -> */
199
180
  {
220
201
    DRIZZLE_TYPE_BLOB,
221
202
    //DRIZZLE_TYPE_TIME
222
203
    DRIZZLE_TYPE_TIME,
223
 
    //DRIZZLE_TYPE_BOOLEAN
224
 
    DRIZZLE_TYPE_VARCHAR,
225
204
    //DRIZZLE_TYPE_UUID
226
205
    DRIZZLE_TYPE_VARCHAR,
227
 
    //DRIZZLE_TYPE_MICROTIME
228
 
    DRIZZLE_TYPE_VARCHAR,
229
206
  },
230
207
  /* DRIZZLE_TYPE_DATETIME -> */
231
208
  {
253
230
    DRIZZLE_TYPE_BLOB,
254
231
    //DRIZZLE_TYPE_TIME
255
232
    DRIZZLE_TYPE_TIME,
256
 
    //DRIZZLE_TYPE_BOOLEAN
257
 
    DRIZZLE_TYPE_VARCHAR,
258
233
    //DRIZZLE_TYPE_UUID
259
234
    DRIZZLE_TYPE_VARCHAR,
260
 
    //DRIZZLE_TYPE_MICROTIME
261
 
    DRIZZLE_TYPE_VARCHAR,
262
235
  },
263
236
  /* DRIZZLE_TYPE_DATE -> */
264
237
  {
286
259
    DRIZZLE_TYPE_BLOB,
287
260
    //DRIZZLE_TYPE_TIME
288
261
    DRIZZLE_TYPE_TIME,
289
 
    //DRIZZLE_TYPE_BOOLEAN
290
 
    DRIZZLE_TYPE_VARCHAR,
291
262
    //DRIZZLE_TYPE_UUID
292
263
    DRIZZLE_TYPE_VARCHAR,
293
 
    //DRIZZLE_TYPE_MICROTIME
294
 
    DRIZZLE_TYPE_VARCHAR,
295
264
  },
296
265
  /* DRIZZLE_TYPE_VARCHAR -> */
297
266
  {
319
288
    DRIZZLE_TYPE_BLOB,
320
289
    //DRIZZLE_TYPE_TIME
321
290
    DRIZZLE_TYPE_TIME,
322
 
    //DRIZZLE_TYPE_BOOLEAN
323
 
    DRIZZLE_TYPE_VARCHAR,
324
291
    //DRIZZLE_TYPE_UUID
325
292
    DRIZZLE_TYPE_VARCHAR,
326
 
    //DRIZZLE_TYPE_MICROTIME
327
 
    DRIZZLE_TYPE_VARCHAR,
328
293
  },
329
294
  /* DRIZZLE_TYPE_DECIMAL -> */
330
295
  {
352
317
    DRIZZLE_TYPE_BLOB,
353
318
    //DRIZZLE_TYPE_TIME
354
319
    DRIZZLE_TYPE_TIME,
355
 
    //DRIZZLE_TYPE_BOOLEAN
356
 
    DRIZZLE_TYPE_VARCHAR,
357
320
    //DRIZZLE_TYPE_UUID
358
321
    DRIZZLE_TYPE_VARCHAR,
359
 
    //DRIZZLE_TYPE_MICROTIME
360
 
    DRIZZLE_TYPE_VARCHAR,
361
322
  },
362
323
  /* DRIZZLE_TYPE_ENUM -> */
363
324
  {
385
346
    DRIZZLE_TYPE_BLOB,
386
347
    //DRIZZLE_TYPE_TIME
387
348
    DRIZZLE_TYPE_TIME,
388
 
    //DRIZZLE_TYPE_BOOLEAN
389
 
    DRIZZLE_TYPE_VARCHAR,
390
349
    //DRIZZLE_TYPE_UUID
391
350
    DRIZZLE_TYPE_VARCHAR,
392
 
    //DRIZZLE_TYPE_MICROTIME
393
 
    DRIZZLE_TYPE_VARCHAR,
394
351
   },
395
352
  /* DRIZZLE_TYPE_BLOB -> */
396
353
  {
418
375
    DRIZZLE_TYPE_BLOB,
419
376
    //DRIZZLE_TYPE_TIME
420
377
    DRIZZLE_TYPE_TIME,
421
 
    //DRIZZLE_TYPE_BOOLEAN
422
 
    DRIZZLE_TYPE_VARCHAR,
423
378
    //DRIZZLE_TYPE_UUID
424
379
    DRIZZLE_TYPE_VARCHAR,
425
 
    //DRIZZLE_TYPE_MICROTIME
426
 
    DRIZZLE_TYPE_VARCHAR,
427
380
  },
428
381
  /* DRIZZLE_TYPE_TIME -> */
429
382
  {
451
404
    DRIZZLE_TYPE_BLOB,
452
405
    //DRIZZLE_TYPE_TIME
453
406
    DRIZZLE_TYPE_TIME,
454
 
    //DRIZZLE_TYPE_BOOLEAN
455
 
    DRIZZLE_TYPE_VARCHAR,
456
407
    //DRIZZLE_TYPE_UUID
457
408
    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
492
 
    DRIZZLE_TYPE_VARCHAR,
493
409
  },
494
410
  /* DRIZZLE_TYPE_UUID -> */
495
411
  {
517
433
    DRIZZLE_TYPE_BLOB,
518
434
    //DRIZZLE_TYPE_TIME
519
435
    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,
 
436
    //DRIZZLE_TYPE_UUID
 
437
    DRIZZLE_TYPE_UUID,
559
438
  },
560
439
};
561
440
 
585
464
  STRING_RESULT,
586
465
  //DRIZZLE_TYPE_TIME
587
466
  STRING_RESULT,
588
 
  //DRIZZLE_TYPE_BOOLEAN
589
 
  STRING_RESULT,
590
467
  //DRIZZLE_TYPE_UUID
591
468
  STRING_RESULT,
592
 
  //DRIZZLE_TYPE_MICROTIME
593
 
  STRING_RESULT,
594
469
};
595
470
 
596
471
bool test_if_important_data(const CHARSET_INFO * const cs, 
827
702
             unsigned char *null_ptr_arg,
828
703
             unsigned char null_bit_arg,
829
704
             utype unireg_check_arg, 
830
 
             const char *field_name_arg) :
 
705
             const char *field_name_arg)
 
706
  :
831
707
    ptr(ptr_arg),
832
708
    null_ptr(null_ptr_arg),
833
709
    table(NULL),
834
710
    orig_table(NULL),
835
711
    field_name(field_name_arg),
836
 
    comment(NULL_LEX_STRING),
837
712
    key_start(0),
838
713
    part_of_key(0),
839
714
    part_of_key_not_clustered(0),
840
715
    part_of_sortkey(0),
841
716
    unireg_check(unireg_check_arg),
842
717
    field_length(length_arg),
843
 
    flags(null_ptr ? 0: NOT_NULL_FLAG),
844
 
    field_index(0),
845
718
    null_bit(null_bit_arg),
846
719
    is_created_from_null_item(false)
847
720
{
 
721
  flags= null_ptr ? 0: NOT_NULL_FLAG;
 
722
  comment.str= (char*) "";
 
723
  comment.length= 0;
 
724
  field_index= 0;
848
725
}
849
726
 
850
727
void Field::hash(uint32_t *nr, uint32_t *nr2)
939
816
  return(result);
940
817
}
941
818
 
942
 
type::Decimal *Field::val_decimal(type::Decimal *)
 
819
my_decimal *Field::val_decimal(my_decimal *)
943
820
{
944
821
  /* This never have to be called */
945
822
  assert(0);
974
851
  field->decimals= 0;
975
852
}
976
853
 
977
 
int64_t Field::convert_decimal2int64_t(const type::Decimal *val, bool, int *err)
 
854
int64_t Field::convert_decimal2int64_t(const my_decimal *val, bool, int *err)
978
855
{
979
856
  int64_t i;
980
 
  if (warn_if_overflow(val->val_int32(E_DEC_ERROR &
 
857
  if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
981
858
                                      ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
982
 
                                      false, &i)))
 
859
                                      val, false, &i)))
983
860
  {
984
861
    i= (val->sign() ? INT64_MIN : INT64_MAX);
985
862
    *err= 1;
997
874
  {
998
875
    copy->blob_field=(Field_blob*) this;
999
876
    copy->strip=0;
1000
 
    copy->length-= table->getShare()->sizeBlobPtr();
 
877
    copy->length-= table->getShare()->blob_ptr_size;
1001
878
    return copy->length;
1002
879
  }
1003
880
  else
1008
885
  return copy->length+ store_length;
1009
886
}
1010
887
 
1011
 
bool Field::get_date(type::Time &ltime, uint32_t fuzzydate)
1012
 
{
1013
 
  char buff[type::Time::MAX_STRING_LENGTH];
1014
 
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
1015
 
 
1016
 
  assert(getTable() and getTable()->getSession());
1017
 
 
1018
 
  if (not (res=val_str_internal(&tmp)) or
1019
 
      str_to_datetime_with_warn(getTable()->getSession(),
1020
 
                                res->ptr(), res->length(),
1021
 
                                &ltime, fuzzydate) <= type::DRIZZLE_TIMESTAMP_ERROR)
1022
 
  {
1023
 
    return true;
1024
 
  }
1025
 
 
1026
 
  return false;
1027
 
}
1028
 
 
1029
 
bool Field::get_time(type::Time &ltime)
1030
 
{
1031
 
  char buff[type::Time::MAX_STRING_LENGTH];
1032
 
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
1033
 
 
1034
 
  if (not (res= val_str_internal(&tmp)) or
1035
 
      str_to_time_with_warn(getTable()->getSession(), res->ptr(), res->length(), &ltime))
1036
 
  {
1037
 
    return true;
1038
 
  }
1039
 
 
1040
 
  return false;
1041
 
}
1042
 
 
1043
 
int Field::store_time(type::Time &ltime, type::timestamp_t)
1044
 
{
1045
 
  String tmp;
1046
 
 
1047
 
  ltime.convert(tmp);
1048
 
 
1049
 
  return store(tmp.ptr(), tmp.length(), &my_charset_bin);
 
888
bool Field::get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
 
889
{
 
890
  char buff[40];
 
891
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
 
892
  if (!(res=val_str_internal(&tmp)) || str_to_datetime_with_warn(res->ptr(), res->length(),
 
893
                                                                 ltime, fuzzydate) <= DRIZZLE_TIMESTAMP_ERROR)
 
894
  {
 
895
    return 1;
 
896
  }
 
897
 
 
898
  return 0;
 
899
}
 
900
 
 
901
bool Field::get_time(DRIZZLE_TIME *ltime)
 
902
{
 
903
  char buff[40];
 
904
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
 
905
 
 
906
  if (!(res=val_str_internal(&tmp)) || str_to_time_with_warn(res->ptr(), res->length(), ltime))
 
907
  {
 
908
    return 1;
 
909
  }
 
910
 
 
911
  return 0;
 
912
}
 
913
 
 
914
int Field::store_time(DRIZZLE_TIME *ltime, enum enum_drizzle_timestamp_type)
 
915
{
 
916
  char buff[MAX_DATE_STRING_REP_LENGTH];
 
917
  uint32_t length= (uint32_t) my_TIME_to_str(ltime, buff);
 
918
  return store(buff, length, &my_charset_bin);
1050
919
}
1051
920
 
1052
921
bool Field::optimize_range(uint32_t idx, uint32_t)
1117
986
{
1118
987
  if (!Field::eq_def(field))
1119
988
    return 0;
1120
 
 
1121
989
  TYPELIB *from_lib=((Field_enum*) field)->typelib;
1122
990
 
1123
991
  if (typelib->count < from_lib->count)
1124
992
    return 0;
1125
 
 
1126
993
  for (uint32_t i=0 ; i < from_lib->count ; i++)
1127
 
  {
1128
994
    if (my_strnncoll(field_charset,
1129
995
                     (const unsigned char*)typelib->type_names[i],
1130
996
                     strlen(typelib->type_names[i]),
1131
997
                     (const unsigned char*)from_lib->type_names[i],
1132
998
                     strlen(from_lib->type_names[i])))
1133
999
      return 0;
1134
 
  }
1135
 
 
1136
1000
  return 1;
1137
1001
}
1138
1002
 
1141
1005
  switch (type) {
1142
1006
  case DRIZZLE_TYPE_VARCHAR: return (length + (length < 256 ? 1: 2));
1143
1007
  case DRIZZLE_TYPE_UUID: return field::Uuid::max_string_length();
1144
 
  case DRIZZLE_TYPE_MICROTIME: return field::Microtime::max_string_length();
1145
 
  case DRIZZLE_TYPE_TIMESTAMP: return field::Epoch::max_string_length();
1146
 
  case DRIZZLE_TYPE_BOOLEAN: return field::Boolean::max_string_length();
1147
1008
  case DRIZZLE_TYPE_DATE:
1148
1009
  case DRIZZLE_TYPE_ENUM:
1149
1010
  case DRIZZLE_TYPE_LONG: return 4;
1150
1011
  case DRIZZLE_TYPE_DOUBLE: return sizeof(double);
1151
1012
  case DRIZZLE_TYPE_TIME:
1152
1013
  case DRIZZLE_TYPE_DATETIME:
 
1014
  case DRIZZLE_TYPE_TIMESTAMP:
1153
1015
  case DRIZZLE_TYPE_LONGLONG: return 8; /* Don't crash if no int64_t */
1154
1016
  case DRIZZLE_TYPE_NULL: return 0;
1155
1017
  case DRIZZLE_TYPE_BLOB: return 4 + portable_sizeof_char_ptr;
1178
1040
*****************************************************************************/
1179
1041
 
1180
1042
bool Field::set_warning(DRIZZLE_ERROR::enum_warning_level level,
1181
 
                        drizzled::error_t code,
 
1043
                        uint32_t code,
1182
1044
                        int cuted_increment)
1183
1045
{
1184
1046
  /*
1198
1060
 
1199
1061
 
1200
1062
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1201
 
                                 drizzled::error_t code,
 
1063
                                 unsigned int code,
1202
1064
                                 const char *str, 
1203
1065
                                 uint32_t str_length,
1204
 
                                 type::timestamp_t ts_type, 
 
1066
                                 enum enum_drizzle_timestamp_type ts_type, 
1205
1067
                                 int cuted_increment)
1206
1068
{
1207
 
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
1208
 
 
1209
 
  if ((session->abortOnWarning() and
 
1069
  Session *session= table ? table->in_use : current_session;
 
1070
  if ((session->really_abort_on_warning() &&
1210
1071
       level >= DRIZZLE_ERROR::WARN_LEVEL_WARN) ||
1211
1072
      set_warning(level, code, cuted_increment))
1212
1073
    make_truncated_value_warning(session, level, str, str_length, ts_type,
1214
1075
}
1215
1076
 
1216
1077
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, 
1217
 
                                 drizzled::error_t code,
 
1078
                                 uint32_t code,
1218
1079
                                 int64_t nr, 
1219
 
                                 type::timestamp_t ts_type,
 
1080
                                 enum enum_drizzle_timestamp_type ts_type,
1220
1081
                                 int cuted_increment)
1221
1082
{
1222
 
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
1223
 
 
1224
 
  if (session->abortOnWarning() or
 
1083
  Session *session= table ? table->in_use : current_session;
 
1084
  if (session->really_abort_on_warning() ||
1225
1085
      set_warning(level, code, cuted_increment))
1226
1086
  {
1227
 
    char str_nr[DECIMAL_LONGLONG_DIGITS];
 
1087
    char str_nr[22];
1228
1088
    char *str_end= internal::int64_t10_to_str(nr, str_nr, -10);
1229
1089
    make_truncated_value_warning(session, level, str_nr, (uint32_t) (str_end - str_nr),
1230
1090
                                 ts_type, field_name);
1232
1092
}
1233
1093
 
1234
1094
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1235
 
                                 const drizzled::error_t code,
 
1095
                                 const uint32_t code,
1236
1096
                                 double nr, 
1237
 
                                 type::timestamp_t ts_type)
 
1097
                                 enum enum_drizzle_timestamp_type ts_type)
1238
1098
{
1239
 
  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
1240
 
 
1241
 
  if (session->abortOnWarning() or
 
1099
  Session *session= table ? table->in_use : current_session;
 
1100
  if (session->really_abort_on_warning() ||
1242
1101
      set_warning(level, code, 1))
1243
1102
  {
1244
1103
    /* DBL_DIG is enough to print '-[digits].E+###' */
1283
1142
  int64_tstore(destination, arg);
1284
1143
}
1285
1144
 
1286
 
void Field::pack_num(uint32_t arg, unsigned char *destination)
1287
 
{
1288
 
  if (not destination)
1289
 
    destination= ptr;
1290
 
 
1291
 
  longstore(destination, arg);
1292
 
}
1293
 
 
1294
1145
uint64_t Field::unpack_num(uint64_t &destination, const unsigned char *arg) const
1295
1146
{
1296
1147
  if (not arg)
1301
1152
  return destination;
1302
1153
}
1303
1154
 
1304
 
uint32_t Field::unpack_num(uint32_t &destination, const unsigned char *arg) const
1305
 
{
1306
 
  if (not arg)
1307
 
    arg= ptr;
1308
 
 
1309
 
  longget(destination, arg);
1310
 
 
1311
 
  return destination;
1312
 
}
1313
 
 
1314
1155
std::ostream& operator<<(std::ostream& output, const Field &field)
1315
1156
{
1316
1157
  output << "Field:(";