« back to all changes in this revision
Viewing changes to drizzled/item.cc
- browse files at revision 575.1.2
- compare with another revision
- compare with revision 48
- download diff
- download tarball
- view history from revision 575.1.2
- Committer: Monty Taylor
- Date: 2008-11-04 13:22:55 UTC
- mto: (575.1.7 fix-headers)
- mto: This revision was merged to the branch mainline in revision 577.
- Revision ID: monty@inaugust.com-20081104132255-l9dhglk4ix6vd3u7
Changed a bunch of __attribute__((unused)) to removing the parameter name instead.
- files modified:
- drizzled/field.cc
added
removed
drizzled/item.cc
49
49
}
50
50
51
51
my_decimal *
52
Hybrid_type_traits::val_decimal(Hybrid_type *val,
53
my_decimal *to __attribute__((unused))) const
52
Hybrid_type_traits::val_decimal(Hybrid_type *val, my_decimal *) const
54
53
{
55
54
double2my_decimal(E_DEC_FATAL_ERROR, val->real, val->dec_buf);
56
55
return val->dec_buf;
153
152
}
154
153
155
154
void
156
Hybrid_type_traits_integer::fix_length_and_dec(Item *item,
157
Item *arg __attribute__((unused))) const
155
Hybrid_type_traits_integer::fix_length_and_dec(Item *item, Item *) const
158
156
{
159
157
item->decimals= 0;
160
158
item->max_length= MY_INT64_NUM_DECIMAL_DIGITS;
479
477
@param arg a dummy parameter, is not used here
480
478
*/
481
479
482
bool Item::cleanup_processor(unsigned char *arg __attribute__((unused)))
480
bool Item::cleanup_processor(unsigned char *)
483
481
{
484
482
if (fixed)
485
483
cleanup();
759
757
- When trying to find an order_st BY/GROUP BY item in the SELECT part
760
758
*/
761
759
762
bool Item::eq(const Item *item, bool binary_cmp __attribute__((unused))) const
760
bool Item::eq(const Item *item, bool) const
763
761
{
764
762
/*
765
763
Note, that this is never true if item is a Item_param:
789
787
the latter returns a non-fixed Item, so val_str() crashes afterwards.
790
788
Override Item_num method, to return a fixed item.
791
789
*/
792
Item *Item_num::safe_charset_converter(const CHARSET_INFO * const tocs __attribute__((unused)))
790
Item *Item_num::safe_charset_converter(const CHARSET_INFO * const)
793
791
{
794
792
Item_string *conv;
795
793
char buf[64];
804
802
}
805
803
806
804
807
Item *Item_static_float_func::safe_charset_converter(const CHARSET_INFO * const tocs __attribute__((unused)))
805
Item *Item_static_float_func::safe_charset_converter(const CHARSET_INFO * const)
808
806
{
809
807
Item_string *conv;
810
808
char buf[64];
1443
1441
Item_field (this is important in prepared statements).
1444
1442
*/
1445
1443
1446
Item_field::Item_field(Session *session __attribute__((unused)),
1447
Name_resolution_context *context_arg,
1444
Item_field::Item_field(Session *, Name_resolution_context *context_arg,
1448
1445
Field *f)
1449
1446
:Item_ident(context_arg, f->table->s->db.str, *f->table_name, f->field_name),
1450
1447
item_equal(0), no_const_subst(0),
1540
1537
}
1541
1538
1542
1539
void Item_ident::print(String *str,
1543
enum_query_type query_type __attribute__((unused)))
1540
enum_query_type)
1544
1541
{
1545
1542
Session *session= current_session;
1546
1543
char d_name_buff[MAX_ALIAS_NAME], t_name_buff[MAX_ALIAS_NAME];
1717
1714
}
1718
1715
1719
1716
1720
bool Item_field::eq(const Item *item,
1721
bool binary_cmp __attribute__((unused))) const
1717
bool Item_field::eq(const Item *item, bool) const
1722
1718
{
1723
1719
Item *real_item= ((Item *) item)->real_item();
1724
1720
if (real_item->type() != FIELD_ITEM)
1756
1752
}
1757
1753
1758
1754
1759
void Item_field::fix_after_pullout(st_select_lex *new_parent,
1760
Item **ref __attribute__((unused)))
1755
void Item_field::fix_after_pullout(st_select_lex *new_parent, Item **)
1761
1756
{
1762
1757
if (new_parent == depended_from)
1763
1758
depended_from= NULL;
1778
1773
return new_item;
1779
1774
}
1780
1775
1781
int64_t Item_field::val_int_endpoint(bool left_endp __attribute__((unused)),
1782
bool *incl_endp __attribute__((unused)))
1776
int64_t Item_field::val_int_endpoint(bool, bool *)
1783
1777
{
1784
1778
int64_t res= val_int();
1785
1779
return null_value? INT64_MIN : res;
1816
1810
return str;
1817
1811
}
1818
1812
1819
void Item_int::print(String *str,
1820
enum_query_type query_type __attribute__((unused)))
1813
void Item_int::print(String *str, enum_query_type)
1821
1814
{
1822
1815
// my_charset_bin is good enough for numbers
1823
1816
str_value.set(value, &my_charset_bin);
1848
1841
}
1849
1842
1850
1843
1851
void Item_uint::print(String *str,
1852
enum_query_type query_type __attribute__((unused)))
1844
void Item_uint::print(String *str, enum_query_type)
1853
1845
{
1854
1846
// latin1 is good enough for numbers
1855
1847
str_value.set((uint64_t) value, default_charset());
1878
1870
}
1879
1871
1880
1872
1881
Item_decimal::Item_decimal(double val,
1882
int precision __attribute__((unused)),
1883
int scale __attribute__((unused)))
1873
Item_decimal::Item_decimal(double val, int, int)
1884
1874
{
1885
1875
double2my_decimal(E_DEC_FATAL_ERROR, val, &decimal_value);
1886
1876
decimals= (uint8_t) decimal_value.frac;
1943
1933
return result;
1944
1934
}
1945
1935
1946
void Item_decimal::print(String *str,
1947
enum_query_type query_type __attribute__((unused)))
1936
void Item_decimal::print(String *str, enum_query_type)
1948
1937
{
1949
1938
my_decimal2string(E_DEC_FATAL_ERROR, &decimal_value, 0, 0, 0, &str_value);
1950
1939
str->append(str_value);
1951
1940
}
1952
1941
1953
1942
1954
bool Item_decimal::eq(const Item *item,
1955
bool binary_cmp __attribute__((unused))) const
1943
bool Item_decimal::eq(const Item *item, bool) const
1956
1944
{
1957
1945
if (type() == item->type() && item->basic_const_item())
1958
1946
{
2111
2099
}
2112
2100
2113
2101
2114
bool Item_null::eq(const Item *item,
2115
bool binary_cmp __attribute__((unused))) const
2102
bool Item_null::eq(const Item *item, bool) const
2116
2103
{ return item->type() == type(); }
2117
2104
2118
2105
2131
2118
return 0;
2132
2119
}
2133
2120
/* ARGSUSED */
2134
String *Item_null::val_str(String *str __attribute__((unused)))
2121
String *Item_null::val_str(String *)
2135
2122
{
2136
2123
// following assert is redundant, because fixed=1 assigned in constructor
2137
2124
assert(fixed == 1);
2139
2126
return 0;
2140
2127
}
2141
2128
2142
my_decimal *Item_null::val_decimal(my_decimal *decimal_value __attribute__((unused)))
2129
my_decimal *Item_null::val_decimal(my_decimal *)
2143
2130
{
2144
2131
return 0;
2145
2132
}
2159
2146
*/
2160
2147
2161
2148
static void
2162
default_set_param_func(Item_param *param,
2163
unsigned char **pos __attribute__((unused)),
2164
ulong len __attribute__((unused)))
2149
default_set_param_func(Item_param *param, unsigned char **, ulong)
2165
2150
{
2166
2151
param->set_null();
2167
2152
}
2807
2792
2808
2793
/* End of Item_param related */
2809
2794
2810
void Item_param::print(String *str,
2811
enum_query_type query_type __attribute__((unused)))
2795
void Item_param::print(String *str, enum_query_type)
2812
2796
{
2813
2797
if (state == NO_VALUE)
2814
2798
{
2838
2822
}
2839
2823
2840
2824
/* ARGSUSED */
2841
String *Item_copy_string::val_str(String *str __attribute__((unused)))
2825
String *Item_copy_string::val_str(String *)
2842
2826
{
2843
2827
// Item_copy_string is used without fix_fields call
2844
2828
if (null_value)
2862
2846
*/
2863
2847
2864
2848
/* ARGSUSED */
2865
bool Item::fix_fields(Session *session __attribute__((unused)),
2866
Item **ref __attribute__((unused)))
2849
bool Item::fix_fields(Session *, Item **)
2867
2850
{
2868
2851
2869
2852
// We do not check fields which are fixed during construction
3874
3857
See comments in Arg_comparator::set_compare_func() for details.
3875
3858
*/
3876
3859
3877
bool Item_field::set_no_const_sub(unsigned char *arg __attribute__((unused)))
3860
bool Item_field::set_no_const_sub(unsigned char *)
3878
3861
{
3879
3862
if (field->charset() != &my_charset_bin)
3880
3863
no_const_subst=1;
3907
3890
- this - otherwise.
3908
3891
*/
3909
3892
3910
Item *Item_field::replace_equal_field(unsigned char *arg __attribute__((unused)))
3893
Item *Item_field::replace_equal_field(unsigned char *)
3911
3894
{
3912
3895
if (item_equal)
3913
3896
{
4112
4095
\# Created field
4113
4096
*/
4114
4097
4115
Field *Item::tmp_table_field_from_field_type(Table *table, bool fixed_length __attribute__((unused)))
4098
Field *Item::tmp_table_field_from_field_type(Table *table, bool)
4116
4099
{
4117
4100
/*
4118
4101
The field functions defines a field to be not null if null_ptr is not 0
4329
4312
}
4330
4313
4331
4314
4332
int Item_string::save_in_field(Field *field,
4333
bool no_conversions __attribute__((unused)))
4315
int Item_string::save_in_field(Field *field, bool)
4334
4316
{
4335
4317
String *result;
4336
4318
result=val_str(&str_value);
4345
4327
}
4346
4328
4347
4329
4348
int Item_int::save_in_field(Field *field,
4349
bool no_conversions __attribute__((unused)))
4330
int Item_int::save_in_field(Field *field, bool)
4350
4331
{
4351
4332
int64_t nr=val_int();
4352
4333
if (null_value)
4356
4337
}
4357
4338
4358
4339
4359
int Item_decimal::save_in_field(Field *field,
4360
bool no_conversions __attribute__((unused)))
4340
int Item_decimal::save_in_field(Field *field, bool)
4361
4341
{
4362
4342
field->set_notnull();
4363
4343
return field->store_decimal(&decimal_value);
4364
4344
}
4365
4345
4366
4346
4367
bool Item_int::eq(const Item *arg,
4368
bool binary_cmp __attribute__((unused))) const
4347
bool Item_int::eq(const Item *arg, bool) const
4369
4348
{
4370
4349
/* No need to check for null value as basic constant can't be NULL */
4371
4350
if (arg->basic_const_item() && arg->type() == type())
4451
4430
}
4452
4431
4453
4432
4454
int Item_float::save_in_field(Field *field,
4455
bool no_conversions __attribute__((unused)))
4433
int Item_float::save_in_field(Field *field, bool)
4456
4434
{
4457
4435
double nr= val_real();
4458
4436
if (null_value)
4462
4440
}
4463
4441
4464
4442
4465
void Item_float::print(String *str,
4466
enum_query_type query_type __attribute__((unused)))
4443
void Item_float::print(String *str, enum_query_type)
4467
4444
{
4468
4445
if (presentation)
4469
4446
{
4483
4460
In number context this is a int64_t value.
4484
4461
*/
4485
4462
4486
bool Item_float::eq(const Item *arg,
4487
bool binary_cmp __attribute__((unused))) const
4463
bool Item_float::eq(const Item *arg, bool) const
4488
4464
{
4489
4465
if (arg->basic_const_item() && arg->type() == type())
4490
4466
{
4552
4528
}
4553
4529
4554
4530
4555
int Item_hex_string::save_in_field(Field *field,
4556
bool no_conversions __attribute__((unused)))
4531
int Item_hex_string::save_in_field(Field *field, bool)
4557
4532
{
4558
4533
field->set_notnull();
4559
4534
if (field->result_type() == STRING_RESULT)
4560
return field->store(str_value.ptr(), str_value.length(),
4535
return field->store(str_value.ptr(), str_value.length(),
4561
4536
collation.collation);
4562
4537
4563
4538
uint64_t nr;
4583
4558
}
4584
4559
4585
4560
4586
void Item_hex_string::print(String *str,
4587
enum_query_type query_type __attribute__((unused)))
4561
void Item_hex_string::print(String *str, enum_query_type)
4588
4562
{
4589
4563
char *end= (char*) str_value.ptr() + str_value.length(),
4590
4564
*ptr= end - cmin(str_value.length(), (uint32_t)sizeof(int64_t));
4664
4638
*/
4665
4639
4666
4640
bool Item_null::send(Protocol *protocol,
4667
String *packet __attribute__((unused)))
4641
String *)
4668
4642
{
4669
4643
return protocol->store_null();
4670
4644
}
4743
4717
}
4744
4718
4745
4719
4746
bool Item_field::send(Protocol *protocol,
4747
String *buffer __attribute__((unused)))
4720
bool Item_field::send(Protocol *protocol, String *)
4748
4721
{
4749
4722
return protocol->store(result_field);
4750
4723
}
5490
5463
}
5491
5464
}
5492
5465
5493
void Item_ref::fix_after_pullout(st_select_lex *new_parent,
5494
Item **refptr __attribute__((unused)))
5466
void Item_ref::fix_after_pullout(st_select_lex *new_parent, Item **)
5495
5467
{
5496
5468
if (depended_from == new_parent)
5497
5469
{
5517
5489
false otherwise
5518
5490
*/
5519
5491
5520
bool Item_direct_view_ref::eq(const Item *item,
5521
bool binary_cmp __attribute__((unused))) const
5492
bool Item_direct_view_ref::eq(const Item *item, bool) const
5522
5493
{
5523
5494
if (item->type() == REF_ITEM)
5524
5495
{
5539
5510
}
5540
5511
5541
5512
5542
bool Item_default_value::fix_fields(Session *session,
5543
Item **items __attribute__((unused)))
5513
bool Item_default_value::fix_fields(Session *session, Item **)
5544
5514
{
5545
5515
Item *real_arg;
5546
5516
Item_field *field_arg;
5656
5626
}
5657
5627
5658
5628
5659
bool Item_insert_value::fix_fields(Session *session,
5660
Item **items __attribute__((unused)))
5629
bool Item_insert_value::fix_fields(Session *session, Item **)
5661
5630
{
5662
5631
assert(fixed == 0);
5663
5632
/* We should only check that arg is in first table */
6000
5969
return str;
6001
5970
}
6002
5971
6003
my_decimal *Item_cache_decimal::val_decimal(my_decimal *val __attribute__((unused)))
5972
my_decimal *Item_cache_decimal::val_decimal(my_decimal *)
6004
5973
{
6005
5974
assert(fixed);
6006
5975
return &decimal_value;
6108
6077
}
6109
6078
6110
6079
6111
void Item_cache_row::illegal_method_call(const char *method __attribute__((unused)))
6080
void Item_cache_row::illegal_method_call(const char *)
6112
6081
{
6113
6082
assert(0);
6114
6083
my_error(ER_OPERAND_COLUMNS, MYF(0), 1);
6260
6229
false OK
6261
6230
*/
6262
6231
6263
bool Item_type_holder::join_types(Session *session __attribute__((unused)),
6264
Item *item)
6232
bool Item_type_holder::join_types(Session *, Item *item)
6265
6233
{
6266
6234
uint32_t max_length_orig= max_length;
6267
6235
uint32_t decimals_orig= decimals;
6492
6460
do nothing
6493
6461
*/
6494
6462
6495
void dummy_error_processor(Session *session __attribute__((unused)),
6496
void *data __attribute__((unused)))
6463
void dummy_error_processor(Session *, void *)
6497
6464
{}
6498
6465
6499
6466
/**
Loggerhead is a web-based interface for Breezy
Version: 2.0.1