← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item.cc

Merged build changes from Antony.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item.cc
18
18
#pragma implementation                          // gcc: Class implementation
19
19
#endif
20
20
#include "mysql_priv.h"
21
 
#include <m_ctype.h>
22
 
#include "my_dir.h"
23
21
#include "sql_select.h"
24
22
 
25
23
const String my_null_string("NULL", 4, default_charset_info);
44
42
 
45
43
my_decimal *
46
44
Hybrid_type_traits::val_decimal(Hybrid_type *val,
47
 
                                my_decimal *to __attribute__((__unused__))) const
 
45
                                my_decimal *to __attribute__((unused))) const
48
46
{
49
47
  double2my_decimal(E_DEC_FATAL_ERROR, val->real, val->dec_buf);
50
48
  return val->dec_buf;
52
50
 
53
51
 
54
52
String *
55
 
Hybrid_type_traits::val_str(Hybrid_type *val, String *to, uint8 decimals) const
 
53
Hybrid_type_traits::val_str(Hybrid_type *val, String *to, uint8_t decimals) const
56
54
{
57
55
  to->set_real(val->real, decimals, &my_charset_bin);
58
56
  return to;
130
128
 
131
129
String *
132
130
Hybrid_type_traits_decimal::val_str(Hybrid_type *val, String *to,
133
 
                                    uint8 decimals) const
 
131
                                    uint8_t decimals) const
134
132
{
135
133
  my_decimal_round(E_DEC_FATAL_ERROR, &val->dec_buf[val->used_dec_buf_no],
136
134
                   decimals, false, &val->dec_buf[2]);
148
146
 
149
147
void
150
148
Hybrid_type_traits_integer::fix_length_and_dec(Item *item,
151
 
                                               Item *arg __attribute__((__unused__))) const
 
149
                                               Item *arg __attribute__((unused))) const
152
150
{
153
151
  item->decimals= 0;
154
152
  item->max_length= MY_INT64_NUM_DECIMAL_DIGITS;
469
467
  @param arg   a dummy parameter, is not used here
470
468
*/
471
469
 
472
 
bool Item::cleanup_processor(uchar *arg __attribute__((__unused__)))
 
470
bool Item::cleanup_processor(uchar *arg __attribute__((unused)))
473
471
{
474
472
  if (fixed)
475
473
    cleanup();
733
731
  - When trying to find an ORDER BY/GROUP BY item in the SELECT part
734
732
*/
735
733
 
736
 
bool Item::eq(const Item *item, bool binary_cmp __attribute__((__unused__))) const
 
734
bool Item::eq(const Item *item, bool binary_cmp __attribute__((unused))) const
737
735
{
738
736
  /*
739
737
    Note, that this is never true if item is a Item_param:
763
761
  the latter returns a non-fixed Item, so val_str() crashes afterwards.
764
762
  Override Item_num method, to return a fixed item.
765
763
*/
766
 
Item *Item_num::safe_charset_converter(CHARSET_INFO *tocs __attribute__((__unused__)))
 
764
Item *Item_num::safe_charset_converter(CHARSET_INFO *tocs __attribute__((unused)))
767
765
{
768
766
  Item_string *conv;
769
767
  char buf[64];
778
776
}
779
777
 
780
778
 
781
 
Item *Item_static_float_func::safe_charset_converter(CHARSET_INFO *tocs __attribute__((__unused__)))
 
779
Item *Item_static_float_func::safe_charset_converter(CHARSET_INFO *tocs __attribute__((unused)))
782
780
{
783
781
  Item_string *conv;
784
782
  char buf[64];
913
911
  return 0;
914
912
 
915
913
err:
916
 
  bzero((char*) ltime,sizeof(*ltime));
 
914
  memset((char*) ltime, 0, sizeof(*ltime));
917
915
  return 1;
918
916
}
919
917
 
930
928
  if (!(res=val_str(&tmp)) ||
931
929
      str_to_time_with_warn(res->ptr(), res->length(), ltime))
932
930
  {
933
 
    bzero((char*) ltime,sizeof(*ltime));
 
931
    memset((char*) ltime, 0, sizeof(*ltime));
934
932
    return 1;
935
933
  }
936
934
  return 0;
1343
1341
  for (i= 0, arg= args; i < nargs; i++, arg+= item_sep)
1344
1342
  {
1345
1343
    Item* conv;
1346
 
    uint32 dummy_offset;
 
1344
    uint32_t dummy_offset;
1347
1345
    if (!String::needs_conversion(0, (*arg)->collation.collation,
1348
1346
                                  coll.collation,
1349
1347
                                  &dummy_offset))
1426
1424
  Item_field (this is important in prepared statements).
1427
1425
*/
1428
1426
 
1429
 
Item_field::Item_field(THD *thd __attribute__((__unused__)),
 
1427
Item_field::Item_field(THD *thd __attribute__((unused)),
1430
1428
                       Name_resolution_context *context_arg,
1431
1429
                       Field *f)
1432
1430
  :Item_ident(context_arg, f->table->s->db.str, *f->table_name, f->field_name),
1523
1521
}
1524
1522
 
1525
1523
void Item_ident::print(String *str,
1526
 
                       enum_query_type query_type __attribute__((__unused__)))
 
1524
                       enum_query_type query_type __attribute__((unused)))
1527
1525
{
1528
1526
  THD *thd= current_thd;
1529
1527
  char d_name_buff[MAX_ALIAS_NAME], t_name_buff[MAX_ALIAS_NAME];
1624
1622
{
1625
1623
  if ((null_value=field->is_null()) || field->get_date(ltime,fuzzydate))
1626
1624
  {
1627
 
    bzero((char*) ltime,sizeof(*ltime));
 
1625
    memset((char*) ltime, 0, sizeof(*ltime));
1628
1626
    return 1;
1629
1627
  }
1630
1628
  return 0;
1635
1633
  if ((null_value=result_field->is_null()) ||
1636
1634
      result_field->get_date(ltime,fuzzydate))
1637
1635
  {
1638
 
    bzero((char*) ltime,sizeof(*ltime));
 
1636
    memset((char*) ltime, 0, sizeof(*ltime));
1639
1637
    return 1;
1640
1638
  }
1641
1639
  return 0;
1645
1643
{
1646
1644
  if ((null_value=field->is_null()) || field->get_time(ltime))
1647
1645
  {
1648
 
    bzero((char*) ltime,sizeof(*ltime));
 
1646
    memset((char*) ltime, 0, sizeof(*ltime));
1649
1647
    return 1;
1650
1648
  }
1651
1649
  return 0;
1701
1699
 
1702
1700
 
1703
1701
bool Item_field::eq(const Item *item,
1704
 
                    bool binary_cmp __attribute__((__unused__))) const
 
1702
                    bool binary_cmp __attribute__((unused))) const
1705
1703
{
1706
1704
  Item *real_item= ((Item *) item)->real_item();
1707
1705
  if (real_item->type() != FIELD_ITEM)
1740
1738
 
1741
1739
 
1742
1740
void Item_field::fix_after_pullout(st_select_lex *new_parent,
1743
 
                                   Item **ref __attribute__((__unused__)))
 
1741
                                   Item **ref __attribute__((unused)))
1744
1742
{
1745
1743
  if (new_parent == depended_from)
1746
1744
    depended_from= NULL;
1761
1759
  return new_item;
1762
1760
}
1763
1761
 
1764
 
int64_t Item_field::val_int_endpoint(bool left_endp __attribute__((__unused__)),
1765
 
                                      bool *incl_endp __attribute__((__unused__)))
 
1762
int64_t Item_field::val_int_endpoint(bool left_endp __attribute__((unused)),
 
1763
                                      bool *incl_endp __attribute__((unused)))
1766
1764
{
1767
1765
  int64_t res= val_int();
1768
1766
  return null_value? INT64_MIN : res;
1800
1798
}
1801
1799
 
1802
1800
void Item_int::print(String *str,
1803
 
                     enum_query_type query_type __attribute__((__unused__)))
 
1801
                     enum_query_type query_type __attribute__((unused)))
1804
1802
{
1805
1803
  // my_charset_bin is good enough for numbers
1806
1804
  str_value.set(value, &my_charset_bin);
1832
1830
 
1833
1831
 
1834
1832
void Item_uint::print(String *str,
1835
 
                      enum_query_type query_type __attribute__((__unused__)))
 
1833
                      enum_query_type query_type __attribute__((unused)))
1836
1834
{
1837
1835
  // latin1 is good enough for numbers
1838
1836
  str_value.set((uint64_t) value, default_charset());
1845
1843
{
1846
1844
  str2my_decimal(E_DEC_FATAL_ERROR, str_arg, length, charset, &decimal_value);
1847
1845
  name= (char*) str_arg;
1848
 
  decimals= (uint8) decimal_value.frac;
 
1846
  decimals= (uint8_t) decimal_value.frac;
1849
1847
  fixed= 1;
1850
1848
  max_length= my_decimal_precision_to_length(decimal_value.intg + decimals,
1851
1849
                                             decimals, unsigned_flag);
1854
1852
Item_decimal::Item_decimal(int64_t val, bool unsig)
1855
1853
{
1856
1854
  int2my_decimal(E_DEC_FATAL_ERROR, val, unsig, &decimal_value);
1857
 
  decimals= (uint8) decimal_value.frac;
 
1855
  decimals= (uint8_t) decimal_value.frac;
1858
1856
  fixed= 1;
1859
1857
  max_length= my_decimal_precision_to_length(decimal_value.intg + decimals,
1860
1858
                                             decimals, unsigned_flag);
1862
1860
 
1863
1861
 
1864
1862
Item_decimal::Item_decimal(double val,
1865
 
                           int precision __attribute__((__unused__)),
1866
 
                           int scale __attribute__((__unused__)))
 
1863
                           int precision __attribute__((unused)),
 
1864
                           int scale __attribute__((unused)))
1867
1865
{
1868
1866
  double2my_decimal(E_DEC_FATAL_ERROR, val, &decimal_value);
1869
 
  decimals= (uint8) decimal_value.frac;
 
1867
  decimals= (uint8_t) decimal_value.frac;
1870
1868
  fixed= 1;
1871
1869
  max_length= my_decimal_precision_to_length(decimal_value.intg + decimals,
1872
1870
                                             decimals, unsigned_flag);
1878
1876
{
1879
1877
  my_decimal2decimal(val_arg, &decimal_value);
1880
1878
  name= (char*) str;
1881
 
  decimals= (uint8) decimal_par;
 
1879
  decimals= (uint8_t) decimal_par;
1882
1880
  max_length= length;
1883
1881
  fixed= 1;
1884
1882
}
1887
1885
Item_decimal::Item_decimal(my_decimal *value_par)
1888
1886
{
1889
1887
  my_decimal2decimal(value_par, &decimal_value);
1890
 
  decimals= (uint8) decimal_value.frac;
 
1888
  decimals= (uint8_t) decimal_value.frac;
1891
1889
  fixed= 1;
1892
1890
  max_length= my_decimal_precision_to_length(decimal_value.intg + decimals,
1893
1891
                                             decimals, unsigned_flag);
1898
1896
{
1899
1897
  binary2my_decimal(E_DEC_FATAL_ERROR, bin,
1900
1898
                    &decimal_value, precision, scale);
1901
 
  decimals= (uint8) decimal_value.frac;
 
1899
  decimals= (uint8_t) decimal_value.frac;
1902
1900
  fixed= 1;
1903
1901
  max_length= my_decimal_precision_to_length(precision, decimals,
1904
1902
                                             unsigned_flag);
1927
1925
}
1928
1926
 
1929
1927
void Item_decimal::print(String *str,
1930
 
                         enum_query_type query_type __attribute__((__unused__)))
 
1928
                         enum_query_type query_type __attribute__((unused)))
1931
1929
{
1932
1930
  my_decimal2string(E_DEC_FATAL_ERROR, &decimal_value, 0, 0, 0, &str_value);
1933
1931
  str->append(str_value);
1935
1933
 
1936
1934
 
1937
1935
bool Item_decimal::eq(const Item *item,
1938
 
                      bool binary_cmp __attribute__((__unused__))) const
 
1936
                      bool binary_cmp __attribute__((unused))) const
1939
1937
{
1940
1938
  if (type() == item->type() && item->basic_const_item())
1941
1939
  {
1956
1954
void Item_decimal::set_decimal_value(my_decimal *value_par)
1957
1955
{
1958
1956
  my_decimal2decimal(value_par, &decimal_value);
1959
 
  decimals= (uint8) decimal_value.frac;
 
1957
  decimals= (uint8_t) decimal_value.frac;
1960
1958
  unsigned_flag= !decimal_value.sign();
1961
1959
  max_length= my_decimal_precision_to_length(decimal_value.intg + decimals,
1962
1960
                                             decimals, unsigned_flag);
2081
2079
 
2082
2080
 
2083
2081
bool Item_null::eq(const Item *item,
2084
 
                   bool binary_cmp __attribute__((__unused__))) const
 
2082
                   bool binary_cmp __attribute__((unused))) const
2085
2083
{ return item->type() == type(); }
2086
2084
 
2087
2085
 
2100
2098
  return 0;
2101
2099
}
2102
2100
/* ARGSUSED */
2103
 
String *Item_null::val_str(String *str __attribute__((__unused__)))
 
2101
String *Item_null::val_str(String *str __attribute__((unused)))
2104
2102
{
2105
2103
  // following assert is redundant, because fixed=1 assigned in constructor
2106
2104
  assert(fixed == 1);
2108
2106
  return 0;
2109
2107
}
2110
2108
 
2111
 
my_decimal *Item_null::val_decimal(my_decimal *decimal_value __attribute__((__unused__)))
 
2109
my_decimal *Item_null::val_decimal(my_decimal *decimal_value __attribute__((unused)))
2112
2110
{
2113
2111
  return 0;
2114
2112
}
2141
2139
  item_result_type(STRING_RESULT),
2142
2140
  /* Don't pretend to be a literal unless value for this item is set. */
2143
2141
  item_type(PARAM_ITEM),
2144
 
  param_type(MYSQL_TYPE_VARCHAR),
 
2142
  param_type(DRIZZLE_TYPE_VARCHAR),
2145
2143
  pos_in_query(pos_in_query_arg),
2146
2144
  set_param_func(default_set_param_func),
2147
2145
  limit_clause_param(false)
2174
2172
  return;
2175
2173
}
2176
2174
 
2177
 
void Item_param::set_int(int64_t i, uint32 max_length_arg)
 
2175
void Item_param::set_int(int64_t i, uint32_t max_length_arg)
2178
2176
{
2179
2177
  value.integer= (int64_t) i;
2180
2178
  state= INT_VALUE;
2236
2234
    MAX_DATE_STRING_REP_LENGTH buffer.
2237
2235
*/
2238
2236
void Item_param::set_time(MYSQL_TIME *tm, timestamp_type time_type,
2239
 
                          uint32 max_length_arg)
 
2237
                          uint32_t max_length_arg)
2240
2238
{ 
2241
2239
  value.time= *tm;
2242
2240
  value.time.time_type= time_type;
2338
2336
    {
2339
2337
      CHARSET_INFO *fromcs= entry->collation.collation;
2340
2338
      CHARSET_INFO *tocs= thd->variables.collation_connection;
2341
 
      uint32 dummy_offset;
 
2339
      uint32_t dummy_offset;
2342
2340
 
2343
2341
      value.cs_info.character_set_of_placeholder= 
2344
2342
        value.cs_info.character_set_client= fromcs;
2646
2644
      *ptr++= '\'';
2647
2645
      ptr+= (uint) my_TIME_to_str(&value.time, ptr);
2648
2646
      *ptr++= '\'';
2649
 
      str->length((uint32) (ptr - buf));
 
2647
      str->length((uint32_t) (ptr - buf));
2650
2648
      break;
2651
2649
    }
2652
2650
  case STRING_VALUE:
2776
2774
/* End of Item_param related */
2777
2775
 
2778
2776
void Item_param::print(String *str,
2779
 
                       enum_query_type query_type __attribute__((__unused__)))
 
2777
                       enum_query_type query_type __attribute__((unused)))
2780
2778
{
2781
2779
  if (state == NO_VALUE)
2782
2780
  {
2806
2804
}
2807
2805
 
2808
2806
/* ARGSUSED */
2809
 
String *Item_copy_string::val_str(String *str __attribute__((__unused__)))
 
2807
String *Item_copy_string::val_str(String *str __attribute__((unused)))
2810
2808
{
2811
2809
  // Item_copy_string is used without fix_fields call
2812
2810
  if (null_value)
2830
2828
*/
2831
2829
 
2832
2830
/* ARGSUSED */
2833
 
bool Item::fix_fields(THD *thd __attribute__((__unused__)),
2834
 
                      Item **ref __attribute__((__unused__)))
 
2831
bool Item::fix_fields(THD *thd __attribute__((unused)),
 
2832
                      Item **ref __attribute__((unused)))
2835
2833
{
2836
2834
 
2837
2835
  // We do not check fields which are fixed during construction
3786
3784
 
3787
3785
 
3788
3786
/**
3789
 
  Convert a numeric value to a zero-filled string
3790
 
 
3791
 
  @param[in,out]  item   the item to operate on
3792
 
  @param          field  The field that this value is equated to
3793
 
 
3794
 
  This function converts a numeric value to a string. In this conversion
3795
 
  the zero-fill flag of the field is taken into account.
3796
 
  This is required so the resulting string value can be used instead of
3797
 
  the field reference when propagating equalities.
3798
 
*/
3799
 
 
3800
 
static void convert_zerofill_number_to_string(Item **item, Field_num *field)
3801
 
{
3802
 
  char buff[MAX_FIELD_WIDTH],*pos;
3803
 
  String tmp(buff,sizeof(buff), field->charset()), *res;
3804
 
 
3805
 
  res= (*item)->val_str(&tmp);
3806
 
  field->prepend_zeros(res);
3807
 
  pos= (char *) sql_strmake (res->ptr(), res->length());
3808
 
  *item= new Item_string(pos, res->length(), field->charset());
3809
 
}
3810
 
 
3811
 
 
3812
 
/**
3813
3787
  Set a pointer to the multiple equality the field reference belongs to
3814
3788
  (if any).
3815
3789
 
3855
3829
  if (!item ||
3856
3830
      (cmp_context != (Item_result)-1 && item->cmp_context != cmp_context))
3857
3831
    item= this;
3858
 
  else if (field && (field->flags & ZEROFILL_FLAG) && IS_NUM(field->type()))
3859
 
  {
3860
 
    if (item && cmp_context != INT_RESULT)
3861
 
      convert_zerofill_number_to_string(&item, (Field_num *)field);
3862
 
    else
3863
 
      item= this;
3864
 
  }
 
3832
 
3865
3833
  return item;
3866
3834
}
3867
3835
 
3872
3840
  See comments in Arg_comparator::set_compare_func() for details.
3873
3841
*/
3874
3842
 
3875
 
bool Item_field::set_no_const_sub(uchar *arg __attribute__((__unused__)))
 
3843
bool Item_field::set_no_const_sub(uchar *arg __attribute__((unused)))
3876
3844
{
3877
3845
  if (field->charset() != &my_charset_bin)
3878
3846
    no_const_subst=1;
3905
3873
    - this - otherwise.
3906
3874
*/
3907
3875
 
3908
 
Item *Item_field::replace_equal_field(uchar *arg __attribute__((__unused__)))
 
3876
Item *Item_field::replace_equal_field(uchar *arg __attribute__((unused)))
3909
3877
{
3910
3878
  if (item_equal)
3911
3879
  {
3953
3921
 
3954
3922
enum_field_types Item::string_field_type() const
3955
3923
{
3956
 
  enum_field_types f_type= MYSQL_TYPE_VAR_STRING;
 
3924
  enum_field_types f_type= DRIZZLE_TYPE_VAR_STRING;
3957
3925
  if (max_length >= 65536)
3958
 
    f_type= MYSQL_TYPE_BLOB;
 
3926
    f_type= DRIZZLE_TYPE_BLOB;
3959
3927
  return f_type;
3960
3928
}
3961
3929
 
3970
3938
{
3971
3939
  switch (result_type()) {
3972
3940
  case STRING_RESULT:  return string_field_type();
3973
 
  case INT_RESULT:     return MYSQL_TYPE_LONGLONG;
3974
 
  case DECIMAL_RESULT: return MYSQL_TYPE_NEWDECIMAL;
3975
 
  case REAL_RESULT:    return MYSQL_TYPE_DOUBLE;
 
3941
  case INT_RESULT:     return DRIZZLE_TYPE_LONGLONG;
 
3942
  case DECIMAL_RESULT: return DRIZZLE_TYPE_NEWDECIMAL;
 
3943
  case REAL_RESULT:    return DRIZZLE_TYPE_DOUBLE;
3976
3944
  case ROW_RESULT:
3977
3945
  default:
3978
3946
    assert(0);
3979
 
    return MYSQL_TYPE_VARCHAR;
 
3947
    return DRIZZLE_TYPE_VARCHAR;
3980
3948
  }
3981
3949
}
3982
3950
 
3985
3953
{
3986
3954
  switch (field_type())
3987
3955
  {
3988
 
    case MYSQL_TYPE_NEWDATE:
3989
 
    case MYSQL_TYPE_DATETIME:
3990
 
    case MYSQL_TYPE_TIMESTAMP:
 
3956
    case DRIZZLE_TYPE_NEWDATE:
 
3957
    case DRIZZLE_TYPE_DATETIME:
 
3958
    case DRIZZLE_TYPE_TIMESTAMP:
3991
3959
      return true;
3992
3960
    default:
3993
3961
      break;
4092
4060
                          collation.collation);
4093
4061
  /* Item_type_holder holds the exact type, do not change it */
4094
4062
  else if (max_length > 0 &&
4095
 
      (type() != Item::TYPE_HOLDER || field_type() != MYSQL_TYPE_STRING))
 
4063
      (type() != Item::TYPE_HOLDER || field_type() != DRIZZLE_TYPE_STRING))
4096
4064
    field= new Field_varstring(max_length, maybe_null, name, table->s,
4097
4065
                               collation.collation);
4098
4066
  else
4125
4093
  Field *field;
4126
4094
 
4127
4095
  switch (field_type()) {
4128
 
  case MYSQL_TYPE_NEWDECIMAL:
 
4096
  case DRIZZLE_TYPE_NEWDECIMAL:
4129
4097
    field= new Field_new_decimal((uchar*) 0, max_length, null_ptr, 0,
4130
4098
                                 Field::NONE, name, decimals, 0,
4131
4099
                                 unsigned_flag);
4132
4100
    break;
4133
 
  case MYSQL_TYPE_TINY:
 
4101
  case DRIZZLE_TYPE_TINY:
4134
4102
    field= new Field_tiny((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4135
4103
                          name, 0, unsigned_flag);
4136
4104
    break;
4137
 
  case MYSQL_TYPE_SHORT:
 
4105
  case DRIZZLE_TYPE_SHORT:
4138
4106
    field= new Field_short((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4139
4107
                           name, 0, unsigned_flag);
4140
4108
    break;
4141
 
  case MYSQL_TYPE_LONG:
 
4109
  case DRIZZLE_TYPE_LONG:
4142
4110
    field= new Field_long((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4143
4111
                          name, 0, unsigned_flag);
4144
4112
    break;
4145
 
  case MYSQL_TYPE_LONGLONG:
 
4113
  case DRIZZLE_TYPE_LONGLONG:
4146
4114
    field= new Field_int64_t((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4147
4115
                              name, 0, unsigned_flag);
4148
4116
    break;
4149
 
  case MYSQL_TYPE_DOUBLE:
 
4117
  case DRIZZLE_TYPE_DOUBLE:
4150
4118
    field= new Field_double((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4151
4119
                            name, decimals, 0, unsigned_flag);
4152
4120
    break;
4153
 
  case MYSQL_TYPE_NULL:
 
4121
  case DRIZZLE_TYPE_NULL:
4154
4122
    field= new Field_null((uchar*) 0, max_length, Field::NONE,
4155
4123
                          name, &my_charset_bin);
4156
4124
    break;
4157
 
  case MYSQL_TYPE_NEWDATE:
 
4125
  case DRIZZLE_TYPE_NEWDATE:
4158
4126
    field= new Field_newdate(maybe_null, name, &my_charset_bin);
4159
4127
    break;
4160
 
  case MYSQL_TYPE_TIME:
 
4128
  case DRIZZLE_TYPE_TIME:
4161
4129
    field= new Field_time(maybe_null, name, &my_charset_bin);
4162
4130
    break;
4163
 
  case MYSQL_TYPE_TIMESTAMP:
 
4131
  case DRIZZLE_TYPE_TIMESTAMP:
4164
4132
    field= new Field_timestamp(maybe_null, name, &my_charset_bin);
4165
4133
    break;
4166
 
  case MYSQL_TYPE_DATETIME:
 
4134
  case DRIZZLE_TYPE_DATETIME:
4167
4135
    field= new Field_datetime(maybe_null, name, &my_charset_bin);
4168
4136
    break;
4169
 
  case MYSQL_TYPE_YEAR:
4170
 
    field= new Field_year((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4171
 
                          name);
4172
 
    break;
4173
4137
  default:
4174
4138
    /* This case should never be chosen */
4175
4139
    assert(0);
4176
4140
    /* If something goes awfully wrong, it's better to get a string than die */
4177
 
  case MYSQL_TYPE_STRING:
 
4141
  case DRIZZLE_TYPE_STRING:
4178
4142
    if (fixed_length && max_length < CONVERT_IF_BIGGER_TO_BLOB)
4179
4143
    {
4180
4144
      field= new Field_string(max_length, maybe_null, name,
4182
4146
      break;
4183
4147
    }
4184
4148
    /* Fall through to make_string_field() */
4185
 
  case MYSQL_TYPE_ENUM:
4186
 
  case MYSQL_TYPE_SET:
4187
 
  case MYSQL_TYPE_VAR_STRING:
4188
 
  case MYSQL_TYPE_VARCHAR:
 
4149
  case DRIZZLE_TYPE_ENUM:
 
4150
  case DRIZZLE_TYPE_SET:
 
4151
  case DRIZZLE_TYPE_VAR_STRING:
 
4152
  case DRIZZLE_TYPE_VARCHAR:
4189
4153
    return make_string_field(table);
4190
 
  case MYSQL_TYPE_BLOB:
 
4154
  case DRIZZLE_TYPE_BLOB:
4191
4155
    if (this->type() == Item::TYPE_HOLDER)
4192
4156
      field= new Field_blob(max_length, maybe_null, name, collation.collation,
4193
4157
                            1);
4356
4320
 
4357
4321
 
4358
4322
int Item_string::save_in_field(Field *field,
4359
 
                               bool no_conversions __attribute__((__unused__)))
 
4323
                               bool no_conversions __attribute__((unused)))
4360
4324
{
4361
4325
  String *result;
4362
4326
  result=val_str(&str_value);
4372
4336
 
4373
4337
 
4374
4338
int Item_int::save_in_field(Field *field,
4375
 
                            bool no_conversions __attribute__((__unused__)))
 
4339
                            bool no_conversions __attribute__((unused)))
4376
4340
{
4377
4341
  int64_t nr=val_int();
4378
4342
  if (null_value)
4383
4347
 
4384
4348
 
4385
4349
int Item_decimal::save_in_field(Field *field,
4386
 
                                bool no_conversions __attribute__((__unused__)))
 
4350
                                bool no_conversions __attribute__((unused)))
4387
4351
{
4388
4352
  field->set_notnull();
4389
4353
  return field->store_decimal(&decimal_value);
4391
4355
 
4392
4356
 
4393
4357
bool Item_int::eq(const Item *arg,
4394
 
                  bool binary_cmp __attribute__((__unused__))) const
 
4358
                  bool binary_cmp __attribute__((unused))) const
4395
4359
{
4396
4360
  /* No need to check for null value as basic constant can't be NULL */
4397
4361
  if (arg->basic_const_item() && arg->type() == type())
4471
4435
    my_error(ER_ILLEGAL_VALUE_FOR_TYPE, MYF(0), "double", (char*) str_arg);
4472
4436
  }
4473
4437
  presentation= name=(char*) str_arg;
4474
 
  decimals=(uint8) nr_of_decimals(str_arg, str_arg+length);
 
4438
  decimals=(uint8_t) nr_of_decimals(str_arg, str_arg+length);
4475
4439
  max_length=length;
4476
4440
  fixed= 1;
4477
4441
}
4478
4442
 
4479
4443
 
4480
4444
int Item_float::save_in_field(Field *field,
4481
 
                              bool no_conversions __attribute__((__unused__)))
 
4445
                              bool no_conversions __attribute__((unused)))
4482
4446
{
4483
4447
  double nr= val_real();
4484
4448
  if (null_value)
4489
4453
 
4490
4454
 
4491
4455
void Item_float::print(String *str,
4492
 
                       enum_query_type query_type __attribute__((__unused__)))
 
4456
                       enum_query_type query_type __attribute__((unused)))
4493
4457
{
4494
4458
  if (presentation)
4495
4459
  {
4510
4474
*/
4511
4475
 
4512
4476
bool Item_float::eq(const Item *arg,
4513
 
                    bool binary_cmp __attribute__((__unused__))) const
 
4477
                    bool binary_cmp __attribute__((unused))) const
4514
4478
{
4515
4479
  if (arg->basic_const_item() && arg->type() == type())
4516
4480
  {
4579
4543
 
4580
4544
 
4581
4545
int Item_hex_string::save_in_field(Field *field,
4582
 
                                   bool no_conversions __attribute__((__unused__)))
 
4546
                                   bool no_conversions __attribute__((unused)))
4583
4547
{
4584
4548
  field->set_notnull();
4585
4549
  if (field->result_type() == STRING_RESULT)
4587
4551
                        collation.collation);
4588
4552
 
4589
4553
  uint64_t nr;
4590
 
  uint32 length= str_value.length();
 
4554
  uint32_t length= str_value.length();
4591
4555
  if (length > 8)
4592
4556
  {
4593
4557
    nr= field->flags & UNSIGNED_FLAG ? UINT64_MAX : INT64_MAX;
4610
4574
 
4611
4575
 
4612
4576
void Item_hex_string::print(String *str,
4613
 
                            enum_query_type query_type __attribute__((__unused__)))
 
4577
                            enum_query_type query_type __attribute__((unused)))
4614
4578
{
4615
4579
  char *end= (char*) str_value.ptr() + str_value.length(),
4616
4580
       *ptr= end - min(str_value.length(), sizeof(int64_t));
4690
4654
*/
4691
4655
 
4692
4656
bool Item_null::send(Protocol *protocol,
4693
 
                     String *packet __attribute__((__unused__)))
 
4657
                     String *packet __attribute__((unused)))
4694
4658
{
4695
4659
  return protocol->store_null();
4696
4660
}
4706
4670
 
4707
4671
  switch ((f_type=field_type())) {
4708
4672
  default:
4709
 
  case MYSQL_TYPE_NULL:
4710
 
  case MYSQL_TYPE_ENUM:
4711
 
  case MYSQL_TYPE_SET:
4712
 
  case MYSQL_TYPE_BLOB:
4713
 
  case MYSQL_TYPE_STRING:
4714
 
  case MYSQL_TYPE_VAR_STRING:
4715
 
  case MYSQL_TYPE_VARCHAR:
4716
 
  case MYSQL_TYPE_NEWDECIMAL:
 
4673
  case DRIZZLE_TYPE_NULL:
 
4674
  case DRIZZLE_TYPE_ENUM:
 
4675
  case DRIZZLE_TYPE_SET:
 
4676
  case DRIZZLE_TYPE_BLOB:
 
4677
  case DRIZZLE_TYPE_STRING:
 
4678
  case DRIZZLE_TYPE_VAR_STRING:
 
4679
  case DRIZZLE_TYPE_VARCHAR:
 
4680
  case DRIZZLE_TYPE_NEWDECIMAL:
4717
4681
  {
4718
4682
    String *res;
4719
4683
    if ((res=val_str(buffer)))
4720
4684
      result= protocol->store(res->ptr(),res->length(),res->charset());
4721
4685
    break;
4722
4686
  }
4723
 
  case MYSQL_TYPE_TINY:
 
4687
  case DRIZZLE_TYPE_TINY:
4724
4688
  {
4725
4689
    int64_t nr;
4726
4690
    nr= val_int();
4728
4692
      result= protocol->store_tiny(nr);
4729
4693
    break;
4730
4694
  }
4731
 
  case MYSQL_TYPE_SHORT:
4732
 
  case MYSQL_TYPE_YEAR:
 
4695
  case DRIZZLE_TYPE_SHORT:
4733
4696
  {
4734
4697
    int64_t nr;
4735
4698
    nr= val_int();
4737
4700
      result= protocol->store_short(nr);
4738
4701
    break;
4739
4702
  }
4740
 
  case MYSQL_TYPE_LONG:
 
4703
  case DRIZZLE_TYPE_LONG:
4741
4704
  {
4742
4705
    int64_t nr;
4743
4706
    nr= val_int();
4745
4708
      result= protocol->store_long(nr);
4746
4709
    break;
4747
4710
  }
4748
 
  case MYSQL_TYPE_LONGLONG:
 
4711
  case DRIZZLE_TYPE_LONGLONG:
4749
4712
  {
4750
4713
    int64_t nr;
4751
4714
    nr= val_int();
4753
4716
      result= protocol->store_int64_t(nr, unsigned_flag);
4754
4717
    break;
4755
4718
  }
4756
 
  case MYSQL_TYPE_DOUBLE:
 
4719
  case DRIZZLE_TYPE_DOUBLE:
4757
4720
  {
4758
4721
    double nr= val_real();
4759
4722
    if (!null_value)
4760
4723
      result= protocol->store(nr, decimals, buffer);
4761
4724
    break;
4762
4725
  }
4763
 
  case MYSQL_TYPE_DATETIME:
4764
 
  case MYSQL_TYPE_TIMESTAMP:
 
4726
  case DRIZZLE_TYPE_DATETIME:
 
4727
  case DRIZZLE_TYPE_TIMESTAMP:
4765
4728
  {
4766
4729
    MYSQL_TIME tm;
4767
4730
    get_date(&tm, TIME_FUZZY_DATE);
4768
4731
    if (!null_value)
4769
4732
    {
4770
 
      if (f_type == MYSQL_TYPE_NEWDATE)
 
4733
      if (f_type == DRIZZLE_TYPE_NEWDATE)
4771
4734
        return protocol->store_date(&tm);
4772
4735
      else
4773
4736
        result= protocol->store(&tm);
4774
4737
    }
4775
4738
    break;
4776
4739
  }
4777
 
  case MYSQL_TYPE_TIME:
 
4740
  case DRIZZLE_TYPE_TIME:
4778
4741
  {
4779
4742
    MYSQL_TIME tm;
4780
4743
    get_time(&tm);
4790
4753
 
4791
4754
 
4792
4755
bool Item_field::send(Protocol *protocol,
4793
 
                      String *buffer __attribute__((__unused__)))
 
4756
                      String *buffer __attribute__((unused)))
4794
4757
{
4795
4758
  return protocol->store(result_field);
4796
4759
}
5538
5501
}
5539
5502
 
5540
5503
void Item_ref::fix_after_pullout(st_select_lex *new_parent,
5541
 
                                 Item **refptr __attribute__((__unused__)))
 
5504
                                 Item **refptr __attribute__((unused)))
5542
5505
{
5543
5506
  if (depended_from == new_parent)
5544
5507
  {
5565
5528
*/
5566
5529
 
5567
5530
bool Item_direct_view_ref::eq(const Item *item,
5568
 
                              bool binary_cmp __attribute__((__unused__))) const
 
5531
                              bool binary_cmp __attribute__((unused))) const
5569
5532
{
5570
5533
  if (item->type() == REF_ITEM)
5571
5534
  {
5587
5550
 
5588
5551
 
5589
5552
bool Item_default_value::fix_fields(THD *thd,
5590
 
                                    Item **items __attribute__((__unused__)))
 
5553
                                    Item **items __attribute__((unused)))
5591
5554
{
5592
5555
  Item *real_arg;
5593
5556
  Item_field *field_arg;
5704
5667
 
5705
5668
 
5706
5669
bool Item_insert_value::fix_fields(THD *thd,
5707
 
                                   Item **items __attribute__((__unused__)))
 
5670
                                   Item **items __attribute__((unused)))
5708
5671
{
5709
5672
  assert(fixed == 0);
5710
5673
  /* We should only check that arg is in first table */
6047
6010
  return str;
6048
6011
}
6049
6012
 
6050
 
my_decimal *Item_cache_decimal::val_decimal(my_decimal *val __attribute__((__unused__)))
 
6013
my_decimal *Item_cache_decimal::val_decimal(my_decimal *val __attribute__((unused)))
6051
6014
{
6052
6015
  assert(fixed);
6053
6016
  return &decimal_value;
6112
6075
int Item_cache_str::save_in_field(Field *field, bool no_conversions)
6113
6076
{
6114
6077
  int res= Item_cache::save_in_field(field, no_conversions);
6115
 
  return (is_varbinary && field->type() == MYSQL_TYPE_STRING &&
 
6078
  return (is_varbinary && field->type() == DRIZZLE_TYPE_STRING &&
6116
6079
          value->length() < field->field_length) ? 1 : res;
6117
6080
}
6118
6081
 
6155
6118
}
6156
6119
 
6157
6120
 
6158
 
void Item_cache_row::illegal_method_call(const char *method __attribute__((__unused__)))
 
6121
void Item_cache_row::illegal_method_call(const char *method __attribute__((unused)))
6159
6122
{
6160
6123
  assert(0);
6161
6124
  my_error(ER_OPERAND_COLUMNS, MYF(0), 1);
6249
6212
    Field *field= ((Item_field *) item)->field;
6250
6213
    enum_field_types type= field->real_type();
6251
6214
    if (field->is_created_from_null_item)
6252
 
      return MYSQL_TYPE_NULL;
 
6215
      return DRIZZLE_TYPE_NULL;
6253
6216
    /* work around about varchar type field detection */
6254
 
    if (type == MYSQL_TYPE_STRING && field->type() == MYSQL_TYPE_VAR_STRING)
6255
 
      return MYSQL_TYPE_VAR_STRING;
 
6217
    if (type == DRIZZLE_TYPE_STRING && field->type() == DRIZZLE_TYPE_VAR_STRING)
 
6218
      return DRIZZLE_TYPE_VAR_STRING;
6256
6219
    return type;
6257
6220
  }
6258
6221
  case SUM_FUNC_ITEM:
6277
6240
      */
6278
6241
      switch (item->result_type()) {
6279
6242
      case STRING_RESULT:
6280
 
        return MYSQL_TYPE_VAR_STRING;
 
6243
        return DRIZZLE_TYPE_VAR_STRING;
6281
6244
      case INT_RESULT:
6282
 
        return MYSQL_TYPE_LONGLONG;
 
6245
        return DRIZZLE_TYPE_LONGLONG;
6283
6246
      case REAL_RESULT:
6284
 
        return MYSQL_TYPE_DOUBLE;
 
6247
        return DRIZZLE_TYPE_DOUBLE;
6285
6248
      case DECIMAL_RESULT:
6286
 
        return MYSQL_TYPE_NEWDECIMAL;
 
6249
        return DRIZZLE_TYPE_NEWDECIMAL;
6287
6250
      case ROW_RESULT:
6288
6251
      default:
6289
6252
        assert(0);
6290
 
        return MYSQL_TYPE_VAR_STRING;
 
6253
        return DRIZZLE_TYPE_VAR_STRING;
6291
6254
      }
6292
6255
    }
6293
6256
    break;
6310
6273
    false  OK
6311
6274
*/
6312
6275
 
6313
 
bool Item_type_holder::join_types(THD *thd __attribute__((__unused__)),
 
6276
bool Item_type_holder::join_types(THD *thd __attribute__((unused)),
6314
6277
                                  Item *item)
6315
6278
{
6316
6279
  uint max_length_orig= max_length;
6338
6301
  case STRING_RESULT:
6339
6302
  {
6340
6303
    const char *old_cs, *old_derivation;
6341
 
    uint32 old_max_chars= max_length / collation.collation->mbmaxlen;
 
6304
    uint32_t old_max_chars= max_length / collation.collation->mbmaxlen;
6342
6305
    old_cs= collation.collation->name;
6343
6306
    old_derivation= collation.derivation_name();
6344
6307
    if (collation.aggregate(item->collation, MY_COLL_ALLOW_CONV))
6373
6336
      int delta1= max_length_orig - decimals_orig;
6374
6337
      int delta2= item->max_length - item->decimals;
6375
6338
      max_length= max(delta1, delta2) + decimals;
6376
 
      if (fld_type == MYSQL_TYPE_DOUBLE && max_length > DBL_DIG + 2) 
 
6339
      if (fld_type == DRIZZLE_TYPE_DOUBLE && max_length > DBL_DIG + 2) 
6377
6340
      {
6378
6341
        max_length= DBL_DIG + 7;
6379
6342
        decimals= NOT_FIXED_DEC;
6403
6366
    length
6404
6367
*/
6405
6368
 
6406
 
uint32 Item_type_holder::display_length(Item *item)
 
6369
uint32_t Item_type_holder::display_length(Item *item)
6407
6370
{
6408
6371
  if (item->type() == Item::FIELD_ITEM)
6409
6372
    return ((Item_field *)item)->max_disp_length();
6410
6373
 
6411
6374
  switch (item->field_type())
6412
6375
  {
6413
 
  case MYSQL_TYPE_TIMESTAMP:
6414
 
  case MYSQL_TYPE_TIME:
6415
 
  case MYSQL_TYPE_DATETIME:
6416
 
  case MYSQL_TYPE_YEAR:
6417
 
  case MYSQL_TYPE_NEWDATE:
6418
 
  case MYSQL_TYPE_VARCHAR:
6419
 
  case MYSQL_TYPE_NEWDECIMAL:
6420
 
  case MYSQL_TYPE_ENUM:
6421
 
  case MYSQL_TYPE_SET:
6422
 
  case MYSQL_TYPE_BLOB:
6423
 
  case MYSQL_TYPE_VAR_STRING:
6424
 
  case MYSQL_TYPE_STRING:
6425
 
  case MYSQL_TYPE_TINY:
 
6376
  case DRIZZLE_TYPE_TIMESTAMP:
 
6377
  case DRIZZLE_TYPE_TIME:
 
6378
  case DRIZZLE_TYPE_DATETIME:
 
6379
  case DRIZZLE_TYPE_NEWDATE:
 
6380
  case DRIZZLE_TYPE_VARCHAR:
 
6381
  case DRIZZLE_TYPE_NEWDECIMAL:
 
6382
  case DRIZZLE_TYPE_ENUM:
 
6383
  case DRIZZLE_TYPE_SET:
 
6384
  case DRIZZLE_TYPE_BLOB:
 
6385
  case DRIZZLE_TYPE_VAR_STRING:
 
6386
  case DRIZZLE_TYPE_STRING:
 
6387
  case DRIZZLE_TYPE_TINY:
6426
6388
    return 4;
6427
 
  case MYSQL_TYPE_SHORT:
 
6389
  case DRIZZLE_TYPE_SHORT:
6428
6390
    return 6;
6429
 
  case MYSQL_TYPE_LONG:
 
6391
  case DRIZZLE_TYPE_LONG:
6430
6392
    return MY_INT32_NUM_DECIMAL_DIGITS;
6431
 
  case MYSQL_TYPE_DOUBLE:
 
6393
  case DRIZZLE_TYPE_DOUBLE:
6432
6394
    return 53;
6433
 
  case MYSQL_TYPE_NULL:
 
6395
  case DRIZZLE_TYPE_NULL:
6434
6396
    return 0;
6435
 
  case MYSQL_TYPE_LONGLONG:
 
6397
  case DRIZZLE_TYPE_LONGLONG:
6436
6398
    return 20;
6437
6399
  default:
6438
6400
    assert(0); // we should never go there
6460
6422
  Field *field;
6461
6423
 
6462
6424
  switch (fld_type) {
6463
 
  case MYSQL_TYPE_ENUM:
 
6425
  case DRIZZLE_TYPE_ENUM:
6464
6426
    assert(enum_set_typelib);
6465
6427
    field= new Field_enum((uchar *) 0, max_length, null_ptr, 0,
6466
6428
                          Field::NONE, name,
6469
6431
    if (field)
6470
6432
      field->init(table);
6471
6433
    return field;
6472
 
  case MYSQL_TYPE_SET:
 
6434
  case DRIZZLE_TYPE_SET:
6473
6435
    assert(enum_set_typelib);
6474
6436
    field= new Field_set((uchar *) 0, max_length, null_ptr, 0,
6475
6437
                         Field::NONE, name,
6478
6440
    if (field)
6479
6441
      field->init(table);
6480
6442
    return field;
6481
 
  case MYSQL_TYPE_NULL:
 
6443
  case DRIZZLE_TYPE_NULL:
6482
6444
    return make_string_field(table);
6483
6445
  default:
6484
6446
    break;
6495
6457
*/
6496
6458
void Item_type_holder::get_full_info(Item *item)
6497
6459
{
6498
 
  if (fld_type == MYSQL_TYPE_ENUM ||
6499
 
      fld_type == MYSQL_TYPE_SET)
 
6460
  if (fld_type == DRIZZLE_TYPE_ENUM ||
 
6461
      fld_type == DRIZZLE_TYPE_SET)
6500
6462
  {
6501
6463
    if (item->type() == Item::SUM_FUNC_ITEM &&
6502
6464
        (((Item_sum*)item)->sum_func() == Item_sum::MAX_FUNC ||
6507
6469
      field (or MIN|MAX(enum|set field)) and number of NULL fields
6508
6470
    */
6509
6471
    assert((enum_set_typelib &&
6510
 
                 get_real_type(item) == MYSQL_TYPE_NULL) ||
 
6472
                 get_real_type(item) == DRIZZLE_TYPE_NULL) ||
6511
6473
                (!enum_set_typelib &&
6512
6474
                 item->type() == Item::FIELD_ITEM &&
6513
 
                 (get_real_type(item) == MYSQL_TYPE_ENUM ||
6514
 
                  get_real_type(item) == MYSQL_TYPE_SET) &&
 
6475
                 (get_real_type(item) == DRIZZLE_TYPE_ENUM ||
 
6476
                  get_real_type(item) == DRIZZLE_TYPE_SET) &&
6515
6477
                 ((Field_enum*)((Item_field *) item)->field)->typelib));
6516
6478
    if (!enum_set_typelib)
6517
6479
    {
6560
6522
    do nothing
6561
6523
*/
6562
6524
 
6563
 
void dummy_error_processor(THD *thd __attribute__((__unused__)),
6564
 
                           void *data __attribute__((__unused__)))
 
6525
void dummy_error_processor(THD *thd __attribute__((unused)),
 
6526
                           void *data __attribute__((unused)))
6565
6527
{}
6566
6528
 
6567
6529
/**