/*

Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved.

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; version 2 of the License.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */

#include "my_global.h" /* NO_EMBEDDED_ACCESS_CHECKS */

#include "sql_priv.h"

#include "unireg.h" // REQUIRED: for other includes

#include <mysql.h>

#include <m_ctype.h>

#include "my_dir.h"

#include "sp_rcontext.h"

#include "sp_head.h" // sp_prepare_func_item

#include "sp.h" // sp_map_item_type

#include "sql_trigger.h"

#include "sql_select.h"

#include "sql_show.h" // append_identifier

#include "sql_view.h" // VIEW_ANY_SQL

#include "sql_time.h" // str_to_datetime_with_warn,

// make_truncated_value_warning

#include "sql_acl.h" // get_column_grant,

// SELECT_ACL, UPDATE_ACL,

// INSERT_ACL,

// check_grant_column

#include "sql_base.h" // enum_resolution_type,

// REPORT_EXCEPT_NOT_FOUND,

// find_item_in_list,

// RESOLVED_AGAINST_ALIAS, ...

#include "log_event.h" // append_query_string

#include "sql_test.h" // print_where

#include "sql_optimizer.h" // JOIN

using std::min;

using std::max;

const String my_null_string("NULL", 4, default_charset_info);

/****************************************************************************/

/* Hybrid_type_traits {_real} */

void Hybrid_type_traits::fix_length_and_dec(Item *item, Item *arg) const

{

item->decimals= NOT_FIXED_DEC;

item->max_length= item->float_length(arg->decimals);

}

static const Hybrid_type_traits real_traits_instance;

const Hybrid_type_traits *Hybrid_type_traits::instance()

{

return &real_traits_instance;

}

my_decimal *

Hybrid_type_traits::val_decimal(Hybrid_type *val, my_decimal *to) const

{

double2my_decimal(E_DEC_FATAL_ERROR, val->real, val->dec_buf);

return val->dec_buf;

}

String *

Hybrid_type_traits::val_str(Hybrid_type *val, String *to, uint8 decimals) const

{

to->set_real(val->real, decimals, &my_charset_bin);

return to;

}

/* Hybrid_type_traits_decimal */

static const Hybrid_type_traits_decimal decimal_traits_instance;

const Hybrid_type_traits_decimal *Hybrid_type_traits_decimal::instance()

{

return &decimal_traits_instance;

}

void

Hybrid_type_traits_decimal::fix_length_and_dec(Item *item, Item *arg) const

{

item->decimals= arg->decimals;

item->max_length= min<uint32>(arg->max_length + DECIMAL_LONGLONG_DIGITS,

DECIMAL_MAX_STR_LENGTH);

}

void Hybrid_type_traits_decimal::set_zero(Hybrid_type *val) const

{

my_decimal_set_zero(&val->dec_buf[0]);

val->used_dec_buf_no= 0;

}

void Hybrid_type_traits_decimal::add(Hybrid_type *val, Field *f) const

{

my_decimal_add(E_DEC_FATAL_ERROR,

&val->dec_buf[val->used_dec_buf_no ^ 1],

&val->dec_buf[val->used_dec_buf_no],

f->val_decimal(&val->dec_buf[2]));

val->used_dec_buf_no^= 1;

}

/**

@todo

what is '4' for scale?

*/

void Hybrid_type_traits_decimal::div(Hybrid_type *val, ulonglong u) const

{

int2my_decimal(E_DEC_FATAL_ERROR, u, TRUE, &val->dec_buf[2]);

/* XXX: what is '4' for scale? */

my_decimal_div(E_DEC_FATAL_ERROR,

&val->dec_buf[val->used_dec_buf_no ^ 1],

&val->dec_buf[val->used_dec_buf_no],

&val->dec_buf[2], 4);

val->used_dec_buf_no^= 1;

}

longlong

Hybrid_type_traits_decimal::val_int(Hybrid_type *val, bool unsigned_flag) const

{

longlong result;

my_decimal2int(E_DEC_FATAL_ERROR, &val->dec_buf[val->used_dec_buf_no],

unsigned_flag, &result);

return result;

}

double

Hybrid_type_traits_decimal::val_real(Hybrid_type *val) const

{

my_decimal2double(E_DEC_FATAL_ERROR, &val->dec_buf[val->used_dec_buf_no],

&val->real);

return val->real;

}

String *

Hybrid_type_traits_decimal::val_str(Hybrid_type *val, String *to,

uint8 decimals) const

{

my_decimal_round(E_DEC_FATAL_ERROR, &val->dec_buf[val->used_dec_buf_no],

decimals, FALSE, &val->dec_buf[2]);

my_decimal2string(E_DEC_FATAL_ERROR, &val->dec_buf[2], 0, 0, 0, to);

return to;

}

/* Hybrid_type_traits_integer */

static const Hybrid_type_traits_integer integer_traits_instance;

const Hybrid_type_traits_integer *Hybrid_type_traits_integer::instance()

{

return &integer_traits_instance;

}

void

Hybrid_type_traits_integer::fix_length_and_dec(Item *item, Item *arg) const

{

item->decimals= 0;

item->max_length= MY_INT64_NUM_DECIMAL_DIGITS;

item->unsigned_flag= 0;

}

/*****************************************************************************

** Item functions

*****************************************************************************/

/**

Init all special items.

*/

void item_init(void)

{

item_user_lock_init();

uuid_short_init();

}

/**

@todo

Make this functions class dependent

*/

bool Item::val_bool()

{

switch(result_type()) {

case INT_RESULT:

return val_int() != 0;

case DECIMAL_RESULT:

{

my_decimal decimal_value;

my_decimal *val= val_decimal(&decimal_value);

if (val)

return !my_decimal_is_zero(val);

return 0;

}

case REAL_RESULT:

case STRING_RESULT:

return val_real() != 0.0;

case ROW_RESULT:

default:

DBUG_ASSERT(0);

return 0; // Wrong (but safe)

}

}

/*

For the items which don't have its own fast val_str_ascii()

implementation we provide a generic slower version,

which converts from the Item character set to ASCII.

For better performance conversion happens only in

case of a "tricky" Item character set (e.g. UCS2).

Normally conversion does not happen.

*/

String *Item::val_str_ascii(String *str)

{

if (!(collation.collation->state & MY_CS_NONASCII))

return val_str(str);

DBUG_ASSERT(str != &str_value);

uint errors;

String *res= val_str(&str_value);

if (!res)

return 0;

if ((null_value= str->copy(res->ptr(), res->length(),

collation.collation, &my_charset_latin1,

&errors)))

return 0;

return str;

}

String *Item::val_string_from_real(String *str)

{

double nr= val_real();

if (null_value)

return 0; /* purecov: inspected */

str->set_real(nr,decimals, &my_charset_bin);

return str;

}

String *Item::val_string_from_int(String *str)

{

longlong nr= val_int();

if (null_value)

return 0;

str->set_int(nr, unsigned_flag, &my_charset_bin);

return str;

}

String *Item::val_string_from_decimal(String *str)

{

my_decimal dec_buf, *dec= val_decimal(&dec_buf);

if (null_value)

return 0;

my_decimal_round(E_DEC_FATAL_ERROR, dec, decimals, FALSE, &dec_buf);

my_decimal2string(E_DEC_FATAL_ERROR, &dec_buf, 0, 0, 0, str);

return str;

}

String *Item::val_string_from_datetime(String *str)

{

DBUG_ASSERT(fixed == 1);

MYSQL_TIME ltime;

if (get_date(&ltime, TIME_FUZZY_DATE) ||

(null_value= str->alloc(MAX_DATE_STRING_REP_LENGTH)))

return (String *) 0;

make_datetime((DATE_TIME_FORMAT *) 0, &ltime, str, decimals);

return str;

}

String *Item::val_string_from_date(String *str)

{

DBUG_ASSERT(fixed == 1);

MYSQL_TIME ltime;

if (get_date(&ltime, TIME_FUZZY_DATE) ||

(null_value= str->alloc(MAX_DATE_STRING_REP_LENGTH)))

return (String *) 0;

make_date((DATE_TIME_FORMAT *) 0, &ltime, str);

return str;

}

String *Item::val_string_from_time(String *str)

{

DBUG_ASSERT(fixed == 1);

MYSQL_TIME ltime;

if (get_time(&ltime) || (null_value= str->alloc(MAX_DATE_STRING_REP_LENGTH)))

return (String *) 0;

make_time((DATE_TIME_FORMAT *) 0, &ltime, str, decimals);

return str;

}

my_decimal *Item::val_decimal_from_real(my_decimal *decimal_value)

{

double nr= val_real();

if (null_value)

return 0;

double2my_decimal(E_DEC_FATAL_ERROR, nr, decimal_value);

return (decimal_value);

}

my_decimal *Item::val_decimal_from_int(my_decimal *decimal_value)

{

longlong nr= val_int();

if (null_value)

return 0;

int2my_decimal(E_DEC_FATAL_ERROR, nr, unsigned_flag, decimal_value);

return decimal_value;

}

my_decimal *Item::val_decimal_from_string(my_decimal *decimal_value)

{

String *res;

if (!(res= val_str(&str_value)))

return NULL;

if (str2my_decimal(E_DEC_FATAL_ERROR & ~E_DEC_BAD_NUM,

res->ptr(), res->length(), res->charset(),

decimal_value) & E_DEC_BAD_NUM)

{

ErrConvString err(res);

push_warning_printf(current_thd, Sql_condition::WARN_LEVEL_WARN,

ER_TRUNCATED_WRONG_VALUE,

ER(ER_TRUNCATED_WRONG_VALUE), "DECIMAL",

err.ptr());

}

return decimal_value;

}

my_decimal *Item::val_decimal_from_date(my_decimal *decimal_value)

{

DBUG_ASSERT(fixed == 1);

MYSQL_TIME ltime;

if (get_date(&ltime, TIME_FUZZY_DATE))

{

my_decimal_set_zero(decimal_value);

null_value= 1; // set NULL, stop processing

return 0;

}

return date2my_decimal(&ltime, decimal_value);

}

my_decimal *Item::val_decimal_from_time(my_decimal *decimal_value)

{

DBUG_ASSERT(fixed == 1);

MYSQL_TIME ltime;

if (get_time(&ltime))

{

my_decimal_set_zero(decimal_value);

null_value= 1;

return 0;

}

return date2my_decimal(&ltime, decimal_value);

}

longlong Item::val_time_temporal()

{

MYSQL_TIME ltime;

if ((null_value= get_time(&ltime)))

return 0;

return TIME_to_longlong_time_packed(&ltime);

}

longlong Item::val_date_temporal()

{

MYSQL_TIME ltime;

longlong flags= (TIME_FUZZY_DATE | MODE_INVALID_DATES |

(current_thd->variables.sql_mode &

(MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE)));

if ((null_value= get_date(&ltime, flags)))

return 0;

return TIME_to_longlong_datetime_packed(&ltime);

}

// TS-TODO: split into separate methods?

longlong Item::val_temporal_with_round(enum_field_types type, uint8 dec)

{

longlong nr= val_temporal_by_field_type();

longlong diff= my_time_fraction_remainder(MY_PACKED_TIME_GET_FRAC_PART(nr),

dec);

longlong abs_diff= diff > 0 ? diff : - diff;

if (abs_diff * 2 >= (int) log_10_int[DATETIME_MAX_DECIMALS - dec])

{

/* Needs rounding */

switch (type)

{

case MYSQL_TYPE_TIME:

{

MYSQL_TIME ltime;

TIME_from_longlong_time_packed(&ltime, nr);

return my_time_round(&ltime, dec) ?

0 : TIME_to_longlong_time_packed(&ltime);

}

case MYSQL_TYPE_TIMESTAMP:

case MYSQL_TYPE_DATETIME:

{

MYSQL_TIME ltime;

int warnings= 0;

TIME_from_longlong_datetime_packed(&ltime, nr);

return my_datetime_round(&ltime, dec, &warnings) ?

0 : TIME_to_longlong_datetime_packed(&ltime);

return nr;

}

default:

DBUG_ASSERT(0);

break;

}

}

/* Does not need rounding, do simple truncation. */

nr-= diff;

return nr;

}

double Item::val_real_from_decimal()

{

/* Note that fix_fields may not be called for Item_avg_field items */

double result;

my_decimal value_buff, *dec_val= val_decimal(&value_buff);

if (null_value)

return 0.0;

my_decimal2double(E_DEC_FATAL_ERROR, dec_val, &result);

return result;

}

longlong Item::val_int_from_decimal()

{

/* Note that fix_fields may not be called for Item_avg_field items */

longlong result;

my_decimal value, *dec_val= val_decimal(&value);

if (null_value)

return 0;

my_decimal2int(E_DEC_FATAL_ERROR, dec_val, unsigned_flag, &result);

return result;

}

longlong Item::val_int_from_time()

{

DBUG_ASSERT(fixed == 1);

MYSQL_TIME ltime;

return get_time(&ltime) ?

0LL : (ltime.neg ? -1 : 1) * TIME_to_ulonglong_time_round(&ltime);

}

longlong Item::val_int_from_date()

{

DBUG_ASSERT(fixed == 1);

MYSQL_TIME ltime;

return get_date(&ltime, TIME_FUZZY_DATE) ?

0LL : (longlong) TIME_to_ulonglong_date(&ltime);

}

longlong Item::val_int_from_datetime()

{

DBUG_ASSERT(fixed == 1);

MYSQL_TIME ltime;

return get_date(&ltime, TIME_FUZZY_DATE) ?

0LL: (longlong) TIME_to_ulonglong_datetime_round(&ltime);

}

type_conversion_status Item::save_time_in_field(Field *field)

{

MYSQL_TIME ltime;

if (get_time(&ltime))

return set_field_to_null_with_conversions(field, 0);

field->set_notnull();

return field->store_time(&ltime, decimals);

}

type_conversion_status Item::save_date_in_field(Field *field)

{

MYSQL_TIME ltime;

if (get_date(&ltime, TIME_FUZZY_DATE))

return set_field_to_null_with_conversions(field, 0);

field->set_notnull();

return field->store_time(&ltime, decimals);

}

/*

Store the string value in field directly

SYNOPSIS

Item::save_str_value_in_field()

field a pointer to field where to store

result the pointer to the string value to be stored

DESCRIPTION

The method is used by Item_*::save_in_field implementations

when we don't need to calculate the value to store

See Item_string::save_in_field() implementation for example

IMPLEMENTATION

Check if the Item is null and stores the NULL or the

result value in the field accordingly.

RETURN

Nonzero value if error

*/

type_conversion_status

Item::save_str_value_in_field(Field *field, String *result)

{

if (null_value)

return set_field_to_null(field);

field->set_notnull();

return field->store(result->ptr(), result->length(), collation.collation);

}

Item::Item():

is_expensive_cache(-1), rsize(0),

marker(0), fixed(0),

collation(&my_charset_bin, DERIVATION_COERCIBLE),

runtime_item(false), with_subselect(false),

with_stored_program(false), tables_locked_cache(false)

{

maybe_null=null_value=with_sum_func=unsigned_flag=0;

decimals= 0; max_length= 0;

cmp_context= (Item_result)-1;

/* Put item in free list so that we can free all items at end */

THD *thd= current_thd;

next= thd->free_list;

thd->free_list= this;

/*

Item constructor can be called during execution other then SQL_COM

command => we should check thd->lex->current_select on zero (thd->lex

can be uninitialised)

*/

if (thd->lex->current_select)

{

enum_parsing_place place=

thd->lex->current_select->parsing_place;

if (place == SELECT_LIST ||

place == IN_HAVING)

thd->lex->current_select->select_n_having_items++;

}

}

/**

Constructor used by Item_field, Item_ref & aggregate (sum)

functions.

Used for duplicating lists in processing queries with temporary

tables.

*/

Item::Item(THD *thd, Item *item):

is_expensive_cache(-1),

rsize(0),

str_value(item->str_value),

item_name(item->item_name),

orig_name(item->orig_name),

max_length(item->max_length),

marker(item->marker),

decimals(item->decimals),

maybe_null(item->maybe_null),

null_value(item->null_value),

unsigned_flag(item->unsigned_flag),

with_sum_func(item->with_sum_func),

fixed(item->fixed),

collation(item->collation),

cmp_context(item->cmp_context),

runtime_item(false),

with_subselect(item->has_subquery()),

with_stored_program(item->with_stored_program),

tables_locked_cache(item->tables_locked_cache)

{

next= thd->free_list; // Put in free list

thd->free_list= this;

}

uint Item::decimal_precision() const

{

Item_result restype= result_type();

if ((restype == DECIMAL_RESULT) || (restype == INT_RESULT))

{

uint prec=

my_decimal_length_to_precision(max_char_length(), decimals,

unsigned_flag);

return min<uint>(prec, DECIMAL_MAX_PRECISION);

}

switch (field_type())

{

case MYSQL_TYPE_TIME:

return decimals + TIME_INT_DIGITS;

case MYSQL_TYPE_DATETIME:

case MYSQL_TYPE_TIMESTAMP:

return decimals + DATETIME_INT_DIGITS;

case MYSQL_TYPE_DATE:

return decimals + DATE_INT_DIGITS;

default:

break;

}

return min<uint>(max_char_length(), DECIMAL_MAX_PRECISION);

}

uint Item::time_precision()

{

if (const_item() && result_type() == STRING_RESULT && !is_temporal())

{

MYSQL_TIME ltime;

String buf, *tmp;

MYSQL_TIME_STATUS status;

DBUG_ASSERT(fixed);

// Nanosecond rounding is not needed, for performance purposes

if ((tmp= val_str(&buf)) &&

str_to_time(tmp, &ltime, TIME_NO_NSEC_ROUNDING, &status) == 0)

return MY_MIN(status.fractional_digits, DATETIME_MAX_DECIMALS);

}

return MY_MIN(decimals, DATETIME_MAX_DECIMALS);

}

uint Item::datetime_precision()

{

if (const_item() && result_type() == STRING_RESULT && !is_temporal())

{

MYSQL_TIME ltime;

String buf, *tmp;

MYSQL_TIME_STATUS status;

DBUG_ASSERT(fixed);

// Nanosecond rounding is not needed, for performance purposes

if ((tmp= val_str(&buf)) &&

!str_to_datetime(tmp, &ltime, TIME_NO_NSEC_ROUNDING | TIME_FUZZY_DATE,

&status))

return MY_MIN(status.fractional_digits, DATETIME_MAX_DECIMALS);

}

return MY_MIN(decimals, DATETIME_MAX_DECIMALS);

}

void Item::print_item_w_name(String *str, enum_query_type query_type)

{

print(str, query_type);

if (item_name.is_set())

{

THD *thd= current_thd;

str->append(STRING_WITH_LEN(" AS "));

append_identifier(thd, str, item_name);

}

}

/**

@details

"SELECT (subq) GROUP BY (same_subq)" confuses ONLY_FULL_GROUP_BY (it does

not see that both subqueries are the same, raises an error).

To avoid hitting this problem, if the original query was:

"SELECT expression AS x GROUP BY x", we print "GROUP BY x", not

"GROUP BY expression". Same for ORDER BY.

This has practical importance for views created as

"CREATE VIEW v SELECT (subq) AS x GROUP BY x"

(print_order() is used to write the view's definition in the frm file).

We make one exception: if the view is merge-able, its ORDER clause will be

merged into the parent query's. If an identifier in the merged ORDER clause

is allowed to be either an alias or an expression of the view's underlying

tables, resolution is difficult: it may be to be found in the underlying

tables of the view, or in the SELECT list of the view; unlike other ORDER

elements directly originating from the parent query.

To avoid this problem, if the view is merge-able, we print the

expression. This does not cause problems with only_full_group_by, because a

merge-able view never has GROUP BY. @see mysql_register_view().

*/

void Item::print_for_order(String *str,

enum_query_type query_type,

bool used_alias)

{

if (used_alias)

{

DBUG_ASSERT(item_name.is_set());

// In the clause, user has referenced expression using an alias; we use it

append_identifier(current_thd, str, item_name);

}

else

print(str,query_type);

}

void Item::cleanup()

{

DBUG_ENTER("Item::cleanup");

fixed=0;

marker= 0;

tables_locked_cache= false;

if (orig_name.is_set())

item_name= orig_name;

DBUG_VOID_RETURN;

}

/**

cleanup() item if it is 'fixed'.

@param arg a dummy parameter, is not used here

*/

bool Item::cleanup_processor(uchar *arg)

{

if (fixed)

cleanup();

return FALSE;

}

/**

rename item (used for views, cleanup() return original name).

@param new_name new name of item;

*/

void Item::rename(char *new_name)

{

/*

we can compare pointers to names here, because if name was not changed,

pointer will be same

*/

if (!orig_name.is_set() && new_name != item_name.ptr())

orig_name= item_name;

item_name.set(new_name);

}

/**

Traverse item tree possibly transforming it (replacing items).

This function is designed to ease transformation of Item trees.

Re-execution note: every such transformation is registered for

rollback by THD::change_item_tree() and is rolled back at the end

of execution by THD::rollback_item_tree_changes().

Therefore:

- this function can not be used at prepared statement prepare

(in particular, in fix_fields!), as only permanent

transformation of Item trees are allowed at prepare.

- the transformer function shall allocate new Items in execution

memory root (thd->mem_root) and not anywhere else: allocated

items will be gone in the end of execution.

If you don't need to transform an item tree, but only traverse

it, please use Item::walk() instead.

@param transformer functor that performs transformation of a subtree

@param arg opaque argument passed to the functor

@return

Returns pointer to the new subtree root. THD::change_item_tree()

should be called for it if transformation took place, i.e. if a

pointer to newly allocated item is returned.

*/

Item* Item::transform(Item_transformer transformer, uchar *arg)

{

DBUG_ASSERT(!current_thd->stmt_arena->is_stmt_prepare());

return (this->*transformer)(arg);

}

Item_ident::Item_ident(Name_resolution_context *context_arg,

const char *db_name_arg,const char *table_name_arg,

const char *field_name_arg)

:orig_db_name(db_name_arg), orig_table_name(table_name_arg),

orig_field_name(field_name_arg), context(context_arg),

db_name(db_name_arg), table_name(table_name_arg),

field_name(field_name_arg),

alias_name_used(FALSE), cached_field_index(NO_CACHED_FIELD_INDEX),

cached_table(0), depended_from(0)

{

item_name.set(field_name_arg);

}

/**

Constructor used by Item_field & Item_*_ref (see Item comment)

*/

Item_ident::Item_ident(THD *thd, Item_ident *item)

:Item(thd, item),

orig_db_name(item->orig_db_name),

orig_table_name(item->orig_table_name),

orig_field_name(item->orig_field_name),

context(item->context),

db_name(item->db_name),

table_name(item->table_name),

field_name(item->field_name),

alias_name_used(item->alias_name_used),

cached_field_index(item->cached_field_index),

cached_table(item->cached_table),

depended_from(item->depended_from)

{}

void Item_ident::cleanup()

{

DBUG_ENTER("Item_ident::cleanup");

#ifdef CANT_BE_USED_AS_MEMORY_IS_FREED

db_name ? db_name : "(null)",

orig_db_name ? orig_db_name : "(null)",

table_name ? table_name : "(null)",

orig_table_name ? orig_table_name : "(null)",

field_name ? field_name : "(null)",

orig_field_name ? orig_field_name : "(null)"));

#endif

Item::cleanup();

db_name= orig_db_name;

table_name= orig_table_name;

field_name= orig_field_name;

DBUG_VOID_RETURN;

}

bool Item_ident::remove_dependence_processor(uchar * arg)

{

DBUG_ENTER("Item_ident::remove_dependence_processor");

if (depended_from == (st_select_lex *) arg)

depended_from= 0;

context= &((st_select_lex *) arg)->context;

DBUG_RETURN(0);

}

/**

Store the pointer to this item field into a list if not already there.

The method is used by Item::walk to collect all unique Item_field objects

from a tree of Items into a set of items represented as a list.

Item_cond::walk() and Item_func::walk() stop the evaluation of the

processor function for its arguments once the processor returns

true.Therefore in order to force this method being called for all item

arguments in a condition the method must return false.

@param arg pointer to a List<Item_field>

@return

FALSE to force the evaluation of collect_item_field_processor

for the subsequent items.

*/

bool Item_field::collect_item_field_processor(uchar *arg)

{

DBUG_ENTER("Item_field::collect_item_field_processor");

DBUG_PRINT("info", ("%s", field->field_name ? field->field_name : "noname"));

List<Item_field> *item_list= (List<Item_field>*) arg;

List_iterator<Item_field> item_list_it(*item_list);

Item_field *curr_item;

while ((curr_item= item_list_it++))

{

if (curr_item->eq(this, 1))

DBUG_RETURN(FALSE); /* Already in the set. */

}

item_list->push_back(this);

DBUG_RETURN(FALSE);

}

bool Item_field::add_field_to_set_processor(uchar *arg)

{

DBUG_ENTER("Item_field::add_field_to_set_processor");

DBUG_PRINT("info", ("%s", field->field_name ? field->field_name : "noname"));

TABLE *table= (TABLE *) arg;

if (field->table == table)

bitmap_set_bit(&table->tmp_set, field->field_index);

DBUG_RETURN(FALSE);

}

bool Item_field::remove_column_from_bitmap(uchar *argument)

{

MY_BITMAP *bitmap= reinterpret_cast<MY_BITMAP*>(argument);

bitmap_clear_bit(bitmap, field->field_index);

return false;

}

/**

Check if an Item_field references some field from a list of fields.

Check whether the Item_field represented by 'this' references any

of the fields in the keyparts passed via 'arg'. Used with the

method Item::walk() to test whether any keypart in a sequence of

keyparts is referenced in an expression.

@param arg Field being compared, arg must be of type Field

@retval

TRUE if 'this' references the field 'arg'

@retval

FALSE otherwise

*/

bool Item_field::find_item_in_field_list_processor(uchar *arg)

{

KEY_PART_INFO *first_non_group_part= *((KEY_PART_INFO **) arg);

KEY_PART_INFO *last_part= *(((KEY_PART_INFO **) arg) + 1);

KEY_PART_INFO *cur_part;

for (cur_part= first_non_group_part; cur_part != last_part; cur_part++)

{

if (field->eq(cur_part->field))

return TRUE;

}

return FALSE;

}

/*

Mark field in read_map

NOTES

This is used by filesort to register used fields in a a temporary

column read set or to register used fields in a view

*/

bool Item_field::register_field_in_read_map(uchar *arg)

{

TABLE *table= (TABLE *) arg;

if (field->table == table || !table)

bitmap_set_bit(field->table->read_set, field->field_index);

return 0;

}

bool Item::check_cols(uint c)

{

if (c != 1)

{

my_error(ER_OPERAND_COLUMNS, MYF(0), c);

return 1;

}

return 0;

}

const Name_string null_name_string(NULL, 0);

void Name_string::copy(const char *str, size_t length, const CHARSET_INFO *cs)

{

if (!length)

{

/* Empty string, used by AS or internal function like last_insert_id() */

set(str ? "" : NULL, 0);

return;

}

if (cs->ctype)

{

/*

This will probably need a better implementation in the future:

a function in CHARSET_INFO structure.

*/

while (length && !my_isgraph(cs, *str))

{ // Fix problem with yacc

length--;

str++;

}

}