← 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-12-07 21:33:25 UTC
  • mto: This revision was merged to the branch mainline in revision 1987.
  • Revision ID: brian@tangent.org-20101207213325-u6vbc107dpe0c7ld
Added compatible REGEX for Drizzle to MySQL's syntax.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item.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) 2008-2009 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008-2009 Sun Microsystems
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
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)
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)
1161
1146
    The field functions defines a field to be not null if null_ptr is not 0
1162
1147
  */
1163
1148
  unsigned char *null_ptr= maybe_null ? (unsigned char*) "" : 0;
1164
 
  Field *field= NULL;
 
1149
  Field *field;
1165
1150
 
1166
1151
  switch (field_type()) {
1167
1152
  case DRIZZLE_TYPE_DECIMAL:
1176
1161
                                 unsigned_flag);
1177
1162
    break;
1178
1163
  case DRIZZLE_TYPE_LONG:
1179
 
    field= new field::Int32((unsigned char*) 0, max_length, null_ptr, 0, Field::NONE, name);
 
1164
    field= new Field_long((unsigned char*) 0, max_length, null_ptr, 0, Field::NONE,
 
1165
                          name, 0, unsigned_flag);
1180
1166
    break;
1181
1167
  case DRIZZLE_TYPE_LONGLONG:
1182
 
    field= new field::Int64((unsigned char*) 0, max_length, null_ptr, 0, Field::NONE, name);
 
1168
    field= new Field_int64_t((unsigned char*) 0, max_length, null_ptr, 0, Field::NONE,
 
1169
                              name, 0, unsigned_flag);
1183
1170
    break;
1184
1171
  case DRIZZLE_TYPE_DOUBLE:
1185
1172
    field= new Field_double((unsigned char*) 0, max_length, null_ptr, 0, Field::NONE,
1186
 
                            name, decimals, 0, unsigned_flag);
 
1173
                            name, decimals, 0, unsigned_flag);
1187
1174
    break;
1188
1175
  case DRIZZLE_TYPE_NULL:
1189
1176
    field= new Field_null((unsigned char*) 0, max_length, name, &my_charset_bin);
1197
1184
  case DRIZZLE_TYPE_DATETIME:
1198
1185
    field= new Field_datetime(maybe_null, name, &my_charset_bin);
1199
1186
    break;
1200
 
  case DRIZZLE_TYPE_UUID:
 
1187
  default:
 
1188
    /* This case should never be chosen */
 
1189
    assert(0);
 
1190
    /* Fall through to make_string_field() */
1201
1191
  case DRIZZLE_TYPE_ENUM:
1202
1192
  case DRIZZLE_TYPE_VARCHAR:
1203
1193
    return make_string_field(table);
1205
1195
      field= new Field_blob(max_length, maybe_null, name, collation.collation);
1206
1196
    break;                                      // Blob handled outside of case
1207
1197
  }
1208
 
  assert(field);
1209
 
 
1210
1198
  if (field)
1211
1199
    field->init(table);
1212
1200
  return field;
1341
1329
  enum_field_types f_type;
1342
1330
 
1343
1331
  switch ((f_type=field_type())) {
1344
 
  case DRIZZLE_TYPE_DATE:
 
1332
  default:
1345
1333
  case DRIZZLE_TYPE_NULL:
1346
1334
  case DRIZZLE_TYPE_ENUM:
1347
1335
  case DRIZZLE_TYPE_BLOB:
1348
1336
  case DRIZZLE_TYPE_VARCHAR:
1349
 
  case DRIZZLE_TYPE_UUID:
1350
1337
  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
 
    }
 
1338
  {
 
1339
    String *res;
 
1340
    if ((res=val_str(buffer)))
 
1341
      result= client->store(res->ptr(),res->length());
 
1342
    break;
 
1343
  }
1357
1344
  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
 
    }
 
1345
  {
 
1346
    int64_t nr;
 
1347
    nr= val_int();
 
1348
    if (!null_value)
 
1349
      result= client->store((int32_t)nr);
 
1350
    break;
 
1351
  }
1365
1352
  case DRIZZLE_TYPE_LONGLONG:
 
1353
  {
 
1354
    int64_t nr;
 
1355
    nr= val_int();
 
1356
    if (!null_value)
1366
1357
    {
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;
 
1358
      if (unsigned_flag)
 
1359
        result= client->store((uint64_t)nr);
 
1360
      else
 
1361
        result= client->store((int64_t)nr);
1377
1362
    }
 
1363
    break;
 
1364
  }
1378
1365
  case DRIZZLE_TYPE_DOUBLE:
1379
 
    {
1380
 
      double nr= val_real();
1381
 
      if (!null_value)
1382
 
        result= client->store(nr, decimals, buffer);
1383
 
      break;
1384
 
    }
 
1366
  {
 
1367
    double nr= val_real();
 
1368
    if (!null_value)
 
1369
      result= client->store(nr, decimals, buffer);
 
1370
    break;
 
1371
  }
1385
1372
  case DRIZZLE_TYPE_DATETIME:
1386
1373
  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
 
    }
 
1374
  {
 
1375
    DRIZZLE_TIME tm;
 
1376
    get_date(&tm, TIME_FUZZY_DATE);
 
1377
    if (!null_value)
 
1378
      result= client->store(&tm);
 
1379
    break;
 
1380
  }
1394
1381
  }
1395
1382
  if (null_value)
1396
1383
    result= client->store();
1397
 
 
1398
1384
  return result;
1399
1385
}
1400
1386
 
1402
1388
{
1403
1389
  if (a == STRING_RESULT && b == STRING_RESULT)
1404
1390
    return STRING_RESULT;
1405
 
 
1406
1391
  if (a == INT_RESULT && b == INT_RESULT)
1407
1392
    return INT_RESULT;
1408
1393
  else if (a == ROW_RESULT || b == ROW_RESULT)
1409
1394
    return ROW_RESULT;
1410
 
 
1411
1395
  if ((a == INT_RESULT || a == DECIMAL_RESULT) &&
1412
1396
      (b == INT_RESULT || b == DECIMAL_RESULT))
1413
1397
    return DECIMAL_RESULT;
1414
 
 
1415
1398
  return REAL_RESULT;
1416
1399
}
1417
1400
 
1427
1410
 
1428
1411
  switch (res_type) {
1429
1412
  case STRING_RESULT:
 
1413
  {
 
1414
    char buff[MAX_FIELD_WIDTH];
 
1415
    String tmp(buff,sizeof(buff),&my_charset_bin),*result;
 
1416
    result=item->val_str(&tmp);
 
1417
    if (item->null_value)
 
1418
      new_item= new Item_null(name);
 
1419
    else
1430
1420
    {
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;
 
1421
      uint32_t length= result->length();
 
1422
      char *tmp_str= memory::sql_strmake(result->ptr(), length);
 
1423
      new_item= new Item_string(name, tmp_str, length, result->charset());
1443
1424
    }
 
1425
    break;
 
1426
  }
1444
1427
  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
 
    }
 
1428
  {
 
1429
    int64_t result=item->val_int();
 
1430
    uint32_t length=item->max_length;
 
1431
    bool null_value=item->null_value;
 
1432
    new_item= (null_value ? (Item*) new Item_null(name) :
 
1433
               (Item*) new Item_int(name, result, length));
 
1434
    break;
 
1435
  }
1453
1436
  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).
 
1437
  if (item->type() == Item::ROW_ITEM && comp_item->type() == Item::ROW_ITEM)
 
1438
  {
 
1439
    /*
 
1440
      Substitute constants only in Item_rows. Don't affect other Items
 
1441
      with ROW_RESULT (eg Item_singlerow_subselect).
1459
1442
 
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 */
 
1443
      For such Items more optimal is to detect if it is constant and replace
 
1444
      it with Item_row. This would optimize queries like this:
 
1445
      SELECT * FROM t1 WHERE (a,b) = (SELECT a,b FROM t2 LIMIT 1);
 
1446
    */
 
1447
    Item_row *item_row= (Item_row*) item;
 
1448
    Item_row *comp_item_row= (Item_row*) comp_item;
 
1449
    uint32_t col;
 
1450
    new_item= 0;
 
1451
    /*
 
1452
      If item and comp_item are both Item_rows and have same number of cols
 
1453
      then process items in Item_row one by one.
 
1454
      We can't ignore NULL values here as this item may be used with <=>, in
 
1455
      which case NULL's are significant.
 
1456
    */
 
1457
    assert(item->result_type() == comp_item->result_type());
 
1458
    assert(item_row->cols() == comp_item_row->cols());
 
1459
    col= item_row->cols();
 
1460
    while (col-- > 0)
 
1461
      resolve_const_item(session, item_row->addr(col),
 
1462
                         comp_item_row->element_index(col));
 
1463
    break;
 
1464
  }
 
1465
  /* Fallthrough */
1483
1466
  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
 
    }
 
1467
  {                                             // It must REAL_RESULT
 
1468
    double result= item->val_real();
 
1469
    uint32_t length=item->max_length,decimals=item->decimals;
 
1470
    bool null_value=item->null_value;
 
1471
    new_item= (null_value ? (Item*) new Item_null(name) : (Item*)
 
1472
               new Item_float(name, result, decimals, length));
 
1473
    break;
 
1474
  }
1492
1475
  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
 
 
 
1476
  {
 
1477
    my_decimal decimal_value;
 
1478
    my_decimal *result= item->val_decimal(&decimal_value);
 
1479
    uint32_t length= item->max_length, decimals= item->decimals;
 
1480
    bool null_value= item->null_value;
 
1481
    new_item= (null_value ?
 
1482
               (Item*) new Item_null(name) :
 
1483
               (Item*) new Item_decimal(name, result, length, decimals));
 
1484
    break;
 
1485
  }
 
1486
  default:
 
1487
    assert(0);
 
1488
  }
1505
1489
  if (new_item)
1506
1490
    session->change_item_tree(ref, new_item);
1507
1491
}
1520
1504
    item_result=item->val_str(&item_tmp);
1521
1505
    if (item->null_value)
1522
1506
      return 1;                                 // This must be true
1523
 
    field->val_str_internal(&field_tmp);
1524
 
    return not stringcmp(&field_tmp,item_result);
 
1507
    field->val_str(&field_tmp);
 
1508
    return !stringcmp(&field_tmp,item_result);
1525
1509
  }
1526
 
 
1527
1510
  if (res_type == INT_RESULT)
1528
1511
    return 1;                                   // Both where of type int
1529
 
 
1530
1512
  if (res_type == DECIMAL_RESULT)
1531
1513
  {
1532
1514
    my_decimal item_buf, *item_val,
1537
1519
    field_val= field->val_decimal(&field_buf);
1538
1520
    return !my_decimal_cmp(item_val, field_val);
1539
1521
  }
1540
 
 
1541
1522
  double result= item->val_real();
1542
1523
  if (item->null_value)
1543
1524
    return 1;
1544
 
 
1545
1525
  return result == field->val_real();
1546
1526
}
1547
1527
 
1577
1557
                                         uint32_t convert_blob_length)
1578
1558
{
1579
1559
  bool maybe_null= item->maybe_null;
1580
 
  Field *new_field= NULL;
 
1560
  Field *new_field;
1581
1561
 
1582
1562
  switch (item->result_type()) {
1583
1563
  case REAL_RESULT:
1584
1564
    new_field= new Field_double(item->max_length, maybe_null,
1585
1565
                                item->name, item->decimals, true);
1586
1566
    break;
1587
 
 
1588
1567
  case INT_RESULT:
1589
1568
    /*
1590
1569
      Select an integer type with the minimal fit precision.
1591
1570
      MY_INT32_NUM_DECIMAL_DIGITS is sign inclusive, don't consider the sign.
1592
1571
      Values with MY_INT32_NUM_DECIMAL_DIGITS digits may or may not fit into
1593
 
      Int32 -> make them field::Int64.
 
1572
      Field_long : make them Field_int64_t.
1594
1573
    */
1595
1574
    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);
 
1575
      new_field=new Field_int64_t(item->max_length, maybe_null,
 
1576
                                   item->name, item->unsigned_flag);
1598
1577
    else
1599
 
      new_field=new field::Int32(item->max_length, maybe_null,
1600
 
                                 item->name, item->unsigned_flag);
 
1578
      new_field=new Field_long(item->max_length, maybe_null,
 
1579
                               item->name, item->unsigned_flag);
1601
1580
    break;
1602
 
 
1603
1581
  case STRING_RESULT:
1604
1582
    assert(item->collation.collation);
1605
1583
 
1632
1610
    }
1633
1611
    new_field->set_derivation(item->collation.derivation);
1634
1612
    break;
1635
 
 
1636
1613
  case DECIMAL_RESULT:
 
1614
  {
 
1615
    uint8_t dec= item->decimals;
 
1616
    uint8_t intg= ((Item_decimal *) item)->decimal_precision() - dec;
 
1617
    uint32_t len= item->max_length;
 
1618
 
 
1619
    /*
 
1620
      Trying to put too many digits overall in a DECIMAL(prec,dec)
 
1621
      will always throw a warning. We must limit dec to
 
1622
      DECIMAL_MAX_SCALE however to prevent an assert() later.
 
1623
    */
 
1624
 
 
1625
    if (dec > 0)
1637
1626
    {
1638
 
      uint8_t dec= item->decimals;
1639
 
      uint8_t intg= ((Item_decimal *) item)->decimal_precision() - dec;
1640
 
      uint32_t len= item->max_length;
 
1627
      signed int overflow;
 
1628
 
 
1629
      dec= min(dec, (uint8_t)DECIMAL_MAX_SCALE);
1641
1630
 
1642
1631
      /*
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.
 
1632
        If the value still overflows the field with the corrected dec,
 
1633
        we'll throw out decimals rather than integers. This is still
 
1634
        bad and of course throws a truncation warning.
 
1635
        +1: for decimal point
1646
1636
      */
1647
1637
 
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;
 
1638
      overflow= my_decimal_precision_to_length(intg + dec, dec,
 
1639
                                               item->unsigned_flag) - len;
 
1640
 
 
1641
      if (overflow > 0)
 
1642
        dec= max(0, dec - overflow);            // too long, discard fract
 
1643
      else
 
1644
        len-= item->decimals - dec;             // corrected value fits
1676
1645
    }
1677
1646
 
 
1647
    new_field= new Field_decimal(len,
 
1648
                                 maybe_null,
 
1649
                                 item->name,
 
1650
                                 dec,
 
1651
                                 item->unsigned_flag);
 
1652
    break;
 
1653
  }
1678
1654
  case ROW_RESULT:
 
1655
  default:
1679
1656
    // This case should never be choosen
1680
1657
    assert(0);
1681
 
    abort();
 
1658
    new_field= 0;
 
1659
    break;
1682
1660
  }
1683
 
 
1684
1661
  if (new_field)
1685
1662
    new_field->init(table);
1686
1663
 
1687
1664
  if (copy_func && item->is_result_field())
1688
1665
    *((*copy_func)++) = item;                   // Save for copy_funcs
1689
 
 
1690
1666
  if (modify_item)
1691
1667
    item->set_result_field(new_field);
1692
 
 
1693
1668
  if (item->type() == Item::NULL_ITEM)
1694
1669
    new_field->is_created_from_null_item= true;
1695
 
 
1696
1670
  return new_field;
1697
1671
}
1698
1672
 
1749
1723
        field->result_field= result;
1750
1724
    }
1751
1725
    else
1752
 
    {
1753
1726
      result= create_tmp_field_from_field(session, (*from_field= field->field),
1754
1727
                                          orig_item ? orig_item->name :
1755
1728
                                          item->name,
1757
1730
                                          modify_item ? field :
1758
1731
                                          NULL,
1759
1732
                                          convert_blob_length);
1760
 
    }
1761
1733
    if (orig_type == Item::REF_ITEM && orig_modify)
1762
1734
      ((Item_ref*)orig_item)->set_result_field(result);
1763
1735
    if (field->field->eq_def(result))
1797
1769
  }
1798
1770
}
1799
1771
 
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
1772
} /* namespace drizzled */