~drizzle-trunk/drizzle/development : revision 577

49

}

50

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

/**