← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item.cc

Merged from PatG.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item.cc
2141
2141
  item_result_type(STRING_RESULT),
2142
2142
  /* Don't pretend to be a literal unless value for this item is set. */
2143
2143
  item_type(PARAM_ITEM),
2144
 
  param_type(FIELD_TYPE_VARCHAR),
 
2144
  param_type(DRIZZLE_TYPE_VARCHAR),
2145
2145
  pos_in_query(pos_in_query_arg),
2146
2146
  set_param_func(default_set_param_func),
2147
2147
  limit_clause_param(false)
3953
3953
 
3954
3954
enum_field_types Item::string_field_type() const
3955
3955
{
3956
 
  enum_field_types f_type= FIELD_TYPE_VAR_STRING;
 
3956
  enum_field_types f_type= DRIZZLE_TYPE_VAR_STRING;
3957
3957
  if (max_length >= 65536)
3958
 
    f_type= FIELD_TYPE_BLOB;
 
3958
    f_type= DRIZZLE_TYPE_BLOB;
3959
3959
  return f_type;
3960
3960
}
3961
3961
 
3970
3970
{
3971
3971
  switch (result_type()) {
3972
3972
  case STRING_RESULT:  return string_field_type();
3973
 
  case INT_RESULT:     return FIELD_TYPE_LONGLONG;
3974
 
  case DECIMAL_RESULT: return FIELD_TYPE_NEWDECIMAL;
3975
 
  case REAL_RESULT:    return FIELD_TYPE_DOUBLE;
 
3973
  case INT_RESULT:     return DRIZZLE_TYPE_LONGLONG;
 
3974
  case DECIMAL_RESULT: return DRIZZLE_TYPE_NEWDECIMAL;
 
3975
  case REAL_RESULT:    return DRIZZLE_TYPE_DOUBLE;
3976
3976
  case ROW_RESULT:
3977
3977
  default:
3978
3978
    assert(0);
3979
 
    return FIELD_TYPE_VARCHAR;
 
3979
    return DRIZZLE_TYPE_VARCHAR;
3980
3980
  }
3981
3981
}
3982
3982
 
3985
3985
{
3986
3986
  switch (field_type())
3987
3987
  {
3988
 
    case FIELD_TYPE_NEWDATE:
3989
 
    case FIELD_TYPE_DATETIME:
3990
 
    case FIELD_TYPE_TIMESTAMP:
 
3988
    case DRIZZLE_TYPE_NEWDATE:
 
3989
    case DRIZZLE_TYPE_DATETIME:
 
3990
    case DRIZZLE_TYPE_TIMESTAMP:
3991
3991
      return true;
3992
3992
    default:
3993
3993
      break;
4092
4092
                          collation.collation);
4093
4093
  /* Item_type_holder holds the exact type, do not change it */
4094
4094
  else if (max_length > 0 &&
4095
 
      (type() != Item::TYPE_HOLDER || field_type() != FIELD_TYPE_STRING))
 
4095
      (type() != Item::TYPE_HOLDER || field_type() != DRIZZLE_TYPE_STRING))
4096
4096
    field= new Field_varstring(max_length, maybe_null, name, table->s,
4097
4097
                               collation.collation);
4098
4098
  else
4125
4125
  Field *field;
4126
4126
 
4127
4127
  switch (field_type()) {
4128
 
  case FIELD_TYPE_NEWDECIMAL:
 
4128
  case DRIZZLE_TYPE_NEWDECIMAL:
4129
4129
    field= new Field_new_decimal((uchar*) 0, max_length, null_ptr, 0,
4130
4130
                                 Field::NONE, name, decimals, 0,
4131
4131
                                 unsigned_flag);
4132
4132
    break;
4133
 
  case FIELD_TYPE_TINY:
 
4133
  case DRIZZLE_TYPE_TINY:
4134
4134
    field= new Field_tiny((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4135
4135
                          name, 0, unsigned_flag);
4136
4136
    break;
4137
 
  case FIELD_TYPE_SHORT:
 
4137
  case DRIZZLE_TYPE_SHORT:
4138
4138
    field= new Field_short((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4139
4139
                           name, 0, unsigned_flag);
4140
4140
    break;
4141
 
  case FIELD_TYPE_LONG:
 
4141
  case DRIZZLE_TYPE_LONG:
4142
4142
    field= new Field_long((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4143
4143
                          name, 0, unsigned_flag);
4144
4144
    break;
4145
 
  case FIELD_TYPE_LONGLONG:
 
4145
  case DRIZZLE_TYPE_LONGLONG:
4146
4146
    field= new Field_int64_t((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4147
4147
                              name, 0, unsigned_flag);
4148
4148
    break;
4149
 
  case FIELD_TYPE_DOUBLE:
 
4149
  case DRIZZLE_TYPE_DOUBLE:
4150
4150
    field= new Field_double((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4151
4151
                            name, decimals, 0, unsigned_flag);
4152
4152
    break;
4153
 
  case FIELD_TYPE_NULL:
 
4153
  case DRIZZLE_TYPE_NULL:
4154
4154
    field= new Field_null((uchar*) 0, max_length, Field::NONE,
4155
4155
                          name, &my_charset_bin);
4156
4156
    break;
4157
 
  case FIELD_TYPE_NEWDATE:
 
4157
  case DRIZZLE_TYPE_NEWDATE:
4158
4158
    field= new Field_newdate(maybe_null, name, &my_charset_bin);
4159
4159
    break;
4160
 
  case FIELD_TYPE_TIME:
 
4160
  case DRIZZLE_TYPE_TIME:
4161
4161
    field= new Field_time(maybe_null, name, &my_charset_bin);
4162
4162
    break;
4163
 
  case FIELD_TYPE_TIMESTAMP:
 
4163
  case DRIZZLE_TYPE_TIMESTAMP:
4164
4164
    field= new Field_timestamp(maybe_null, name, &my_charset_bin);
4165
4165
    break;
4166
 
  case FIELD_TYPE_DATETIME:
 
4166
  case DRIZZLE_TYPE_DATETIME:
4167
4167
    field= new Field_datetime(maybe_null, name, &my_charset_bin);
4168
4168
    break;
4169
 
  case FIELD_TYPE_YEAR:
 
4169
  case DRIZZLE_TYPE_YEAR:
4170
4170
    field= new Field_year((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4171
4171
                          name);
4172
4172
    break;
4174
4174
    /* This case should never be chosen */
4175
4175
    assert(0);
4176
4176
    /* If something goes awfully wrong, it's better to get a string than die */
4177
 
  case FIELD_TYPE_STRING:
 
4177
  case DRIZZLE_TYPE_STRING:
4178
4178
    if (fixed_length && max_length < CONVERT_IF_BIGGER_TO_BLOB)
4179
4179
    {
4180
4180
      field= new Field_string(max_length, maybe_null, name,
4182
4182
      break;
4183
4183
    }
4184
4184
    /* Fall through to make_string_field() */
4185
 
  case FIELD_TYPE_ENUM:
4186
 
  case FIELD_TYPE_SET:
4187
 
  case FIELD_TYPE_VAR_STRING:
4188
 
  case FIELD_TYPE_VARCHAR:
 
4185
  case DRIZZLE_TYPE_ENUM:
 
4186
  case DRIZZLE_TYPE_SET:
 
4187
  case DRIZZLE_TYPE_VAR_STRING:
 
4188
  case DRIZZLE_TYPE_VARCHAR:
4189
4189
    return make_string_field(table);
4190
 
  case FIELD_TYPE_BLOB:
 
4190
  case DRIZZLE_TYPE_BLOB:
4191
4191
    if (this->type() == Item::TYPE_HOLDER)
4192
4192
      field= new Field_blob(max_length, maybe_null, name, collation.collation,
4193
4193
                            1);
4706
4706
 
4707
4707
  switch ((f_type=field_type())) {
4708
4708
  default:
4709
 
  case FIELD_TYPE_NULL:
4710
 
  case FIELD_TYPE_ENUM:
4711
 
  case FIELD_TYPE_SET:
4712
 
  case FIELD_TYPE_BLOB:
4713
 
  case FIELD_TYPE_STRING:
4714
 
  case FIELD_TYPE_VAR_STRING:
4715
 
  case FIELD_TYPE_VARCHAR:
4716
 
  case FIELD_TYPE_NEWDECIMAL:
 
4709
  case DRIZZLE_TYPE_NULL:
 
4710
  case DRIZZLE_TYPE_ENUM:
 
4711
  case DRIZZLE_TYPE_SET:
 
4712
  case DRIZZLE_TYPE_BLOB:
 
4713
  case DRIZZLE_TYPE_STRING:
 
4714
  case DRIZZLE_TYPE_VAR_STRING:
 
4715
  case DRIZZLE_TYPE_VARCHAR:
 
4716
  case DRIZZLE_TYPE_NEWDECIMAL:
4717
4717
  {
4718
4718
    String *res;
4719
4719
    if ((res=val_str(buffer)))
4720
4720
      result= protocol->store(res->ptr(),res->length(),res->charset());
4721
4721
    break;
4722
4722
  }
4723
 
  case FIELD_TYPE_TINY:
 
4723
  case DRIZZLE_TYPE_TINY:
4724
4724
  {
4725
4725
    int64_t nr;
4726
4726
    nr= val_int();
4728
4728
      result= protocol->store_tiny(nr);
4729
4729
    break;
4730
4730
  }
4731
 
  case FIELD_TYPE_SHORT:
4732
 
  case FIELD_TYPE_YEAR:
 
4731
  case DRIZZLE_TYPE_SHORT:
 
4732
  case DRIZZLE_TYPE_YEAR:
4733
4733
  {
4734
4734
    int64_t nr;
4735
4735
    nr= val_int();
4737
4737
      result= protocol->store_short(nr);
4738
4738
    break;
4739
4739
  }
4740
 
  case FIELD_TYPE_LONG:
 
4740
  case DRIZZLE_TYPE_LONG:
4741
4741
  {
4742
4742
    int64_t nr;
4743
4743
    nr= val_int();
4745
4745
      result= protocol->store_long(nr);
4746
4746
    break;
4747
4747
  }
4748
 
  case FIELD_TYPE_LONGLONG:
 
4748
  case DRIZZLE_TYPE_LONGLONG:
4749
4749
  {
4750
4750
    int64_t nr;
4751
4751
    nr= val_int();
4753
4753
      result= protocol->store_int64_t(nr, unsigned_flag);
4754
4754
    break;
4755
4755
  }
4756
 
  case FIELD_TYPE_DOUBLE:
 
4756
  case DRIZZLE_TYPE_DOUBLE:
4757
4757
  {
4758
4758
    double nr= val_real();
4759
4759
    if (!null_value)
4760
4760
      result= protocol->store(nr, decimals, buffer);
4761
4761
    break;
4762
4762
  }
4763
 
  case FIELD_TYPE_DATETIME:
4764
 
  case FIELD_TYPE_TIMESTAMP:
 
4763
  case DRIZZLE_TYPE_DATETIME:
 
4764
  case DRIZZLE_TYPE_TIMESTAMP:
4765
4765
  {
4766
4766
    MYSQL_TIME tm;
4767
4767
    get_date(&tm, TIME_FUZZY_DATE);
4768
4768
    if (!null_value)
4769
4769
    {
4770
 
      if (f_type == FIELD_TYPE_NEWDATE)
 
4770
      if (f_type == DRIZZLE_TYPE_NEWDATE)
4771
4771
        return protocol->store_date(&tm);
4772
4772
      else
4773
4773
        result= protocol->store(&tm);
4774
4774
    }
4775
4775
    break;
4776
4776
  }
4777
 
  case FIELD_TYPE_TIME:
 
4777
  case DRIZZLE_TYPE_TIME:
4778
4778
  {
4779
4779
    MYSQL_TIME tm;
4780
4780
    get_time(&tm);
6112
6112
int Item_cache_str::save_in_field(Field *field, bool no_conversions)
6113
6113
{
6114
6114
  int res= Item_cache::save_in_field(field, no_conversions);
6115
 
  return (is_varbinary && field->type() == FIELD_TYPE_STRING &&
 
6115
  return (is_varbinary && field->type() == DRIZZLE_TYPE_STRING &&
6116
6116
          value->length() < field->field_length) ? 1 : res;
6117
6117
}
6118
6118
 
6249
6249
    Field *field= ((Item_field *) item)->field;
6250
6250
    enum_field_types type= field->real_type();
6251
6251
    if (field->is_created_from_null_item)
6252
 
      return FIELD_TYPE_NULL;
 
6252
      return DRIZZLE_TYPE_NULL;
6253
6253
    /* work around about varchar type field detection */
6254
 
    if (type == FIELD_TYPE_STRING && field->type() == FIELD_TYPE_VAR_STRING)
6255
 
      return FIELD_TYPE_VAR_STRING;
 
6254
    if (type == DRIZZLE_TYPE_STRING && field->type() == DRIZZLE_TYPE_VAR_STRING)
 
6255
      return DRIZZLE_TYPE_VAR_STRING;
6256
6256
    return type;
6257
6257
  }
6258
6258
  case SUM_FUNC_ITEM:
6277
6277
      */
6278
6278
      switch (item->result_type()) {
6279
6279
      case STRING_RESULT:
6280
 
        return FIELD_TYPE_VAR_STRING;
 
6280
        return DRIZZLE_TYPE_VAR_STRING;
6281
6281
      case INT_RESULT:
6282
 
        return FIELD_TYPE_LONGLONG;
 
6282
        return DRIZZLE_TYPE_LONGLONG;
6283
6283
      case REAL_RESULT:
6284
 
        return FIELD_TYPE_DOUBLE;
 
6284
        return DRIZZLE_TYPE_DOUBLE;
6285
6285
      case DECIMAL_RESULT:
6286
 
        return FIELD_TYPE_NEWDECIMAL;
 
6286
        return DRIZZLE_TYPE_NEWDECIMAL;
6287
6287
      case ROW_RESULT:
6288
6288
      default:
6289
6289
        assert(0);
6290
 
        return FIELD_TYPE_VAR_STRING;
 
6290
        return DRIZZLE_TYPE_VAR_STRING;
6291
6291
      }
6292
6292
    }
6293
6293
    break;
6373
6373
      int delta1= max_length_orig - decimals_orig;
6374
6374
      int delta2= item->max_length - item->decimals;
6375
6375
      max_length= max(delta1, delta2) + decimals;
6376
 
      if (fld_type == FIELD_TYPE_DOUBLE && max_length > DBL_DIG + 2) 
 
6376
      if (fld_type == DRIZZLE_TYPE_DOUBLE && max_length > DBL_DIG + 2) 
6377
6377
      {
6378
6378
        max_length= DBL_DIG + 7;
6379
6379
        decimals= NOT_FIXED_DEC;
6410
6410
 
6411
6411
  switch (item->field_type())
6412
6412
  {
6413
 
  case FIELD_TYPE_TIMESTAMP:
6414
 
  case FIELD_TYPE_TIME:
6415
 
  case FIELD_TYPE_DATETIME:
6416
 
  case FIELD_TYPE_YEAR:
6417
 
  case FIELD_TYPE_NEWDATE:
6418
 
  case FIELD_TYPE_VARCHAR:
6419
 
  case FIELD_TYPE_NEWDECIMAL:
6420
 
  case FIELD_TYPE_ENUM:
6421
 
  case FIELD_TYPE_SET:
6422
 
  case FIELD_TYPE_BLOB:
6423
 
  case FIELD_TYPE_VAR_STRING:
6424
 
  case FIELD_TYPE_STRING:
6425
 
  case FIELD_TYPE_TINY:
 
6413
  case DRIZZLE_TYPE_TIMESTAMP:
 
6414
  case DRIZZLE_TYPE_TIME:
 
6415
  case DRIZZLE_TYPE_DATETIME:
 
6416
  case DRIZZLE_TYPE_YEAR:
 
6417
  case DRIZZLE_TYPE_NEWDATE:
 
6418
  case DRIZZLE_TYPE_VARCHAR:
 
6419
  case DRIZZLE_TYPE_NEWDECIMAL:
 
6420
  case DRIZZLE_TYPE_ENUM:
 
6421
  case DRIZZLE_TYPE_SET:
 
6422
  case DRIZZLE_TYPE_BLOB:
 
6423
  case DRIZZLE_TYPE_VAR_STRING:
 
6424
  case DRIZZLE_TYPE_STRING:
 
6425
  case DRIZZLE_TYPE_TINY:
6426
6426
    return 4;
6427
 
  case FIELD_TYPE_SHORT:
 
6427
  case DRIZZLE_TYPE_SHORT:
6428
6428
    return 6;
6429
 
  case FIELD_TYPE_LONG:
 
6429
  case DRIZZLE_TYPE_LONG:
6430
6430
    return MY_INT32_NUM_DECIMAL_DIGITS;
6431
 
  case FIELD_TYPE_DOUBLE:
 
6431
  case DRIZZLE_TYPE_DOUBLE:
6432
6432
    return 53;
6433
 
  case FIELD_TYPE_NULL:
 
6433
  case DRIZZLE_TYPE_NULL:
6434
6434
    return 0;
6435
 
  case FIELD_TYPE_LONGLONG:
 
6435
  case DRIZZLE_TYPE_LONGLONG:
6436
6436
    return 20;
6437
6437
  default:
6438
6438
    assert(0); // we should never go there
6460
6460
  Field *field;
6461
6461
 
6462
6462
  switch (fld_type) {
6463
 
  case FIELD_TYPE_ENUM:
 
6463
  case DRIZZLE_TYPE_ENUM:
6464
6464
    assert(enum_set_typelib);
6465
6465
    field= new Field_enum((uchar *) 0, max_length, null_ptr, 0,
6466
6466
                          Field::NONE, name,
6469
6469
    if (field)
6470
6470
      field->init(table);
6471
6471
    return field;
6472
 
  case FIELD_TYPE_SET:
 
6472
  case DRIZZLE_TYPE_SET:
6473
6473
    assert(enum_set_typelib);
6474
6474
    field= new Field_set((uchar *) 0, max_length, null_ptr, 0,
6475
6475
                         Field::NONE, name,
6478
6478
    if (field)
6479
6479
      field->init(table);
6480
6480
    return field;
6481
 
  case FIELD_TYPE_NULL:
 
6481
  case DRIZZLE_TYPE_NULL:
6482
6482
    return make_string_field(table);
6483
6483
  default:
6484
6484
    break;
6495
6495
*/
6496
6496
void Item_type_holder::get_full_info(Item *item)
6497
6497
{
6498
 
  if (fld_type == FIELD_TYPE_ENUM ||
6499
 
      fld_type == FIELD_TYPE_SET)
 
6498
  if (fld_type == DRIZZLE_TYPE_ENUM ||
 
6499
      fld_type == DRIZZLE_TYPE_SET)
6500
6500
  {
6501
6501
    if (item->type() == Item::SUM_FUNC_ITEM &&
6502
6502
        (((Item_sum*)item)->sum_func() == Item_sum::MAX_FUNC ||
6507
6507
      field (or MIN|MAX(enum|set field)) and number of NULL fields
6508
6508
    */
6509
6509
    assert((enum_set_typelib &&
6510
 
                 get_real_type(item) == FIELD_TYPE_NULL) ||
 
6510
                 get_real_type(item) == DRIZZLE_TYPE_NULL) ||
6511
6511
                (!enum_set_typelib &&
6512
6512
                 item->type() == Item::FIELD_ITEM &&
6513
 
                 (get_real_type(item) == FIELD_TYPE_ENUM ||
6514
 
                  get_real_type(item) == FIELD_TYPE_SET) &&
 
6513
                 (get_real_type(item) == DRIZZLE_TYPE_ENUM ||
 
6514
                  get_real_type(item) == DRIZZLE_TYPE_SET) &&
6515
6515
                 ((Field_enum*)((Item_field *) item)->field)->typelib));
6516
6516
    if (!enum_set_typelib)
6517
6517
    {