← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item.cc

  • Committer: Stewart Smith
  • Date: 2011-01-14 05:13:33 UTC
  • mto: (2086.1.3 build)
  • mto: This revision was merged to the branch mainline in revision 2087.
  • Revision ID: stewart@flamingspork.com-20110114051333-pz1xy0f1dyc4jfms
talk about statement rollback (briefly) in replication docs

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item.cc
102
102
      type::Decimal decimal_value;
103
103
      type::Decimal *val= val_decimal(&decimal_value);
104
104
      if (val)
105
 
        return not val->isZero();
 
105
        return not val->is_zero();
106
106
      return false;
107
107
    }
108
108
 
146
146
    return NULL;
147
147
 
148
148
  class_decimal_round(E_DEC_FATAL_ERROR, dec, decimals, false, &dec_buf);
149
 
  class_decimal2string(&dec_buf, 0, str);
 
149
  class_decimal2string(E_DEC_FATAL_ERROR, &dec_buf, 0, 0, 0, str);
150
150
  return str;
151
151
}
152
152
 
183
183
                     res->length(), 
184
184
                     res->charset()) & E_DEC_BAD_NUM)
185
185
  {
186
 
    push_warning_printf(&getSession(), 
 
186
    push_warning_printf(current_session, 
187
187
                        DRIZZLE_ERROR::WARN_LEVEL_WARN,
188
188
                        ER_TRUNCATED_WRONG_VALUE,
189
189
                        ER(ER_TRUNCATED_WRONG_VALUE), "DECIMAL",
196
196
{
197
197
  assert(fixed);
198
198
  type::Time ltime;
199
 
  if (get_date(ltime, TIME_FUZZY_DATE))
 
199
  if (get_date(&ltime, TIME_FUZZY_DATE))
200
200
  {
201
201
    decimal_value->set_zero();
202
202
    null_value= 1;                               // set NULL, stop processing
209
209
{
210
210
  assert(fixed);
211
211
  type::Time ltime;
212
 
  if (get_time(ltime))
 
212
  if (get_time(&ltime))
213
213
  {
214
214
    decimal_value->set_zero();
215
215
    return NULL;
233
233
  /* Note that fix_fields may not be called for Item_avg_field items */
234
234
  int64_t result;
235
235
  type::Decimal value, *dec_val= val_decimal(&value);
236
 
 
237
236
  if (null_value)
238
237
    return 0;
239
238
  dec_val->val_int32(E_DEC_FATAL_ERROR, unsigned_flag, &result);
240
 
 
241
239
  return result;
242
240
}
243
241
 
244
 
bool Item::save_time_in_field(Field *field)
 
242
int Item::save_time_in_field(Field *field)
245
243
{
246
244
  type::Time ltime;
247
 
 
248
 
  if (get_time(ltime))
 
245
  if (get_time(&ltime))
249
246
    return set_field_to_null(field);
250
 
 
251
247
  field->set_notnull();
252
 
 
253
 
  return field->store_time(ltime, type::DRIZZLE_TIMESTAMP_TIME);
 
248
  return field->store_time(&ltime, DRIZZLE_TIMESTAMP_TIME);
254
249
}
255
250
 
256
 
bool Item::save_date_in_field(Field *field)
 
251
int Item::save_date_in_field(Field *field)
257
252
{
258
253
  type::Time ltime;
259
 
 
260
 
  if (get_date(ltime, TIME_FUZZY_DATE))
 
254
  if (get_date(&ltime, TIME_FUZZY_DATE))
261
255
    return set_field_to_null(field);
262
 
 
263
256
  field->set_notnull();
264
 
 
265
 
  return field->store_time(ltime, type::DRIZZLE_TIMESTAMP_DATETIME);
 
257
  return field->store_time(&ltime, DRIZZLE_TIMESTAMP_DATETIME);
266
258
}
267
259
 
268
260
/**
273
265
{
274
266
  if (null_value)
275
267
    return set_field_to_null(field);
276
 
 
277
268
  field->set_notnull();
278
 
 
279
269
  return field->store(result->ptr(), result->length(), collation.collation);
280
270
}
281
271
 
294
284
  with_sum_func(false),
295
285
  is_autogenerated_name(true),
296
286
  with_subselect(false),
297
 
  collation(&my_charset_bin, DERIVATION_COERCIBLE),
298
 
  _session(*current_session)
 
287
  collation(&my_charset_bin, DERIVATION_COERCIBLE)
299
288
{
300
289
  cmp_context= (Item_result)-1;
301
290
 
302
291
  /* Put item in free list so that we can free all items at end */
303
 
  next= getSession().free_list;
304
 
  getSession().free_list= this;
 
292
  Session *session= current_session;
 
293
  next= session->free_list;
 
294
  session->free_list= this;
305
295
 
306
296
  /*
307
297
    Item constructor can be called during execution other then SQL_COM
308
298
    command => we should check session->lex->current_select on zero (session->lex
309
299
    can be uninitialised)
310
300
  */
311
 
  if (getSession().lex->current_select)
 
301
  if (session->lex->current_select)
312
302
  {
313
 
    enum_parsing_place place= getSession().getLex()->current_select->parsing_place;
 
303
    enum_parsing_place place= session->lex->current_select->parsing_place;
314
304
    if (place == SELECT_LIST || place == IN_HAVING)
315
 
      getSession().getLex()->current_select->select_n_having_items++;
 
305
      session->lex->current_select->select_n_having_items++;
316
306
  }
317
307
}
318
308
 
333
323
  is_autogenerated_name(item->is_autogenerated_name),
334
324
  with_subselect(item->with_subselect),
335
325
  collation(item->collation),
336
 
  cmp_context(item->cmp_context),
337
 
  _session(*session)
 
326
  cmp_context(item->cmp_context)
338
327
{
339
328
  /* Put this item in the session's free list */
340
 
  next= getSession().free_list;
341
 
  getSession().free_list= this;
 
329
  next= session->free_list;
 
330
  session->free_list= this;
342
331
}
343
332
 
344
333
uint32_t Item::float_length(uint32_t decimals_par) const
436
425
    if (orig_len != length && ! is_autogenerated_name)
437
426
    {
438
427
      if (length == 0)
439
 
        push_warning_printf(&getSession(), 
 
428
        push_warning_printf(current_session, 
440
429
                            DRIZZLE_ERROR::WARN_LEVEL_WARN,
441
430
                            ER_NAME_BECOMES_EMPTY, 
442
431
                            ER(ER_NAME_BECOMES_EMPTY),
443
432
                            str + length - orig_len);
444
433
      else
445
 
        push_warning_printf(&getSession(),
 
434
        push_warning_printf(current_session, 
446
435
                            DRIZZLE_ERROR::WARN_LEVEL_WARN,
447
436
                            ER_REMOVED_SPACES, 
448
437
                            ER(ER_REMOVED_SPACES),
471
460
  return conv->safe ? conv : NULL;
472
461
}
473
462
 
474
 
bool Item::get_date(type::Time &ltime,uint32_t fuzzydate)
 
463
bool Item::get_date(type::Time *ltime,uint32_t fuzzydate)
475
464
{
476
 
  do
477
 
  {
478
 
    if (is_null())
479
 
    {
480
 
      break;
481
 
    }
482
 
    else if (result_type() == STRING_RESULT)
483
 
    {
484
 
      char buff[type::Time::MAX_STRING_LENGTH];
485
 
      String tmp(buff,sizeof(buff), &my_charset_bin),*res;
486
 
      if (!(res=val_str(&tmp)) ||
487
 
          str_to_datetime_with_warn(&getSession(), res->ptr(), res->length(),
488
 
                                    &ltime, fuzzydate) <= type::DRIZZLE_TIMESTAMP_ERROR)
489
 
      {
490
 
        break;
491
 
      }
492
 
    }
493
 
    else
494
 
    {
495
 
      int64_t value= val_int();
496
 
      type::datetime_t date_value;
497
 
 
498
 
      ltime.convert(date_value, value, fuzzydate);
499
 
 
500
 
      if (not type::is_valid(date_value))
501
 
      {
502
 
        char buff[DECIMAL_LONGLONG_DIGITS], *end;
503
 
        end= internal::int64_t10_to_str(value, buff, -10);
504
 
        make_truncated_value_warning(&getSession(), DRIZZLE_ERROR::WARN_LEVEL_WARN,
505
 
                                     buff, (int) (end-buff), type::DRIZZLE_TIMESTAMP_NONE, NULL);
506
 
        break;
507
 
      }
508
 
    }
509
 
 
510
 
    return false;
511
 
  } while (0);
512
 
 
513
 
  ltime.reset();
514
 
 
 
465
  if (result_type() == STRING_RESULT)
 
466
  {
 
467
    char buff[40];
 
468
    String tmp(buff,sizeof(buff), &my_charset_bin),*res;
 
469
    if (!(res=val_str(&tmp)) ||
 
470
        str_to_datetime_with_warn(res->ptr(), res->length(),
 
471
                                  ltime, fuzzydate) <= DRIZZLE_TIMESTAMP_ERROR)
 
472
      goto err;
 
473
  }
 
474
  else
 
475
  {
 
476
    int64_t value= val_int();
 
477
    int was_cut;
 
478
    if (number_to_datetime(value, ltime, fuzzydate, &was_cut) == -1L)
 
479
    {
 
480
      char buff[22], *end;
 
481
      end= internal::int64_t10_to_str(value, buff, -10);
 
482
      make_truncated_value_warning(current_session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
483
                                   buff, (int) (end-buff), DRIZZLE_TIMESTAMP_NONE,
 
484
                                   NULL);
 
485
      goto err;
 
486
    }
 
487
  }
 
488
  return false;
 
489
 
 
490
err:
 
491
  memset(ltime, 0, sizeof(*ltime));
515
492
  return true;
516
493
}
517
494
 
518
 
bool Item::get_time(type::Time &ltime)
 
495
bool Item::get_time(type::Time *ltime)
519
496
{
520
 
  char buff[type::Time::MAX_STRING_LENGTH];
 
497
  char buff[40];
521
498
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
522
 
  if (!(res=val_str(&tmp)) or
523
 
      str_to_time_with_warn(&getSession(), res->ptr(), res->length(), &ltime))
 
499
  if (!(res=val_str(&tmp)) ||
 
500
      str_to_time_with_warn(res->ptr(), res->length(), ltime))
524
501
  {
525
 
    ltime.reset();
526
 
 
 
502
    memset(ltime, 0, sizeof(*ltime));
527
503
    return true;
528
504
  }
529
 
 
530
505
  return false;
531
506
}
532
507
 
533
 
bool Item::get_date_result(type::Time &ltime,uint32_t fuzzydate)
 
508
bool Item::get_date_result(type::Time *ltime,uint32_t fuzzydate)
534
509
{
535
 
  return get_date(ltime, fuzzydate);
 
510
  return get_date(ltime,fuzzydate);
536
511
}
537
512
 
538
513
bool Item::is_null()
884
859
    - the found item on success
885
860
    - NULL if find_item is not in group_list
886
861
*/
887
 
static Item** find_field_in_group_list(Session *session, Item *find_item, Order *group_list)
 
862
static Item** find_field_in_group_list(Item *find_item, Order *group_list)
888
863
{
889
864
  const char *db_name;
890
865
  const char *table_name;
940
915
        if (cur_field->db_name && db_name)
941
916
        {
942
917
          /* If field_name is also qualified by a database name. */
943
 
          if (my_strcasecmp(system_charset_info, cur_field->db_name, db_name))
944
 
          {
 
918
          if (strcasecmp(cur_field->db_name, db_name))
945
919
            /* Same field names, different databases. */
946
920
            return NULL;
947
 
          }
948
921
          ++cur_match_degree;
949
922
        }
950
923
      }
963
936
          best match, they must reference the same column, otherwise the field
964
937
          is ambiguous.
965
938
        */
966
 
        my_error(ER_NON_UNIQ_ERROR, MYF(0), find_item->full_name(), session->where());
 
939
        my_error(ER_NON_UNIQ_ERROR, MYF(0), find_item->full_name(), current_session->where);
967
940
        return NULL;
968
941
      }
969
942
    }
999
972
  /* If this is a non-aggregated field inside HAVING, search in GROUP BY. */
1000
973
  if (select->having_fix_field && !ref->with_sum_func && group_list)
1001
974
  {
1002
 
    group_by_ref= find_field_in_group_list(session, ref, group_list);
 
975
    group_by_ref= find_field_in_group_list(ref, group_list);
1003
976
 
1004
977
    /* Check if the fields found in SELECT and GROUP BY are the same field. */
1005
978
    if (group_by_ref && (select_ref != not_found_item) &&
1008
981
      ambiguous_fields= true;
1009
982
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_NON_UNIQ_ERROR,
1010
983
                          ER(ER_NON_UNIQ_ERROR), ref->full_name(),
1011
 
                          session->where());
 
984
                          current_session->where);
1012
985
 
1013
986
    }
1014
987
  }
1122
1095
                                       str->length(), &well_formed_error);
1123
1096
  if (wlen < str->length())
1124
1097
  {
 
1098
    Session *session= current_session;
1125
1099
    char hexbuf[7];
1126
1100
    enum DRIZZLE_ERROR::enum_warning_level level;
1127
1101
    uint32_t diff= str->length() - wlen;
1138
1112
      null_value= 1;
1139
1113
      str= 0;
1140
1114
    }
1141
 
    push_warning_printf(&getSession(), level, ER_INVALID_CHARACTER_STRING,
 
1115
    push_warning_printf(session, level, ER_INVALID_CHARACTER_STRING,
1142
1116
                        ER(ER_INVALID_CHARACTER_STRING), cs->csname, hexbuf);
1143
1117
  }
1144
1118
  return str;
1203
1177
                                 0,
1204
1178
                                 Field::NONE,
1205
1179
                                 name,
1206
 
                                 decimals);
 
1180
                                 decimals,
 
1181
                                 0,
 
1182
                                 unsigned_flag);
1207
1183
    break;
1208
1184
  case DRIZZLE_TYPE_LONG:
1209
1185
    field= new field::Int32((unsigned char*) 0, max_length, null_ptr, 0, Field::NONE, name);
1425
1401
  case DRIZZLE_TYPE_TIME:
1426
1402
    {
1427
1403
      type::Time tm;
1428
 
      get_time(tm);
 
1404
      get_time(&tm);
1429
1405
      if (not null_value)
1430
1406
        result= client->store(&tm);
1431
1407
      break;
1435
1411
  case DRIZZLE_TYPE_TIMESTAMP:
1436
1412
    {
1437
1413
      type::Time tm;
1438
 
      get_date(tm, TIME_FUZZY_DATE);
 
1414
      get_date(&tm, TIME_FUZZY_DATE);
1439
1415
      if (!null_value)
1440
1416
        result= client->store(&tm);
1441
1417
      break;
1447
1423
  return result;
1448
1424
}
1449
1425
 
1450
 
uint32_t Item::max_char_length() const
1451
 
{
1452
 
  return max_length / collation.collation->mbmaxlen;
1453
 
}
1454
 
 
1455
 
void Item::fix_length_and_charset(uint32_t max_char_length_arg, CHARSET_INFO *cs)
1456
 
{ 
1457
 
  max_length= char_to_byte_length_safe(max_char_length_arg, cs->mbmaxlen);
1458
 
  collation.collation= cs;
1459
 
}
1460
 
 
1461
 
void Item::fix_char_length(uint32_t max_char_length_arg)
1462
 
{ 
1463
 
  max_length= char_to_byte_length_safe(max_char_length_arg, collation.collation->mbmaxlen);
1464
 
}
1465
 
 
1466
 
void Item::fix_char_length_uint64_t(uint64_t max_char_length_arg)
1467
 
{ 
1468
 
  uint64_t max_result_length= max_char_length_arg *
1469
 
    collation.collation->mbmaxlen;
1470
 
 
1471
 
  if (max_result_length >= MAX_BLOB_WIDTH)
1472
 
  { 
1473
 
    max_length= MAX_BLOB_WIDTH;
1474
 
    maybe_null= false;
1475
 
  }
1476
 
  else
1477
 
  {
1478
 
    max_length= max_result_length;
1479
 
  }
1480
 
}
1481
 
 
1482
 
void Item::fix_length_and_charset_datetime(uint32_t max_char_length_arg)
1483
 
{ 
1484
 
  collation.set(&my_charset_bin);
1485
 
  fix_char_length(max_char_length_arg);
1486
 
}
1487
 
 
1488
1426
Item_result item_cmp_type(Item_result a,Item_result b)
1489
1427
{
1490
1428
  if (a == STRING_RESULT && b == STRING_RESULT)