← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item.h

Merged build changes from Antony.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item.h
166
166
  { val->real/= uint64_t2double(u); }
167
167
 
168
168
  virtual int64_t val_int(Hybrid_type *val,
169
 
                           bool unsigned_flag __attribute__((__unused__))) const
 
169
                           bool unsigned_flag __attribute__((unused))) const
170
170
  { return (int64_t) rint(val->real); }
171
171
  virtual double val_real(Hybrid_type *val) const { return val->real; }
172
172
  virtual my_decimal *val_decimal(Hybrid_type *val, my_decimal *buf) const;
173
 
  virtual String *val_str(Hybrid_type *val, String *buf, uint8 decimals) const;
 
173
  virtual String *val_str(Hybrid_type *val, String *buf, uint8_t decimals) const;
174
174
  static const Hybrid_type_traits *instance();
175
175
  Hybrid_type_traits() {}
176
176
  virtual ~Hybrid_type_traits() {}
192
192
  virtual int64_t val_int(Hybrid_type *val, bool unsigned_flag) const;
193
193
  virtual double val_real(Hybrid_type *val) const;
194
194
  virtual my_decimal *val_decimal(Hybrid_type *val,
195
 
                                  my_decimal *buf __attribute__((__unused__))) const
 
195
                                  my_decimal *buf __attribute__((unused))) const
196
196
  { return &val->dec_buf[val->used_dec_buf_no]; }
197
 
  virtual String *val_str(Hybrid_type *val, String *buf, uint8 decimals) const;
 
197
  virtual String *val_str(Hybrid_type *val, String *buf, uint8_t decimals) const;
198
198
  static const Hybrid_type_traits_decimal *instance();
199
199
  Hybrid_type_traits_decimal() {};
200
200
};
216
216
  { val->integer/= (int64_t) u; }
217
217
 
218
218
  virtual int64_t val_int(Hybrid_type *val,
219
 
                           bool unsigned_flag __attribute__((__unused__))) const
 
219
                           bool unsigned_flag __attribute__((unused))) const
220
220
  { return val->integer; }
221
221
  virtual double val_real(Hybrid_type *val) const
222
222
  { return (double) val->integer; }
223
223
  virtual my_decimal *val_decimal(Hybrid_type *val,
224
 
                                  my_decimal *buf __attribute__((__unused__))) const
 
224
                                  my_decimal *buf __attribute__((unused))) const
225
225
  {
226
226
    int2my_decimal(E_DEC_FATAL_ERROR, val->integer, 0, &val->dec_buf[2]);
227
227
    return &val->dec_buf[2];
228
228
  }
229
229
  virtual String *val_str(Hybrid_type *val, String *buf,
230
 
                          uint8 decimals __attribute__((__unused__))) const
 
230
                          uint8_t decimals __attribute__((unused))) const
231
231
  { buf->set(val->integer, &my_charset_bin); return buf;}
232
232
  static const Hybrid_type_traits_integer *instance();
233
233
  Hybrid_type_traits_integer() {};
434
434
  Item(const Item &);                   /* Prevent use of these */
435
435
  void operator=(Item &);
436
436
  /* Cache of the result of is_expensive(). */
437
 
  int8 is_expensive_cache;
438
 
  virtual bool is_expensive_processor(uchar *arg __attribute__((__unused__)))
 
437
  int8_t is_expensive_cache;
 
438
  virtual bool is_expensive_processor(uchar *arg __attribute__((unused)))
439
439
  { return 0; }
440
440
 
441
441
public:
443
443
  { return sql_alloc(size); }
444
444
  static void *operator new(size_t size, MEM_ROOT *mem_root)
445
445
  { return alloc_root(mem_root, size); }
446
 
  static void operator delete(void *ptr __attribute__((__unused__)),
447
 
                              size_t size __attribute__((__unused__)))
 
446
  static void operator delete(void *ptr __attribute__((unused)),
 
447
                              size_t size __attribute__((unused)))
448
448
  { TRASH(ptr, size); }
449
 
  static void operator delete(void *ptr __attribute__((__unused__)),
450
 
                              MEM_ROOT *mem_root __attribute__((__unused__)))
 
449
  static void operator delete(void *ptr __attribute__((unused)),
 
450
                              MEM_ROOT *mem_root __attribute__((unused)))
451
451
  {}
452
452
 
453
453
  enum Type {FIELD_ITEM= 0, FUNC_ITEM, SUM_FUNC_ITEM, STRING_ITEM,
476
476
  /* Original item name (if it was renamed)*/
477
477
  char * orig_name;
478
478
  Item *next;
479
 
  uint32 max_length;
 
479
  uint32_t max_length;
480
480
  uint name_length;                     /* Length of name */
481
 
  int8 marker;
482
 
  uint8 decimals;
 
481
  int8_t marker;
 
482
  uint8_t decimals;
483
483
  my_bool maybe_null;                   /* If item may be null */
484
484
  my_bool null_value;                   /* if item is null */
485
485
  my_bool unsigned_flag;
520
520
    Fix after some tables has been pulled out. Basically re-calculate all
521
521
    attributes that are dependent on the tables.
522
522
  */
523
 
  virtual void fix_after_pullout(st_select_lex *new_parent __attribute__((__unused__)),
524
 
                                 Item **ref __attribute__((__unused__))) {};
 
523
  virtual void fix_after_pullout(st_select_lex *new_parent __attribute__((unused)),
 
524
                                 Item **ref __attribute__((unused))) {};
525
525
 
526
526
  /*
527
527
    should be used in case where we are sure that we do not need
584
584
        - If the value of the function is NULL then the bound is the
585
585
          smallest possible value of INT64_MIN
586
586
  */
587
 
  virtual int64_t val_int_endpoint(bool left_endp __attribute__((__unused__)),
588
 
                                    bool *incl_endp __attribute__((__unused__)))
 
587
  virtual int64_t val_int_endpoint(bool left_endp __attribute__((unused)),
 
588
                                    bool *incl_endp __attribute__((unused)))
589
589
  { assert(0); return 0; }
590
590
 
591
591
 
698
698
 
699
699
  virtual Field *get_tmp_table_field(void) { return 0; }
700
700
  /* This is also used to create fields in CREATE ... SELECT: */
701
 
  virtual Field *tmp_table_field(TABLE *t_arg __attribute__((__unused__)))
 
701
  virtual Field *tmp_table_field(TABLE *t_arg __attribute__((unused)))
702
702
  { return 0; }
703
703
  virtual const char *full_name(void) const { return name ? name : "???"; }
704
704
 
766
766
    mysql_register_view().
767
767
  */
768
768
  virtual inline void print(String *str,
769
 
                            enum_query_type query_type __attribute__((__unused__)))
 
769
                            enum_query_type query_type __attribute__((unused)))
770
770
  {
771
771
    str->append(full_name());
772
772
  }
773
773
 
774
774
  void print_item_w_name(String *, enum_query_type query_type);
775
775
  virtual void update_used_tables() {}
776
 
  virtual void split_sum_func(THD *thd __attribute__((__unused__)),
777
 
                              Item **ref_pointer_array __attribute__((__unused__)),
778
 
                              List<Item> &fields __attribute__((__unused__))) {}
 
776
  virtual void split_sum_func(THD *thd __attribute__((unused)),
 
777
                              Item **ref_pointer_array __attribute__((unused)),
 
778
                              List<Item> &fields __attribute__((unused))) {}
779
779
  /* Called for items that really have to be split */
780
780
  void split_sum_func2(THD *thd, Item **ref_pointer_array, List<Item> &fields,
781
781
                       Item **ref, bool skip_registered);
812
812
    set field of temporary table for Item which can be switched on temporary
813
813
    table during query processing (grouping and so on)
814
814
  */
815
 
  virtual void set_result_field(Field *field __attribute__((__unused__))) {}
 
815
  virtual void set_result_field(Field *field __attribute__((unused))) {}
816
816
  virtual bool is_result_field(void) { return 0; }
817
817
  virtual bool is_bool_func(void) { return 0; }
818
 
  virtual void save_in_result_field(bool no_conversions __attribute__((__unused__)))
 
818
  virtual void save_in_result_field(bool no_conversions __attribute__((unused)))
819
819
  {}
820
820
  /*
821
821
    set value of aggregate function in case of no rows for grouping were found
822
822
  */
823
823
  virtual void no_rows_in_result(void) {}
824
 
  virtual Item *copy_or_same(THD *thd __attribute__((__unused__)))
 
824
  virtual Item *copy_or_same(THD *thd __attribute__((unused)))
825
825
  { return this; }
826
 
  virtual Item *copy_andor_structure(THD *thd  __attribute__((__unused__)))
 
826
  virtual Item *copy_andor_structure(THD *thd  __attribute__((unused)))
827
827
  { return this; }
828
828
  virtual Item *real_item(void) { return this; }
829
829
  virtual Item *get_tmp_table_item(THD *thd) { return copy_or_same(thd); }
831
831
  static CHARSET_INFO *default_charset();
832
832
  virtual CHARSET_INFO *compare_collation() { return NULL; }
833
833
 
834
 
  virtual bool walk(Item_processor processor __attribute__((__unused__)),
835
 
                    bool walk_subquery __attribute__((__unused__)),
 
834
  virtual bool walk(Item_processor processor __attribute__((unused)),
 
835
                    bool walk_subquery __attribute__((unused)),
836
836
                    uchar *arg)
837
837
  {
838
838
    return (this->*processor)(arg);
864
864
    return 0;
865
865
  }
866
866
 
867
 
   virtual void traverse_cond(Cond_traverser traverser __attribute__((__unused__)),
 
867
   virtual void traverse_cond(Cond_traverser traverser __attribute__((unused)),
868
868
                              void *arg,
869
 
                              traverse_order order __attribute__((__unused__)))
 
869
                              traverse_order order __attribute__((unused)))
870
870
   {
871
871
     (*traverser)(this, arg);
872
872
   }
873
873
 
874
 
  virtual bool remove_dependence_processor(uchar * arg __attribute__((__unused__)))
 
874
  virtual bool remove_dependence_processor(uchar * arg __attribute__((unused)))
875
875
  { return 0; }
876
 
  virtual bool remove_fixed(uchar * arg __attribute__((__unused__)))
 
876
  virtual bool remove_fixed(uchar * arg __attribute__((unused)))
877
877
  {
878
878
    fixed= 0;
879
879
    return 0;
880
880
  }
881
 
  virtual bool cleanup_processor(uchar *arg __attribute__((__unused__)));
882
 
  virtual bool collect_item_field_processor(uchar * arg __attribute__((__unused__)))
 
881
  virtual bool cleanup_processor(uchar *arg __attribute__((unused)));
 
882
  virtual bool collect_item_field_processor(uchar * arg __attribute__((unused)))
883
883
  { return 0; }
884
 
  virtual bool find_item_in_field_list_processor(uchar *arg __attribute__((__unused__)))
 
884
  virtual bool find_item_in_field_list_processor(uchar *arg __attribute__((unused)))
885
885
 { return 0; }
886
 
  virtual bool change_context_processor(uchar *context __attribute__((__unused__)))
887
 
  { return 0; }
888
 
  virtual bool reset_query_id_processor(uchar *query_id_arg __attribute__((__unused__)))
889
 
  { return 0; }
890
 
  virtual bool register_field_in_read_map(uchar *arg __attribute__((__unused__)))
 
886
  virtual bool change_context_processor(uchar *context __attribute__((unused)))
 
887
  { return 0; }
 
888
  virtual bool reset_query_id_processor(uchar *query_id_arg __attribute__((unused)))
 
889
  { return 0; }
 
890
  virtual bool register_field_in_read_map(uchar *arg __attribute__((unused)))
891
891
  { return 0; }
892
892
  virtual bool subst_argument_checker(uchar **arg)
893
893
  {
896
896
    return true;
897
897
  }
898
898
 
899
 
  virtual Item *equal_fields_propagator(uchar * arg __attribute__((__unused__))) { return this; }
900
 
  virtual bool set_no_const_sub(uchar *arg __attribute__((__unused__))) { return false; }
901
 
  virtual Item *replace_equal_field(uchar * arg __attribute__((__unused__))) { return this; }
 
899
  virtual Item *equal_fields_propagator(uchar * arg __attribute__((unused))) { return this; }
 
900
  virtual bool set_no_const_sub(uchar *arg __attribute__((unused))) { return false; }
 
901
  virtual Item *replace_equal_field(uchar * arg __attribute__((unused))) { return this; }
902
902
 
903
903
  /*
904
904
    For SP local variable returns pointer to Item representing its
911
911
    For SP local variable returns address of pointer to Item representing its
912
912
    current value and pointer passed via parameter otherwise.
913
913
  */
914
 
  virtual Item **this_item_addr(THD *thd __attribute__((__unused__)), Item **addr_arg) { return addr_arg; }
 
914
  virtual Item **this_item_addr(THD *thd __attribute__((unused)), Item **addr_arg) { return addr_arg; }
915
915
 
916
916
  // Row emulation
917
917
  virtual uint cols() { return 1; }
918
 
  virtual Item* element_index(uint i __attribute__((__unused__))) { return this; }
919
 
  virtual Item** addr(uint i __attribute__((__unused__))) { return 0; }
 
918
  virtual Item* element_index(uint i __attribute__((unused))) { return this; }
 
919
  virtual Item** addr(uint i __attribute__((unused))) { return 0; }
920
920
  virtual bool check_cols(uint c);
921
921
  // It is not row => null inside is impossible
922
922
  virtual bool null_inside() { return 0; }
926
926
  Field *tmp_table_field_from_field_type(TABLE *table, bool fixed_length);
927
927
  virtual Item_field *filed_for_view_update() { return 0; }
928
928
 
929
 
  virtual Item *neg_transformer(THD *thd __attribute__((__unused__))) { return NULL; }
930
 
  virtual Item *update_value_transformer(uchar *select_arg __attribute__((__unused__))) { return this; }
 
929
  virtual Item *neg_transformer(THD *thd __attribute__((unused))) { return NULL; }
 
930
  virtual Item *update_value_transformer(uchar *select_arg __attribute__((unused))) { return this; }
931
931
  virtual Item *safe_charset_converter(CHARSET_INFO *tocs);
932
932
  void delete_self()
933
933
  {
1146
1146
  }
1147
1147
  int64_t val_int_endpoint(bool left_endp, bool *incl_endp);
1148
1148
  Field *get_tmp_table_field() { return result_field; }
1149
 
  Field *tmp_table_field(TABLE *t_arg __attribute__((__unused__))) { return result_field; }
 
1149
  Field *tmp_table_field(TABLE *t_arg __attribute__((unused))) { return result_field; }
1150
1150
  bool get_date(MYSQL_TIME *ltime,uint fuzzydate);
1151
1151
  bool get_date_result(MYSQL_TIME *ltime,uint fuzzydate);
1152
1152
  bool get_time(MYSQL_TIME *ltime);
1166
1166
  Item *equal_fields_propagator(uchar *arg);
1167
1167
  bool set_no_const_sub(uchar *arg);
1168
1168
  Item *replace_equal_field(uchar *arg);
1169
 
  inline uint32 max_disp_length() { return field->max_display_length(); }
 
1169
  inline uint32_t max_disp_length() { return field->max_display_length(); }
1170
1170
  Item_field *filed_for_view_update() { return this; }
1171
1171
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1172
1172
  int fix_outer_field(THD *thd, Field **field, Item **reference);
1199
1199
  int save_safe_in_field(Field *field);
1200
1200
  bool send(Protocol *protocol, String *str);
1201
1201
  enum Item_result result_type () const { return STRING_RESULT; }
1202
 
  enum_field_types field_type() const   { return MYSQL_TYPE_NULL; }
 
1202
  enum_field_types field_type() const   { return DRIZZLE_TYPE_NULL; }
1203
1203
  bool basic_const_item() const { return 1; }
1204
1204
  Item *clone_item() { return new Item_null(name); }
1205
1205
  bool is_null() { return 1; }
1206
1206
 
1207
1207
  virtual inline void print(String *str,
1208
 
                            enum_query_type query_type __attribute__((__unused__)))
 
1208
                            enum_query_type query_type __attribute__((unused)))
1209
1209
  {
1210
1210
    str->append(STRING_WITH_LEN("NULL"));
1211
1211
  }
1286
1286
    Used when this item is used in a temporary table.
1287
1287
    This is NOT placeholder metadata sent to client, as this value
1288
1288
    is assigned after sending metadata (in setup_one_conversion_function).
1289
 
    For example in case of 'SELECT ?' you'll get MYSQL_TYPE_STRING both
 
1289
    For example in case of 'SELECT ?' you'll get DRIZZLE_TYPE_STRING both
1290
1290
    in result set and placeholders metadata, no matter what type you will
1291
1291
    supply for this placeholder in mysql_stmt_execute.
1292
1292
  */
1312
1312
  int  save_in_field(Field *field, bool no_conversions);
1313
1313
 
1314
1314
  void set_null();
1315
 
  void set_int(int64_t i, uint32 max_length_arg);
 
1315
  void set_int(int64_t i, uint32_t max_length_arg);
1316
1316
  void set_double(double i);
1317
1317
  void set_decimal(const char *str, ulong length);
1318
1318
  bool set_str(const char *str, ulong length);
1319
1319
  bool set_longdata(const char *str, ulong length);
1320
 
  void set_time(MYSQL_TIME *tm, timestamp_type type, uint32 max_length_arg);
 
1320
  void set_time(MYSQL_TIME *tm, timestamp_type type, uint32_t max_length_arg);
1321
1321
  bool set_from_user_var(THD *thd, const user_var_entry *entry);
1322
1322
  void reset();
1323
1323
  /*
1370
1370
{
1371
1371
public:
1372
1372
  int64_t value;
1373
 
  Item_int(int32 i,uint length= MY_INT32_NUM_DECIMAL_DIGITS)
 
1373
  Item_int(int32_t i,uint length= MY_INT32_NUM_DECIMAL_DIGITS)
1374
1374
    :value((int64_t) i)
1375
1375
    { max_length=length; fixed= 1; }
1376
1376
  Item_int(int64_t i,uint length= MY_INT64_NUM_DECIMAL_DIGITS)
1384
1384
  Item_int(const char *str_arg, uint length=64);
1385
1385
  enum Type type() const { return INT_ITEM; }
1386
1386
  enum Item_result result_type () const { return INT_RESULT; }
1387
 
  enum_field_types field_type() const { return MYSQL_TYPE_LONGLONG; }
 
1387
  enum_field_types field_type() const { return DRIZZLE_TYPE_LONGLONG; }
1388
1388
  int64_t val_int() { assert(fixed == 1); return value; }
1389
1389
  double val_real() { assert(fixed == 1); return (double) value; }
1390
1390
  my_decimal *val_decimal(my_decimal *);
1433
1433
 
1434
1434
  enum Type type() const { return DECIMAL_ITEM; }
1435
1435
  enum Item_result result_type () const { return DECIMAL_RESULT; }
1436
 
  enum_field_types field_type() const { return MYSQL_TYPE_NEWDECIMAL; }
 
1436
  enum_field_types field_type() const { return DRIZZLE_TYPE_NEWDECIMAL; }
1437
1437
  int64_t val_int();
1438
1438
  double val_real();
1439
1439
  String *val_str(String*);
1440
 
  my_decimal *val_decimal(my_decimal *val __attribute__((__unused__)))
 
1440
  my_decimal *val_decimal(my_decimal *val __attribute__((unused)))
1441
1441
  { return &decimal_value; }
1442
1442
  int save_in_field(Field *field, bool no_conversions);
1443
1443
  bool basic_const_item() const { return 1; }
1469
1469
    :value(val_arg)
1470
1470
  {
1471
1471
    presentation= name=(char*) str;
1472
 
    decimals=(uint8) decimal_par;
 
1472
    decimals=(uint8_t) decimal_par;
1473
1473
    max_length=length;
1474
1474
    fixed= 1;
1475
1475
  }
1476
1476
  Item_float(double value_par, uint decimal_par) :presentation(0), value(value_par)
1477
1477
  {
1478
 
    decimals= (uint8) decimal_par;
 
1478
    decimals= (uint8_t) decimal_par;
1479
1479
    fixed= 1;
1480
1480
  }
1481
1481
  int save_in_field(Field *field, bool no_conversions);
1482
1482
  enum Type type() const { return REAL_ITEM; }
1483
 
  enum_field_types field_type() const { return MYSQL_TYPE_DOUBLE; }
 
1483
  enum_field_types field_type() const { return DRIZZLE_TYPE_DOUBLE; }
1484
1484
  double val_real() { assert(fixed == 1); return value; }
1485
1485
  int64_t val_int()
1486
1486
  {
1516
1516
  {}
1517
1517
 
1518
1518
  virtual inline void print(String *str,
1519
 
                            enum_query_type query_type __attribute__((__unused__)))
 
1519
                            enum_query_type query_type __attribute__((unused)))
1520
1520
  {
1521
1521
    str->append(func_name);
1522
1522
  }
1597
1597
  my_decimal *val_decimal(my_decimal *);
1598
1598
  int save_in_field(Field *field, bool no_conversions);
1599
1599
  enum Item_result result_type () const { return STRING_RESULT; }
1600
 
  enum_field_types field_type() const { return MYSQL_TYPE_VARCHAR; }
 
1600
  enum_field_types field_type() const { return DRIZZLE_TYPE_VARCHAR; }
1601
1601
  bool basic_const_item() const { return 1; }
1602
1602
  bool eq(const Item *item, bool binary_cmp) const;
1603
1603
  Item *clone_item() 
1669
1669
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1670
1670
 
1671
1671
  virtual inline void print(String *str,
1672
 
                            enum_query_type query_type __attribute__((__unused__)))
 
1672
                            enum_query_type query_type __attribute__((unused)))
1673
1673
  {
1674
1674
    str->append(func_name);
1675
1675
  }
1696
1696
    Item_string(name, length, &my_charset_bin)
1697
1697
  { max_length= length; }
1698
1698
  enum Type type() const { return TYPE_HOLDER; }
1699
 
  enum_field_types field_type() const { return MYSQL_TYPE_BLOB; }
 
1699
  enum_field_types field_type() const { return DRIZZLE_TYPE_BLOB; }
1700
1700
};
1701
1701
 
1702
1702
 
1748
1748
  int save_in_field(Field *field, bool no_conversions);
1749
1749
  enum Item_result result_type () const { return STRING_RESULT; }
1750
1750
  enum Item_result cast_to_int_type() const { return INT_RESULT; }
1751
 
  enum_field_types field_type() const { return MYSQL_TYPE_VARCHAR; }
 
1751
  enum_field_types field_type() const { return DRIZZLE_TYPE_VARCHAR; }
1752
1752
  virtual void print(String *str, enum_query_type query_type);
1753
1753
  bool eq(const Item *item, bool binary_cmp) const;
1754
1754
  virtual Item *safe_charset_converter(CHARSET_INFO *tocs);
1772
1772
  {}
1773
1773
  ~Item_result_field() {}                       /* Required with gcc 2.95 */
1774
1774
  Field *get_tmp_table_field() { return result_field; }
1775
 
  Field *tmp_table_field(TABLE *t_arg __attribute__((__unused__)))
 
1775
  Field *tmp_table_field(TABLE *t_arg __attribute__((unused)))
1776
1776
  { return result_field; }
1777
1777
  table_map used_tables() const { return 1; }
1778
1778
  virtual void fix_length_and_dec()=0;
2006
2006
                     alias_name_used_arg),
2007
2007
    outer_ref(0), in_sum_func(0), found_in_select_list(1)
2008
2008
  {}
2009
 
  void save_in_result_field(bool no_conversions __attribute__((__unused__)))
 
2009
  void save_in_result_field(bool no_conversions __attribute__((unused)))
2010
2010
  {
2011
2011
    outer_ref->save_org_in_field(result_field);
2012
2012
  }
2132
2132
  void make_field(Send_field *field) { item->make_field(field); }
2133
2133
  void copy();
2134
2134
  int save_in_field(Field *field,
2135
 
                    bool no_conversions __attribute__((__unused__)))
 
2135
                    bool no_conversions __attribute__((unused)))
2136
2136
  {
2137
2137
    return save_str_value_in_field(field, &str_value);
2138
2138
  }
2288
2288
  enum enum_field_types cached_field_type;
2289
2289
public:
2290
2290
  Item_cache(): 
2291
 
    example(0), used_table_map(0), cached_field(0), cached_field_type(MYSQL_TYPE_STRING) 
 
2291
    example(0), used_table_map(0), cached_field(0), cached_field_type(DRIZZLE_TYPE_STRING) 
2292
2292
  {
2293
2293
    fixed= 1; 
2294
2294
    null_value= 1;
2302
2302
 
2303
2303
  void set_used_tables(table_map map) { used_table_map= map; }
2304
2304
 
2305
 
  virtual bool allocate(uint i __attribute__((__unused__)))
 
2305
  virtual bool allocate(uint i __attribute__((unused)))
2306
2306
  { return 0; }
2307
2307
  virtual bool setup(Item *item)
2308
2308
  {
2327
2327
    return cached_field ? cached_field->eq_def (field) : false;
2328
2328
  }
2329
2329
  bool eq(const Item *item,
2330
 
          bool binary_cmp __attribute__((__unused__))) const
 
2330
          bool binary_cmp __attribute__((unused))) const
2331
2331
  {
2332
2332
    return this == item;
2333
2333
  }
2396
2396
    Item_cache(), value(0),
2397
2397
    is_varbinary(item->type() == FIELD_ITEM &&
2398
2398
                 ((const Item_field *) item)->field->type() ==
2399
 
                   MYSQL_TYPE_VARCHAR &&
 
2399
                   DRIZZLE_TYPE_VARCHAR &&
2400
2400
                 !((const Item_field *) item)->field->has_charset())
2401
2401
  {}
2402
2402
  void store(Item *item);
2449
2449
    illegal_method_call((const char*)"val_str");
2450
2450
    return 0;
2451
2451
  };
2452
 
  my_decimal *val_decimal(my_decimal *val __attribute__((__unused__)))
 
2452
  my_decimal *val_decimal(my_decimal *val __attribute__((unused)))
2453
2453
  {
2454
2454
    illegal_method_call((const char*)"val_decimal");
2455
2455
    return 0;
2468
2468
  {
2469
2469
    Item_cache::cleanup();
2470
2470
    if (save_array)
2471
 
      bzero(values, item_count*sizeof(Item**));
 
2471
      memset(values, 0, item_count*sizeof(Item**));
2472
2472
    else
2473
2473
      values= 0;
2474
2474
    return;
2505
2505
  String *val_str(String*);
2506
2506
  bool join_types(THD *thd, Item *);
2507
2507
  Field *make_field_by_type(TABLE *table);
2508
 
  static uint32 display_length(Item *item);
 
2508
  static uint32_t display_length(Item *item);
2509
2509
  static enum_field_types get_real_type(Item *);
2510
2510
};
2511
2511