← 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-16 04:01:22 UTC
  • mfrom: (1996.2.1 compare)
  • Revision ID: brian@tangent.org-20101216040122-eodh5shwsij35ybe
Merge in uuid tree.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item.cc
106
106
    case ROW_RESULT:
107
107
    default:
108
108
      assert(0);
109
 
      return false;
 
109
      abort();
110
110
  }
111
111
}
112
112
 
1046
1046
  case ROW_RESULT:
1047
1047
  default:
1048
1048
    assert(0);
1049
 
    return DRIZZLE_TYPE_VARCHAR;
 
1049
    abort();
1050
1050
  }
1051
1051
}
1052
1052
 
1058
1058
    case DRIZZLE_TYPE_DATETIME:
1059
1059
    case DRIZZLE_TYPE_TIMESTAMP:
1060
1060
      return true;
1061
 
    default:
1062
 
      break;
 
1061
    case DRIZZLE_TYPE_BLOB:
 
1062
    case DRIZZLE_TYPE_VARCHAR:
 
1063
    case DRIZZLE_TYPE_DOUBLE:
 
1064
    case DRIZZLE_TYPE_DECIMAL:
 
1065
    case DRIZZLE_TYPE_ENUM:
 
1066
    case DRIZZLE_TYPE_LONG:
 
1067
    case DRIZZLE_TYPE_LONGLONG:
 
1068
    case DRIZZLE_TYPE_NULL:
 
1069
    case DRIZZLE_TYPE_UUID:
 
1070
      return false;
1063
1071
  }
1064
 
  return false;
 
1072
 
 
1073
  assert(0);
 
1074
  abort();
1065
1075
}
1066
1076
 
1067
1077
String *Item::check_well_formed_result(String *str, bool send_error)
1146
1156
    The field functions defines a field to be not null if null_ptr is not 0
1147
1157
  */
1148
1158
  unsigned char *null_ptr= maybe_null ? (unsigned char*) "" : 0;
1149
 
  Field *field;
 
1159
  Field *field= NULL;
1150
1160
 
1151
1161
  switch (field_type()) {
1152
1162
  case DRIZZLE_TYPE_DECIMAL:
1184
1194
  case DRIZZLE_TYPE_DATETIME:
1185
1195
    field= new Field_datetime(maybe_null, name, &my_charset_bin);
1186
1196
    break;
1187
 
  default:
1188
 
    /* This case should never be chosen */
1189
 
    assert(0);
1190
 
    /* Fall through to make_string_field() */
 
1197
  case DRIZZLE_TYPE_UUID:
1191
1198
  case DRIZZLE_TYPE_ENUM:
1192
1199
  case DRIZZLE_TYPE_VARCHAR:
1193
1200
    return make_string_field(table);
1195
1202
      field= new Field_blob(max_length, maybe_null, name, collation.collation);
1196
1203
    break;                                      // Blob handled outside of case
1197
1204
  }
 
1205
  assert(field);
 
1206
 
1198
1207
  if (field)
1199
1208
    field->init(table);
1200
1209
  return field;
1329
1338
  enum_field_types f_type;
1330
1339
 
1331
1340
  switch ((f_type=field_type())) {
1332
 
  default:
 
1341
  case DRIZZLE_TYPE_DATE:
1333
1342
  case DRIZZLE_TYPE_NULL:
1334
1343
  case DRIZZLE_TYPE_ENUM:
1335
1344
  case DRIZZLE_TYPE_BLOB:
1336
1345
  case DRIZZLE_TYPE_VARCHAR:
 
1346
  case DRIZZLE_TYPE_UUID:
1337
1347
  case DRIZZLE_TYPE_DECIMAL:
1338
 
  {
1339
 
    String *res;
1340
 
    if ((res=val_str(buffer)))
1341
 
      result= client->store(res->ptr(),res->length());
1342
 
    break;
1343
 
  }
 
1348
    {
 
1349
      String *res;
 
1350
      if ((res=val_str(buffer)))
 
1351
        result= client->store(res->ptr(),res->length());
 
1352
      break;
 
1353
    }
1344
1354
  case DRIZZLE_TYPE_LONG:
1345
 
  {
1346
 
    int64_t nr;
1347
 
    nr= val_int();
1348
 
    if (!null_value)
1349
 
      result= client->store((int32_t)nr);
1350
 
    break;
1351
 
  }
 
1355
    {
 
1356
      int64_t nr;
 
1357
      nr= val_int();
 
1358
      if (!null_value)
 
1359
        result= client->store((int32_t)nr);
 
1360
      break;
 
1361
    }
1352
1362
  case DRIZZLE_TYPE_LONGLONG:
1353
 
  {
1354
 
    int64_t nr;
1355
 
    nr= val_int();
1356
 
    if (!null_value)
1357
1363
    {
1358
 
      if (unsigned_flag)
1359
 
        result= client->store((uint64_t)nr);
1360
 
      else
1361
 
        result= client->store((int64_t)nr);
 
1364
      int64_t nr;
 
1365
      nr= val_int();
 
1366
      if (!null_value)
 
1367
      {
 
1368
        if (unsigned_flag)
 
1369
          result= client->store((uint64_t)nr);
 
1370
        else
 
1371
          result= client->store((int64_t)nr);
 
1372
      }
 
1373
      break;
1362
1374
    }
1363
 
    break;
1364
 
  }
1365
1375
  case DRIZZLE_TYPE_DOUBLE:
1366
 
  {
1367
 
    double nr= val_real();
1368
 
    if (!null_value)
1369
 
      result= client->store(nr, decimals, buffer);
1370
 
    break;
1371
 
  }
 
1376
    {
 
1377
      double nr= val_real();
 
1378
      if (!null_value)
 
1379
        result= client->store(nr, decimals, buffer);
 
1380
      break;
 
1381
    }
1372
1382
  case DRIZZLE_TYPE_DATETIME:
1373
1383
  case DRIZZLE_TYPE_TIMESTAMP:
1374
 
  {
1375
 
    DRIZZLE_TIME tm;
1376
 
    get_date(&tm, TIME_FUZZY_DATE);
1377
 
    if (!null_value)
1378
 
      result= client->store(&tm);
1379
 
    break;
1380
 
  }
 
1384
    {
 
1385
      DRIZZLE_TIME tm;
 
1386
      get_date(&tm, TIME_FUZZY_DATE);
 
1387
      if (!null_value)
 
1388
        result= client->store(&tm);
 
1389
      break;
 
1390
    }
1381
1391
  }
1382
1392
  if (null_value)
1383
1393
    result= client->store();
 
1394
 
1384
1395
  return result;
1385
1396
}
1386
1397
 
1504
1515
    item_result=item->val_str(&item_tmp);
1505
1516
    if (item->null_value)
1506
1517
      return 1;                                 // This must be true
1507
 
    field->val_str(&field_tmp);
1508
 
    return !stringcmp(&field_tmp,item_result);
 
1518
    field->val_str_internal(&field_tmp);
 
1519
    return not stringcmp(&field_tmp,item_result);
1509
1520
  }
1510
1521
  if (res_type == INT_RESULT)
1511
1522
    return 1;                                   // Both where of type int
1655
1666
  default:
1656
1667
    // This case should never be choosen
1657
1668
    assert(0);
1658
 
    new_field= 0;
1659
 
    break;
 
1669
    abort();
1660
1670
  }
1661
1671
  if (new_field)
1662
1672
    new_field->init(table);
1723
1733
        field->result_field= result;
1724
1734
    }
1725
1735
    else
 
1736
    {
1726
1737
      result= create_tmp_field_from_field(session, (*from_field= field->field),
1727
1738
                                          orig_item ? orig_item->name :
1728
1739
                                          item->name,
1730
1741
                                          modify_item ? field :
1731
1742
                                          NULL,
1732
1743
                                          convert_blob_length);
 
1744
    }
1733
1745
    if (orig_type == Item::REF_ITEM && orig_modify)
1734
1746
      ((Item_ref*)orig_item)->set_result_field(result);
1735
1747
    if (field->field->eq_def(result))
1769
1781
  }
1770
1782
}
1771
1783
 
 
1784
std::ostream& operator<<(std::ostream& output, const Item &item)
 
1785
{
 
1786
  output << "Item:(";
 
1787
  output <<  item.name;
 
1788
  output << ", ";
 
1789
  output << drizzled::display::type(item.type());
 
1790
  output << ")";
 
1791
 
 
1792
  return output;  // for multiple << operators.
 
1793
}
 
1794
 
1772
1795
} /* namespace drizzled */