← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item.cc

  • Committer: Brian Aker
  • Date: 2010-08-03 20:57:39 UTC
  • mfrom: (1680.6.4 rollup)
  • Revision ID: brian@gaz-20100803205739-7betgobkod41363k
Removes LOCK_system_variables_hash, one goto, drops internall new for std
new (so possible performance regression), fixes bug where Session was not
unlocked correctly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item.cc
41
41
#include "drizzled/field/decimal.h"
42
42
#include "drizzled/field/real.h"
43
43
#include "drizzled/field/double.h"
44
 
#include "drizzled/field/int32.h"
45
 
#include "drizzled/field/int64.h"
 
44
#include "drizzled/field/long.h"
 
45
#include "drizzled/field/int64_t.h"
46
46
#include "drizzled/field/num.h"
47
47
#include "drizzled/field/timestamp.h"
48
48
#include "drizzled/field/datetime.h"
92
92
  {
93
93
    case INT_RESULT:
94
94
      return val_int() != 0;
95
 
 
96
95
    case DECIMAL_RESULT:
97
96
    {
98
97
      my_decimal decimal_value;
101
100
        return !my_decimal_is_zero(val);
102
101
      return false;
103
102
    }
104
 
 
105
103
    case REAL_RESULT:
106
104
    case STRING_RESULT:
107
105
      return val_real() != 0.0;
108
 
 
109
106
    case ROW_RESULT:
 
107
    default:
110
108
      assert(0);
111
 
      abort();
 
109
      return false;
112
110
  }
113
 
 
114
 
  assert(0);
115
 
  abort();
116
111
}
117
112
 
118
113
String *Item::val_string_from_real(String *str)
856
851
    - the found item on success
857
852
    - NULL if find_item is not in group_list
858
853
*/
859
 
static Item** find_field_in_group_list(Item *find_item, Order *group_list)
 
854
static Item** find_field_in_group_list(Item *find_item, order_st *group_list)
860
855
{
861
856
  const char *db_name;
862
857
  const char *table_name;
863
858
  const char *field_name;
864
 
  Order *found_group= NULL;
 
859
  order_st *found_group= NULL;
865
860
  int found_match_degree= 0;
866
861
  Item_ident *cur_field;
867
862
  int cur_match_degree= 0;
887
882
 
888
883
  assert(field_name != 0);
889
884
 
890
 
  for (Order *cur_group= group_list ; cur_group ; cur_group= cur_group->next)
 
885
  for (order_st *cur_group= group_list ; cur_group ; cur_group= cur_group->next)
891
886
  {
892
887
    if ((*(cur_group->item))->real_item()->type() == Item::FIELD_ITEM)
893
888
    {
949
944
{
950
945
  Item **group_by_ref= NULL;
951
946
  Item **select_ref= NULL;
952
 
  Order *group_list= (Order*) select->group_list.first;
 
947
  order_st *group_list= (order_st*) select->group_list.first;
953
948
  bool ambiguous_fields= false;
954
949
  uint32_t counter;
955
950
  enum_resolution_type resolution;
1049
1044
  case REAL_RESULT:    
1050
1045
    return DRIZZLE_TYPE_DOUBLE;
1051
1046
  case ROW_RESULT:
 
1047
  default:
1052
1048
    assert(0);
 
1049
    return DRIZZLE_TYPE_VARCHAR;
1053
1050
  }
1054
 
 
1055
 
  abort();
1056
1051
}
1057
1052
 
1058
1053
bool Item::is_datetime()
1063
1058
    case DRIZZLE_TYPE_DATETIME:
1064
1059
    case DRIZZLE_TYPE_TIMESTAMP:
1065
1060
      return true;
1066
 
    case DRIZZLE_TYPE_BLOB:
1067
 
    case DRIZZLE_TYPE_VARCHAR:
1068
 
    case DRIZZLE_TYPE_DOUBLE:
1069
 
    case DRIZZLE_TYPE_DECIMAL:
1070
 
    case DRIZZLE_TYPE_ENUM:
1071
 
    case DRIZZLE_TYPE_LONG:
1072
 
    case DRIZZLE_TYPE_LONGLONG:
1073
 
    case DRIZZLE_TYPE_NULL:
1074
 
    case DRIZZLE_TYPE_UUID:
1075
 
      return false;
 
1061
    default:
 
1062
      break;
1076
1063
  }
1077
 
 
1078
 
  assert(0);
1079
 
  abort();
 
1064
  return false;
1080
1065
}
1081
1066
 
1082
1067
String *Item::check_well_formed_result(String *str, bool send_error)
1139
1124
  Field *field;
1140
1125
  assert(collation.collation);
1141
1126
  if (max_length/collation.collation->mbmaxlen > CONVERT_IF_BIGGER_TO_BLOB)
1142
 
  {
1143
1127
    field= new Field_blob(max_length, maybe_null, name,
1144
1128
                          collation.collation);
1145
 
  }
1146
1129
  else
1147
 
  {
1148
 
    table->setVariableWidth();
1149
 
    field= new Field_varstring(max_length, maybe_null, name,
 
1130
    field= new Field_varstring(max_length, maybe_null, name, table->getMutableShare(),
1150
1131
                               collation.collation);
1151
 
  }
1152
1132
 
1153
1133
  if (field)
1154
1134
    field->init(table);
1161
1141
    The field functions defines a field to be not null if null_ptr is not 0
1162
1142
  */
1163
1143
  unsigned char *null_ptr= maybe_null ? (unsigned char*) "" : 0;
1164
 
  Field *field= NULL;
 
1144
  Field *field;
1165
1145
 
1166
1146
  switch (field_type()) {
1167
1147
  case DRIZZLE_TYPE_DECIMAL:
1176
1156
                                 unsigned_flag);
1177
1157
    break;
1178
1158
  case DRIZZLE_TYPE_LONG:
1179
 
    field= new field::Int32((unsigned char*) 0, max_length, null_ptr, 0, Field::NONE, name);
 
1159
    field= new Field_long((unsigned char*) 0, max_length, null_ptr, 0, Field::NONE,
 
1160
                          name, 0, unsigned_flag);
1180
1161
    break;
1181
1162
  case DRIZZLE_TYPE_LONGLONG:
1182
 
    field= new field::Int64((unsigned char*) 0, max_length, null_ptr, 0, Field::NONE, name);
 
1163
    field= new Field_int64_t((unsigned char*) 0, max_length, null_ptr, 0, Field::NONE,
 
1164
                              name, 0, unsigned_flag);
1183
1165
    break;
1184
1166
  case DRIZZLE_TYPE_DOUBLE:
1185
1167
    field= new Field_double((unsigned char*) 0, max_length, null_ptr, 0, Field::NONE,
1186
 
                            name, decimals, 0, unsigned_flag);
 
1168
                            name, decimals, 0, unsigned_flag);
1187
1169
    break;
1188
1170
  case DRIZZLE_TYPE_NULL:
1189
1171
    field= new Field_null((unsigned char*) 0, max_length, name, &my_charset_bin);
1197
1179
  case DRIZZLE_TYPE_DATETIME:
1198
1180
    field= new Field_datetime(maybe_null, name, &my_charset_bin);
1199
1181
    break;
1200
 
  case DRIZZLE_TYPE_UUID:
 
1182
  default:
 
1183
    /* This case should never be chosen */
 
1184
    assert(0);
 
1185
    /* Fall through to make_string_field() */
1201
1186
  case DRIZZLE_TYPE_ENUM:
1202
1187
  case DRIZZLE_TYPE_VARCHAR:
1203
1188
    return make_string_field(table);
1204
1189
  case DRIZZLE_TYPE_BLOB:
 
1190
    if (this->type() == Item::TYPE_HOLDER)
 
1191
      field= new Field_blob(max_length, maybe_null, name, collation.collation,
 
1192
                            1);
 
1193
    else
1205
1194
      field= new Field_blob(max_length, maybe_null, name, collation.collation);
1206
1195
    break;                                      // Blob handled outside of case
1207
1196
  }
1208
 
  assert(field);
1209
 
 
1210
1197
  if (field)
1211
1198
    field->init(table);
1212
1199
  return field;
1341
1328
  enum_field_types f_type;
1342
1329
 
1343
1330
  switch ((f_type=field_type())) {
1344
 
  case DRIZZLE_TYPE_DATE:
 
1331
  default:
1345
1332
  case DRIZZLE_TYPE_NULL:
1346
1333
  case DRIZZLE_TYPE_ENUM:
1347
1334
  case DRIZZLE_TYPE_BLOB:
1348
1335
  case DRIZZLE_TYPE_VARCHAR:
1349
 
  case DRIZZLE_TYPE_UUID:
1350
1336
  case DRIZZLE_TYPE_DECIMAL:
1351
 
    {
1352
 
      String *res;
1353
 
      if ((res=val_str(buffer)))
1354
 
        result= client->store(res->ptr(),res->length());
1355
 
      break;
1356
 
    }
 
1337
  {
 
1338
    String *res;
 
1339
    if ((res=val_str(buffer)))
 
1340
      result= client->store(res->ptr(),res->length());
 
1341
    break;
 
1342
  }
1357
1343
  case DRIZZLE_TYPE_LONG:
1358
 
    {
1359
 
      int64_t nr;
1360
 
      nr= val_int();
1361
 
      if (!null_value)
1362
 
        result= client->store((int32_t)nr);
1363
 
      break;
1364
 
    }
 
1344
  {
 
1345
    int64_t nr;
 
1346
    nr= val_int();
 
1347
    if (!null_value)
 
1348
      result= client->store((int32_t)nr);
 
1349
    break;
 
1350
  }
1365
1351
  case DRIZZLE_TYPE_LONGLONG:
 
1352
  {
 
1353
    int64_t nr;
 
1354
    nr= val_int();
 
1355
    if (!null_value)
1366
1356
    {
1367
 
      int64_t nr;
1368
 
      nr= val_int();
1369
 
      if (!null_value)
1370
 
      {
1371
 
        if (unsigned_flag)
1372
 
          result= client->store((uint64_t)nr);
1373
 
        else
1374
 
          result= client->store((int64_t)nr);
1375
 
      }
1376
 
      break;
 
1357
      if (unsigned_flag)
 
1358
        result= client->store((uint64_t)nr);
 
1359
      else
 
1360
        result= client->store((int64_t)nr);
1377
1361
    }
 
1362
    break;
 
1363
  }
1378
1364
  case DRIZZLE_TYPE_DOUBLE:
1379
 
    {
1380
 
      double nr= val_real();
1381
 
      if (!null_value)
1382
 
        result= client->store(nr, decimals, buffer);
1383
 
      break;
1384
 
    }
 
1365
  {
 
1366
    double nr= val_real();
 
1367
    if (!null_value)
 
1368
      result= client->store(nr, decimals, buffer);
 
1369
    break;
 
1370
  }
1385
1371
  case DRIZZLE_TYPE_DATETIME:
1386
1372
  case DRIZZLE_TYPE_TIMESTAMP:
1387
 
    {
1388
 
      DRIZZLE_TIME tm;
1389
 
      get_date(&tm, TIME_FUZZY_DATE);
1390
 
      if (!null_value)
1391
 
        result= client->store(&tm);
1392
 
      break;
1393
 
    }
 
1373
  {
 
1374
    DRIZZLE_TIME tm;
 
1375
    get_date(&tm, TIME_FUZZY_DATE);
 
1376
    if (!null_value)
 
1377
      result= client->store(&tm);
 
1378
    break;
 
1379
  }
1394
1380
  }
1395
1381
  if (null_value)
1396
1382
    result= client->store();
1397
 
 
1398
1383
  return result;
1399
1384
}
1400
1385
 
1402
1387
{
1403
1388
  if (a == STRING_RESULT && b == STRING_RESULT)
1404
1389
    return STRING_RESULT;
1405
 
 
1406
1390
  if (a == INT_RESULT && b == INT_RESULT)
1407
1391
    return INT_RESULT;
1408
1392
  else if (a == ROW_RESULT || b == ROW_RESULT)
1409
1393
    return ROW_RESULT;
1410
 
 
1411
1394
  if ((a == INT_RESULT || a == DECIMAL_RESULT) &&
1412
1395
      (b == INT_RESULT || b == DECIMAL_RESULT))
1413
1396
    return DECIMAL_RESULT;
1414
 
 
1415
1397
  return REAL_RESULT;
1416
1398
}
1417
1399
 
1427
1409
 
1428
1410
  switch (res_type) {
1429
1411
  case STRING_RESULT:
 
1412
  {
 
1413
    char buff[MAX_FIELD_WIDTH];
 
1414
    String tmp(buff,sizeof(buff),&my_charset_bin),*result;
 
1415
    result=item->val_str(&tmp);
 
1416
    if (item->null_value)
 
1417
      new_item= new Item_null(name);
 
1418
    else
1430
1419
    {
1431
 
      char buff[MAX_FIELD_WIDTH];
1432
 
      String tmp(buff,sizeof(buff),&my_charset_bin),*result;
1433
 
      result=item->val_str(&tmp);
1434
 
      if (item->null_value)
1435
 
        new_item= new Item_null(name);
1436
 
      else
1437
 
      {
1438
 
        uint32_t length= result->length();
1439
 
        char *tmp_str= memory::sql_strmake(result->ptr(), length);
1440
 
        new_item= new Item_string(name, tmp_str, length, result->charset());
1441
 
      }
1442
 
      break;
 
1420
      uint32_t length= result->length();
 
1421
      char *tmp_str= memory::sql_strmake(result->ptr(), length);
 
1422
      new_item= new Item_string(name, tmp_str, length, result->charset());
1443
1423
    }
 
1424
    break;
 
1425
  }
1444
1426
  case INT_RESULT:
1445
 
    {
1446
 
      int64_t result=item->val_int();
1447
 
      uint32_t length=item->max_length;
1448
 
      bool null_value=item->null_value;
1449
 
      new_item= (null_value ? (Item*) new Item_null(name) :
1450
 
                 (Item*) new Item_int(name, result, length));
1451
 
      break;
1452
 
    }
 
1427
  {
 
1428
    int64_t result=item->val_int();
 
1429
    uint32_t length=item->max_length;
 
1430
    bool null_value=item->null_value;
 
1431
    new_item= (null_value ? (Item*) new Item_null(name) :
 
1432
               (Item*) new Item_int(name, result, length));
 
1433
    break;
 
1434
  }
1453
1435
  case ROW_RESULT:
1454
 
    if (item->type() == Item::ROW_ITEM && comp_item->type() == Item::ROW_ITEM)
1455
 
    {
1456
 
      /*
1457
 
        Substitute constants only in Item_rows. Don't affect other Items
1458
 
        with ROW_RESULT (eg Item_singlerow_subselect).
 
1436
  if (item->type() == Item::ROW_ITEM && comp_item->type() == Item::ROW_ITEM)
 
1437
  {
 
1438
    /*
 
1439
      Substitute constants only in Item_rows. Don't affect other Items
 
1440
      with ROW_RESULT (eg Item_singlerow_subselect).
1459
1441
 
1460
 
        For such Items more optimal is to detect if it is constant and replace
1461
 
        it with Item_row. This would optimize queries like this:
1462
 
        SELECT * FROM t1 WHERE (a,b) = (SELECT a,b FROM t2 LIMIT 1);
1463
 
      */
1464
 
      Item_row *item_row= (Item_row*) item;
1465
 
      Item_row *comp_item_row= (Item_row*) comp_item;
1466
 
      uint32_t col;
1467
 
      new_item= 0;
1468
 
      /*
1469
 
        If item and comp_item are both Item_rows and have same number of cols
1470
 
        then process items in Item_row one by one.
1471
 
        We can't ignore NULL values here as this item may be used with <=>, in
1472
 
        which case NULL's are significant.
1473
 
      */
1474
 
      assert(item->result_type() == comp_item->result_type());
1475
 
      assert(item_row->cols() == comp_item_row->cols());
1476
 
      col= item_row->cols();
1477
 
      while (col-- > 0)
1478
 
        resolve_const_item(session, item_row->addr(col),
1479
 
                           comp_item_row->element_index(col));
1480
 
      break;
1481
 
    }
1482
 
    /* Fallthrough */
 
1442
      For such Items more optimal is to detect if it is constant and replace
 
1443
      it with Item_row. This would optimize queries like this:
 
1444
      SELECT * FROM t1 WHERE (a,b) = (SELECT a,b FROM t2 LIMIT 1);
 
1445
    */
 
1446
    Item_row *item_row= (Item_row*) item;
 
1447
    Item_row *comp_item_row= (Item_row*) comp_item;
 
1448
    uint32_t col;
 
1449
    new_item= 0;
 
1450
    /*
 
1451
      If item and comp_item are both Item_rows and have same number of cols
 
1452
      then process items in Item_row one by one.
 
1453
      We can't ignore NULL values here as this item may be used with <=>, in
 
1454
      which case NULL's are significant.
 
1455
    */
 
1456
    assert(item->result_type() == comp_item->result_type());
 
1457
    assert(item_row->cols() == comp_item_row->cols());
 
1458
    col= item_row->cols();
 
1459
    while (col-- > 0)
 
1460
      resolve_const_item(session, item_row->addr(col),
 
1461
                         comp_item_row->element_index(col));
 
1462
    break;
 
1463
  }
 
1464
  /* Fallthrough */
1483
1465
  case REAL_RESULT:
1484
 
    {                                           // It must REAL_RESULT
1485
 
      double result= item->val_real();
1486
 
      uint32_t length=item->max_length,decimals=item->decimals;
1487
 
      bool null_value=item->null_value;
1488
 
      new_item= (null_value ? (Item*) new Item_null(name) : (Item*)
1489
 
                 new Item_float(name, result, decimals, length));
1490
 
      break;
1491
 
    }
 
1466
  {                                             // It must REAL_RESULT
 
1467
    double result= item->val_real();
 
1468
    uint32_t length=item->max_length,decimals=item->decimals;
 
1469
    bool null_value=item->null_value;
 
1470
    new_item= (null_value ? (Item*) new Item_null(name) : (Item*)
 
1471
               new Item_float(name, result, decimals, length));
 
1472
    break;
 
1473
  }
1492
1474
  case DECIMAL_RESULT:
1493
 
    {
1494
 
      my_decimal decimal_value;
1495
 
      my_decimal *result= item->val_decimal(&decimal_value);
1496
 
      uint32_t length= item->max_length, decimals= item->decimals;
1497
 
      bool null_value= item->null_value;
1498
 
      new_item= (null_value ?
1499
 
                 (Item*) new Item_null(name) :
1500
 
                 (Item*) new Item_decimal(name, result, length, decimals));
1501
 
      break;
1502
 
    }
1503
 
  }
1504
 
 
 
1475
  {
 
1476
    my_decimal decimal_value;
 
1477
    my_decimal *result= item->val_decimal(&decimal_value);
 
1478
    uint32_t length= item->max_length, decimals= item->decimals;
 
1479
    bool null_value= item->null_value;
 
1480
    new_item= (null_value ?
 
1481
               (Item*) new Item_null(name) :
 
1482
               (Item*) new Item_decimal(name, result, length, decimals));
 
1483
    break;
 
1484
  }
 
1485
  default:
 
1486
    assert(0);
 
1487
  }
1505
1488
  if (new_item)
1506
1489
    session->change_item_tree(ref, new_item);
1507
1490
}
1520
1503
    item_result=item->val_str(&item_tmp);
1521
1504
    if (item->null_value)
1522
1505
      return 1;                                 // This must be true
1523
 
    field->val_str_internal(&field_tmp);
1524
 
    return not stringcmp(&field_tmp,item_result);
 
1506
    field->val_str(&field_tmp);
 
1507
    return !stringcmp(&field_tmp,item_result);
1525
1508
  }
1526
 
 
1527
1509
  if (res_type == INT_RESULT)
1528
1510
    return 1;                                   // Both where of type int
1529
 
 
1530
1511
  if (res_type == DECIMAL_RESULT)
1531
1512
  {
1532
1513
    my_decimal item_buf, *item_val,
1537
1518
    field_val= field->val_decimal(&field_buf);
1538
1519
    return !my_decimal_cmp(item_val, field_val);
1539
1520
  }
1540
 
 
1541
1521
  double result= item->val_real();
1542
1522
  if (item->null_value)
1543
1523
    return 1;
1544
 
 
1545
1524
  return result == field->val_real();
1546
1525
}
1547
1526
 
1577
1556
                                         uint32_t convert_blob_length)
1578
1557
{
1579
1558
  bool maybe_null= item->maybe_null;
1580
 
  Field *new_field= NULL;
 
1559
  Field *new_field;
1581
1560
 
1582
1561
  switch (item->result_type()) {
1583
1562
  case REAL_RESULT:
1584
1563
    new_field= new Field_double(item->max_length, maybe_null,
1585
1564
                                item->name, item->decimals, true);
1586
1565
    break;
1587
 
 
1588
1566
  case INT_RESULT:
1589
1567
    /*
1590
1568
      Select an integer type with the minimal fit precision.
1591
1569
      MY_INT32_NUM_DECIMAL_DIGITS is sign inclusive, don't consider the sign.
1592
1570
      Values with MY_INT32_NUM_DECIMAL_DIGITS digits may or may not fit into
1593
 
      Int32 -> make them field::Int64.
 
1571
      Field_long : make them Field_int64_t.
1594
1572
    */
1595
1573
    if (item->max_length >= (MY_INT32_NUM_DECIMAL_DIGITS - 1))
1596
 
      new_field=new field::Int64(item->max_length, maybe_null,
1597
 
                                 item->name, item->unsigned_flag);
 
1574
      new_field=new Field_int64_t(item->max_length, maybe_null,
 
1575
                                   item->name, item->unsigned_flag);
1598
1576
    else
1599
 
      new_field=new field::Int32(item->max_length, maybe_null,
1600
 
                                 item->name, item->unsigned_flag);
 
1577
      new_field=new Field_long(item->max_length, maybe_null,
 
1578
                               item->name, item->unsigned_flag);
1601
1579
    break;
1602
 
 
1603
1580
  case STRING_RESULT:
1604
1581
    assert(item->collation.collation);
1605
1582
 
1611
1588
    if ((type= item->field_type()) == DRIZZLE_TYPE_DATETIME ||
1612
1589
        type == DRIZZLE_TYPE_DATE ||
1613
1590
        type == DRIZZLE_TYPE_TIMESTAMP)
1614
 
    {
1615
1591
      new_field= item->tmp_table_field_from_field_type(table, 1);
1616
 
      /*
1617
 
        Make sure that the blob fits into a Field_varstring which has
1618
 
        2-byte lenght.
1619
 
      */
1620
 
    }
 
1592
    /*
 
1593
      Make sure that the blob fits into a Field_varstring which has
 
1594
      2-byte lenght.
 
1595
    */
1621
1596
    else if (item->max_length/item->collation.collation->mbmaxlen > 255 &&
1622
1597
             convert_blob_length <= Field_varstring::MAX_SIZE &&
1623
1598
             convert_blob_length)
1624
 
    {
1625
 
      table->setVariableWidth();
1626
1599
      new_field= new Field_varstring(convert_blob_length, maybe_null,
1627
 
                                     item->name, item->collation.collation);
1628
 
    }
 
1600
                                     item->name, table->getMutableShare(),
 
1601
                                     item->collation.collation);
1629
1602
    else
1630
 
    {
1631
1603
      new_field= item->make_string_field(table);
1632
 
    }
1633
1604
    new_field->set_derivation(item->collation.derivation);
1634
1605
    break;
1635
 
 
1636
1606
  case DECIMAL_RESULT:
 
1607
  {
 
1608
    uint8_t dec= item->decimals;
 
1609
    uint8_t intg= ((Item_decimal *) item)->decimal_precision() - dec;
 
1610
    uint32_t len= item->max_length;
 
1611
 
 
1612
    /*
 
1613
      Trying to put too many digits overall in a DECIMAL(prec,dec)
 
1614
      will always throw a warning. We must limit dec to
 
1615
      DECIMAL_MAX_SCALE however to prevent an assert() later.
 
1616
    */
 
1617
 
 
1618
    if (dec > 0)
1637
1619
    {
1638
 
      uint8_t dec= item->decimals;
1639
 
      uint8_t intg= ((Item_decimal *) item)->decimal_precision() - dec;
1640
 
      uint32_t len= item->max_length;
 
1620
      signed int overflow;
 
1621
 
 
1622
      dec= min(dec, (uint8_t)DECIMAL_MAX_SCALE);
1641
1623
 
1642
1624
      /*
1643
 
        Trying to put too many digits overall in a DECIMAL(prec,dec)
1644
 
        will always throw a warning. We must limit dec to
1645
 
        DECIMAL_MAX_SCALE however to prevent an assert() later.
 
1625
        If the value still overflows the field with the corrected dec,
 
1626
        we'll throw out decimals rather than integers. This is still
 
1627
        bad and of course throws a truncation warning.
 
1628
        +1: for decimal point
1646
1629
      */
1647
1630
 
1648
 
      if (dec > 0)
1649
 
      {
1650
 
        signed int overflow;
1651
 
 
1652
 
        dec= min(dec, (uint8_t)DECIMAL_MAX_SCALE);
1653
 
 
1654
 
        /*
1655
 
          If the value still overflows the field with the corrected dec,
1656
 
          we'll throw out decimals rather than integers. This is still
1657
 
          bad and of course throws a truncation warning.
1658
 
          +1: for decimal point
1659
 
        */
1660
 
 
1661
 
        overflow= my_decimal_precision_to_length(intg + dec, dec,
1662
 
                                                 item->unsigned_flag) - len;
1663
 
 
1664
 
        if (overflow > 0)
1665
 
          dec= max(0, dec - overflow);            // too long, discard fract
1666
 
        else
1667
 
          len-= item->decimals - dec;             // corrected value fits
1668
 
      }
1669
 
 
1670
 
      new_field= new Field_decimal(len,
1671
 
                                   maybe_null,
1672
 
                                   item->name,
1673
 
                                   dec,
1674
 
                                   item->unsigned_flag);
1675
 
      break;
 
1631
      overflow= my_decimal_precision_to_length(intg + dec, dec,
 
1632
                                               item->unsigned_flag) - len;
 
1633
 
 
1634
      if (overflow > 0)
 
1635
        dec= max(0, dec - overflow);            // too long, discard fract
 
1636
      else
 
1637
        len-= item->decimals - dec;             // corrected value fits
1676
1638
    }
1677
1639
 
 
1640
    new_field= new Field_decimal(len,
 
1641
                                 maybe_null,
 
1642
                                 item->name,
 
1643
                                 dec,
 
1644
                                 item->unsigned_flag);
 
1645
    break;
 
1646
  }
1678
1647
  case ROW_RESULT:
 
1648
  default:
1679
1649
    // This case should never be choosen
1680
1650
    assert(0);
1681
 
    abort();
 
1651
    new_field= 0;
 
1652
    break;
1682
1653
  }
1683
 
 
1684
1654
  if (new_field)
1685
1655
    new_field->init(table);
1686
1656
 
1687
1657
  if (copy_func && item->is_result_field())
1688
1658
    *((*copy_func)++) = item;                   // Save for copy_funcs
1689
 
 
1690
1659
  if (modify_item)
1691
1660
    item->set_result_field(new_field);
1692
 
 
1693
1661
  if (item->type() == Item::NULL_ITEM)
1694
1662
    new_field->is_created_from_null_item= true;
1695
 
 
1696
1663
  return new_field;
1697
1664
}
1698
1665
 
1749
1716
        field->result_field= result;
1750
1717
    }
1751
1718
    else
1752
 
    {
1753
1719
      result= create_tmp_field_from_field(session, (*from_field= field->field),
1754
1720
                                          orig_item ? orig_item->name :
1755
1721
                                          item->name,
1757
1723
                                          modify_item ? field :
1758
1724
                                          NULL,
1759
1725
                                          convert_blob_length);
1760
 
    }
1761
1726
    if (orig_type == Item::REF_ITEM && orig_modify)
1762
1727
      ((Item_ref*)orig_item)->set_result_field(result);
1763
1728
    if (field->field->eq_def(result))
1797
1762
  }
1798
1763
}
1799
1764
 
1800
 
std::ostream& operator<<(std::ostream& output, const Item &item)
1801
 
{
1802
 
  output << "Item:(";
1803
 
  output <<  item.name;
1804
 
  output << ", ";
1805
 
  output << drizzled::display::type(item.type());
1806
 
  output << ")";
1807
 
 
1808
 
  return output;  // for multiple << operators.
1809
 
}
1810
 
 
1811
1765
} /* namespace drizzled */