summaryrefslogtreecommitdiffstats
path: root/sql/item.cc
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-05-04 18:07:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-05-04 18:07:14 +0000
commita175314c3e5827eb193872241446f2f8f5c9d33c (patch)
treecd3d60ca99ae00829c52a6ca79150a5b6e62528b /sql/item.cc
parentInitial commit. (diff)
downloadmariadb-10.5-a175314c3e5827eb193872241446f2f8f5c9d33c.tar.xz
mariadb-10.5-a175314c3e5827eb193872241446f2f8f5c9d33c.zip
Adding upstream version 1:10.5.12.upstream/1%10.5.12upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'sql/item.cc')
-rw-r--r--sql/item.cc10714
1 files changed, 10714 insertions, 0 deletions
diff --git a/sql/item.cc b/sql/item.cc
new file mode 100644
index 00000000..8f6bfdc6
--- /dev/null
+++ b/sql/item.cc
@@ -0,0 +1,10714 @@
+/*
+ Copyright (c) 2000, 2018, Oracle and/or its affiliates.
+ Copyright (c) 2010, 2021, MariaDB Corporation.
+
+ 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-1335 USA */
+
+
+#ifdef USE_PRAGMA_IMPLEMENTATION
+#pragma implementation // gcc: Class implementation
+#endif
+#include "mariadb.h" /* NO_EMBEDDED_ACCESS_CHECKS */
+#include "sql_priv.h"
+#include <mysql.h>
+#include <m_ctype.h>
+#include "my_dir.h"
+#include "sp_rcontext.h"
+#include "sp_head.h"
+#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 "sql_expression_cache.h"
+
+const String my_null_string("NULL", 4, default_charset_info);
+const String my_default_string("DEFAULT", 7, default_charset_info);
+
+/*
+ item_empty_name is used when calling Item::set_name with NULL
+ pointer, to make it easier to use the name in printf.
+ item_used_name is used when calling Item::set_name with a 0 length
+ string.
+*/
+const char *item_empty_name="";
+const char *item_used_name= "\0";
+
+static int save_field_in_field(Field *, bool *, Field *, bool);
+
+
+/**
+ Compare two Items for List<Item>::add_unique()
+*/
+
+bool cmp_items(Item *a, Item *b)
+{
+ return a->eq(b, FALSE);
+}
+
+
+/**
+ Set max_sum_func_level if it is needed
+*/
+inline void set_max_sum_func_level(THD *thd, SELECT_LEX *select)
+{
+ if (thd->lex->in_sum_func &&
+ thd->lex->in_sum_func->nest_level >= select->nest_level)
+ set_if_bigger(thd->lex->in_sum_func->max_sum_func_level,
+ select->nest_level - 1);
+}
+
+
+MEM_ROOT *get_thd_memroot(THD *thd)
+{
+ return thd->mem_root;
+}
+
+/*****************************************************************************
+** Item functions
+*****************************************************************************/
+
+/**
+ Init all special items.
+*/
+
+void item_init(void)
+{
+ item_func_sleep_init();
+ uuid_short_init();
+}
+
+
+void Item::raise_error_not_evaluable()
+{
+ Item::Print tmp(this, QT_ORDINARY);
+ my_error(ER_NOT_ALLOWED_IN_THIS_CONTEXT, MYF(0), tmp.ptr());
+}
+
+
+void Item::push_note_converted_to_negative_complement(THD *thd)
+{
+ push_warning(thd, Sql_condition::WARN_LEVEL_NOTE, ER_UNKNOWN_ERROR,
+ "Cast to signed converted positive out-of-range integer to "
+ "it's negative complement");
+}
+
+
+void Item::push_note_converted_to_positive_complement(THD *thd)
+{
+ push_warning(thd, Sql_condition::WARN_LEVEL_NOTE, ER_UNKNOWN_ERROR,
+ "Cast to unsigned converted negative integer to it's "
+ "positive complement");
+}
+
+
+longlong Item::val_datetime_packed_result(THD *thd)
+{
+ MYSQL_TIME ltime, tmp;
+ if (get_date_result(thd, &ltime, Datetime::Options_cmp(thd)))
+ return 0;
+ if (ltime.time_type != MYSQL_TIMESTAMP_TIME)
+ return pack_time(&ltime);
+ if ((null_value= time_to_datetime_with_warn(thd, &ltime, &tmp,
+ TIME_CONV_NONE)))
+ return 0;
+ return pack_time(&tmp);
+}
+
+
+longlong Item::val_time_packed_result(THD *thd)
+{
+ MYSQL_TIME ltime;
+ if (get_date_result(thd, &ltime, Time::Options_cmp(thd)))
+ return 0;
+ if (ltime.time_type == MYSQL_TIMESTAMP_TIME)
+ return pack_time(&ltime);
+ int warn= 0;
+ Time tmp(&warn, &ltime, 0);
+ DBUG_ASSERT(tmp.is_valid_time());
+ return tmp.to_packed();
+}
+
+
+/*
+ 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)
+{
+ DBUG_ASSERT(str != &str_value);
+
+ uint errors;
+ String *res= val_str(&str_value);
+ if (!res)
+ return 0;
+
+ if (!(res->charset()->state & MY_CS_NONASCII))
+ str= res;
+ else
+ {
+ if ((null_value= str->copy(res->ptr(), res->length(), collation.collation,
+ &my_charset_latin1, &errors)))
+ return 0;
+ }
+
+ return str;
+}
+
+
+String *Item::val_str_ascii_revert_empty_string_is_null(THD *thd, String *str)
+{
+ String *res= val_str_ascii(str);
+ if (!res && (thd->variables.sql_mode & MODE_EMPTY_STRING_IS_NULL))
+ {
+ null_value= false;
+ str->set("", 0, &my_charset_latin1);
+ return str;
+ }
+ return res;
+}
+
+
+String *Item::val_str(String *str, String *converter, CHARSET_INFO *cs)
+{
+ String *res= val_str(str);
+ if (null_value)
+ return (String *) 0;
+
+ if (!cs)
+ return res;
+
+ uint errors;
+ if ((null_value= converter->copy(res->ptr(), res->length(),
+ collation.collation, cs, &errors)))
+ return (String *) 0;
+
+ return converter;
+}
+
+
+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_numeric);
+ 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_numeric);
+ return str;
+}
+
+
+longlong Item::val_int_from_str(int *error)
+{
+ char buff[MAX_FIELD_WIDTH];
+ String tmp(buff,sizeof(buff), &my_charset_bin), *res;
+
+ /*
+ For a string result, we must first get the string and then convert it
+ to a longlong
+ */
+ if (!(res= val_str(&tmp)))
+ {
+ *error= 0;
+ return 0;
+ }
+ Converter_strtoll10_with_warn cnv(NULL, Warn_filter_all(),
+ res->charset(), res->ptr(), res->length());
+ *error= cnv.error();
+ return cnv.result();
+}
+
+
+longlong Item::val_int_signed_typecast_from_str()
+{
+ int error;
+ longlong value= val_int_from_str(&error);
+ if (unlikely(!null_value && value < 0 && error == 0))
+ push_note_converted_to_negative_complement(current_thd);
+ return value;
+}
+
+
+longlong Item::val_int_unsigned_typecast_from_str()
+{
+ int error;
+ longlong value= val_int_from_str(&error);
+ if (unlikely(!null_value && error < 0))
+ push_note_converted_to_positive_complement(current_thd);
+ return value;
+}
+
+
+longlong Item::val_int_signed_typecast_from_real()
+{
+ double nr= val_real();
+ if (null_value)
+ return 0;
+ Converter_double_to_longlong conv(nr, false);
+ if (conv.error())
+ {
+ THD *thd= current_thd;
+ push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
+ ER_DATA_OVERFLOW, ER_THD(thd, ER_DATA_OVERFLOW),
+ ErrConvDouble(nr).ptr(), "SIGNED BIGINT");
+ }
+ return conv.result();
+}
+
+
+longlong Item::val_int_unsigned_typecast_from_real()
+{
+ double nr= val_real();
+ if (null_value)
+ return 0;
+ Converter_double_to_longlong conv(nr, true);
+ if (conv.error())
+ {
+ THD *thd= current_thd;
+ push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
+ ER_DATA_OVERFLOW, ER_THD(thd, ER_DATA_OVERFLOW),
+ ErrConvDouble(nr).ptr(), "UNSIGNED BIGINT");
+ }
+ return conv.result();
+}
+
+
+longlong Item::val_int_signed_typecast_from_int()
+{
+ longlong value= val_int();
+ if (!null_value && unsigned_flag && value < 0)
+ push_note_converted_to_negative_complement(current_thd);
+ return value;
+}
+
+
+longlong Item::val_int_unsigned_typecast_from_int()
+{
+ longlong value= val_int();
+ if (!null_value && unsigned_flag == 0 && value < 0)
+ push_note_converted_to_positive_complement(current_thd);
+ return value;
+}
+
+
+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)
+{
+ DBUG_ASSERT(is_fixed());
+ 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 0;
+
+ return decimal_from_string_with_check(decimal_value, res);
+}
+
+
+int Item::save_time_in_field(Field *field, bool no_conversions)
+{
+ MYSQL_TIME ltime;
+ if (get_time(field->table->in_use, &ltime))
+ return set_field_to_null_with_conversions(field, no_conversions);
+ field->set_notnull();
+ return field->store_time_dec(&ltime, decimals);
+}
+
+
+int Item::save_date_in_field(Field *field, bool no_conversions)
+{
+ MYSQL_TIME ltime;
+ THD *thd= field->table->in_use;
+ if (get_date(thd, &ltime, Datetime::Options(thd)))
+ return set_field_to_null_with_conversions(field, no_conversions);
+ field->set_notnull();
+ return field->store_time_dec(&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
+*/
+
+int 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(THD *thd):
+ is_expensive_cache(-1), rsize(0), name(null_clex_str), orig_name(0),
+ common_flags(IS_AUTO_GENERATED_NAME)
+{
+ DBUG_ASSERT(thd);
+ marker= 0;
+ maybe_null= null_value= with_window_func= with_field= false;
+ in_rollup= 0;
+ with_param= 0;
+
+ /* Initially this item is not attached to any JOIN_TAB. */
+ join_tab_idx= MAX_TABLES;
+
+ /* Put item in free list so that we can free all items at end */
+ 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++;
+ }
+}
+
+
+const TABLE_SHARE *Item::field_table_or_null()
+{
+ if (real_item()->type() != Item::FIELD_ITEM)
+ return NULL;
+
+ return ((Item_field *) this)->field->table->s;
+}
+
+
+/**
+ 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):
+ Type_all_attributes(*item),
+ join_tab_idx(item->join_tab_idx),
+ is_expensive_cache(-1),
+ rsize(0),
+ str_value(item->str_value),
+ name(item->name),
+ orig_name(item->orig_name),
+ marker(item->marker),
+ maybe_null(item->maybe_null),
+ in_rollup(item->in_rollup),
+ null_value(item->null_value),
+ with_param(item->with_param),
+ with_window_func(item->with_window_func),
+ with_field(item->with_field),
+ common_flags(item->common_flags)
+{
+ next= thd->free_list; // Put in free list
+ thd->free_list= this;
+}
+
+
+void Item::print_parenthesised(String *str, enum_query_type query_type,
+ enum precedence parent_prec)
+{
+ bool need_parens= precedence() < parent_prec;
+ if (need_parens)
+ str->append('(');
+ print(str, query_type);
+ if (need_parens)
+ str->append(')');
+}
+
+
+void Item::print(String *str, enum_query_type query_type)
+{
+ str->append(full_name());
+}
+
+
+void Item::print_item_w_name(String *str, enum_query_type query_type)
+{
+ print(str, query_type);
+
+ if (name.str)
+ {
+ DBUG_ASSERT(name.length == strlen(name.str));
+ THD *thd= current_thd;
+ str->append(STRING_WITH_LEN(" AS "));
+ append_identifier(thd, str, &name);
+ }
+}
+
+
+void Item::print_value(String *str)
+{
+ char buff[MAX_FIELD_WIDTH];
+ String *ptr, tmp(buff,sizeof(buff),str->charset());
+ ptr= val_str(&tmp);
+ if (!ptr)
+ str->append("NULL");
+ else
+ {
+ switch (cmp_type()) {
+ case STRING_RESULT:
+ case TIME_RESULT:
+ append_unescaped(str, ptr->ptr(), ptr->length());
+ break;
+ case DECIMAL_RESULT:
+ case REAL_RESULT:
+ case INT_RESULT:
+ str->append(*ptr);
+ break;
+ case ROW_RESULT:
+ DBUG_ASSERT(0);
+ }
+ }
+}
+
+
+void Item::cleanup()
+{
+ DBUG_ENTER("Item::cleanup");
+ DBUG_PRINT("enter", ("this: %p", this));
+ marker= 0;
+ join_tab_idx= MAX_TABLES;
+ if (orig_name)
+ {
+ name.str= orig_name;
+ name.length= strlen(orig_name);
+ }
+ DBUG_VOID_RETURN;
+}
+
+
+/**
+ cleanup() item if it is 'fixed'.
+
+ @param arg a dummy parameter, is not used here
+*/
+
+bool Item::cleanup_processor(void *arg)
+{
+ if (is_fixed())
+ cleanup();
+ return FALSE;
+}
+
+
+/**
+ 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(THD *thd, Item_transformer transformer, uchar *arg)
+{
+ DBUG_ASSERT(!thd->stmt_arena->is_stmt_prepare());
+
+ return (this->*transformer)(thd, arg);
+}
+
+
+/**
+ Create and set up an expression cache for this item
+
+ @param thd Thread handle
+ @param depends_on List of the expression parameters
+
+ @details
+ The function creates an expression cache for an item and its parameters
+ specified by the 'depends_on' list. Then the expression cache is placed
+ into a cache wrapper that is returned as the result of the function.
+
+ @returns
+ A pointer to created wrapper item if successful, NULL - otherwise
+*/
+
+Item* Item::set_expr_cache(THD *thd)
+{
+ DBUG_ENTER("Item::set_expr_cache");
+ Item_cache_wrapper *wrapper;
+ if (likely((wrapper= new (thd->mem_root) Item_cache_wrapper(thd, this))) &&
+ likely(!wrapper->fix_fields(thd, (Item**)&wrapper)))
+ {
+ if (likely(!wrapper->set_cache(thd)))
+ DBUG_RETURN(wrapper);
+ }
+ DBUG_RETURN(NULL);
+}
+
+
+Item_ident::Item_ident(THD *thd, Name_resolution_context *context_arg,
+ const LEX_CSTRING &db_name_arg,
+ const LEX_CSTRING &table_name_arg,
+ const LEX_CSTRING &field_name_arg)
+ :Item_result_field(thd), 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), can_be_depended(TRUE)
+{
+ name= field_name_arg;
+}
+
+
+Item_ident::Item_ident(THD *thd, TABLE_LIST *view_arg,
+ const LEX_CSTRING &field_name_arg)
+ :Item_result_field(thd), orig_db_name(null_clex_str),
+ orig_table_name(view_arg->table_name),
+ orig_field_name(field_name_arg),
+ /* TODO: suspicious use of first_select_lex */
+ context(&view_arg->view->first_select_lex()->context),
+ db_name(null_clex_str), table_name(view_arg->alias),
+ field_name(field_name_arg),
+ alias_name_used(FALSE), cached_field_index(NO_CACHED_FIELD_INDEX),
+ cached_table(NULL), depended_from(NULL), can_be_depended(TRUE)
+{
+ name= field_name_arg;
+}
+
+
+/**
+ Constructor used by Item_field & Item_*_ref (see Item comment)
+*/
+
+Item_ident::Item_ident(THD *thd, Item_ident *item)
+ :Item_result_field(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),
+ can_be_depended(item->can_be_depended)
+{}
+
+void Item_ident::cleanup()
+{
+ DBUG_ENTER("Item_ident::cleanup");
+ bool was_fixed= fixed;
+ Item_result_field::cleanup();
+ db_name= orig_db_name;
+ table_name= orig_table_name;
+ field_name= orig_field_name;
+ /* Store if this Item was depended */
+ if (was_fixed)
+ {
+ /*
+ We can trust that depended_from set correctly only if this item
+ was fixed
+ */
+ can_be_depended= MY_TEST(depended_from);
+ }
+ DBUG_VOID_RETURN;
+}
+
+bool Item_ident::remove_dependence_processor(void * arg)
+{
+ DBUG_ENTER("Item_ident::remove_dependence_processor");
+ if (get_depended_from() == (st_select_lex *) arg)
+ depended_from= 0;
+ context= &((st_select_lex *) arg)->context;
+ DBUG_RETURN(0);
+}
+
+
+bool Item_ident::collect_outer_ref_processor(void *param)
+{
+ Collect_deps_prm *prm= (Collect_deps_prm *)param;
+ if (depended_from &&
+ depended_from->nest_level_base == prm->nest_level_base &&
+ depended_from->nest_level < prm->nest_level)
+ {
+ if (prm->collect)
+ prm->parameters->add_unique(this, &cmp_items);
+ else
+ prm->count++;
+ }
+ return FALSE;
+}
+
+
+/**
+ 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(void *arg)
+{
+ DBUG_ENTER("Item_field::collect_item_field_processor");
+ DBUG_PRINT("info", ("%s", field->field_name.str ?
+ field->field_name.str : "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);
+}
+
+
+void Item_ident::undeclared_spvar_error() const
+{
+ /*
+ We assume this is an unknown SP variable, possibly a ROW variable.
+ Print the leftmost name in the error:
+ SET var=a; -> a
+ SET var=a.b; -> a
+ SET var=a.b.c; -> a
+ */
+ my_error(ER_SP_UNDECLARED_VAR, MYF(0), db_name.str ? db_name.str :
+ table_name.str ? table_name.str :
+ field_name.str);
+}
+
+bool Item_field::unknown_splocal_processor(void *arg)
+{
+ DBUG_ENTER("Item_field::unknown_splocal_processor");
+ DBUG_ASSERT(type() == FIELD_ITEM);
+ undeclared_spvar_error();
+ DBUG_RETURN(true);
+}
+
+
+bool Item_field::add_field_to_set_processor(void *arg)
+{
+ DBUG_ENTER("Item_field::add_field_to_set_processor");
+ DBUG_PRINT("info", ("%s", field->field_name.str ? field->field_name.str :
+ "noname"));
+ TABLE *table= (TABLE *) arg;
+ if (field->table == table)
+ bitmap_set_bit(&table->tmp_set, field->field_index);
+ DBUG_RETURN(FALSE);
+}
+
+
+/**
+ Rename fields in an expression to new field name as speficied by ALTER TABLE
+*/
+
+bool Item_field::rename_fields_processor(void *arg)
+{
+ Item::func_processor_rename *rename= (Item::func_processor_rename*) arg;
+ List_iterator<Create_field> def_it(rename->fields);
+ Create_field *def;
+
+ while ((def=def_it++))
+ {
+ if (def->change.str &&
+ (!db_name.str || !db_name.str[0] ||
+ !my_strcasecmp(table_alias_charset, db_name.str, rename->db_name.str)) &&
+ (!table_name.str || !table_name.str[0] ||
+ !my_strcasecmp(table_alias_charset, table_name.str, rename->table_name.str)) &&
+ !my_strcasecmp(system_charset_info, field_name.str, def->change.str))
+ {
+ field_name= def->field_name;
+ break;
+ }
+ }
+ return 0;
+}
+
+
+/**
+ 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(void *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 or check constraint
+*/
+
+bool Item_field::register_field_in_read_map(void *arg)
+{
+ TABLE *table= (TABLE *) arg;
+ int res= 0;
+ if (table && table != field->table)
+ return res;
+
+ if (field->vcol_info &&
+ !bitmap_fast_test_and_set(field->table->read_set, field->field_index))
+ {
+ res= field->vcol_info->expr->walk(&Item::register_field_in_read_map,1,arg);
+ }
+ else
+ bitmap_set_bit(field->table->read_set, field->field_index);
+ return res;
+}
+
+/*
+ @brief
+ Mark field in bitmap supplied as *arg
+*/
+
+bool Item_field::register_field_in_bitmap(void *arg)
+{
+ MY_BITMAP *bitmap= (MY_BITMAP *) arg;
+ DBUG_ASSERT(bitmap);
+ bitmap_set_bit(bitmap, field->field_index);
+ return 0;
+}
+
+
+/*
+ Mark field in write_map
+
+ NOTES
+ This is used by UPDATE to register underlying fields of used view fields.
+*/
+
+bool Item_field::register_field_in_write_map(void *arg)
+{
+ TABLE *table= (TABLE *) arg;
+ if (field->table == table || !table)
+ bitmap_set_bit(field->table->write_set, field->field_index);
+ return 0;
+}
+
+/**
+ Check that we are not referring to any not yet initialized fields
+
+ Fields are initialized in this order:
+ - All fields that have default value as a constant are initialized first.
+ - Then user-specified values from the INSERT list
+ - Then all fields that has a default expression, in field_index order.
+ - Then all virtual fields, in field_index order.
+ - Then auto-increment values
+
+ This means:
+ - For default fields we can't access the same field or a field after
+ itself that doesn't have a non-constant default value.
+ - A virtual field can't access itself or a virtual field after itself.
+ - user-specified values will not see virtual fields or default expressions,
+ as in INSERT t1 (a) VALUES (b);
+ - no virtual fields can access auto-increment values
+
+ This is used by fix_vcol_expr() when a table is opened
+
+ We don't have to check fields that are marked as NO_DEFAULT_VALUE
+ as the upper level will ensure that all these will be given a value.
+*/
+
+bool Item_field::check_field_expression_processor(void *arg)
+{
+ Field *org_field= (Field*) arg;
+ if (field->flags & NO_DEFAULT_VALUE_FLAG)
+ return 0;
+ if ((field->default_value && field->default_value->flags) || field->vcol_info)
+ {
+ if (field == org_field ||
+ (!org_field->vcol_info && field->vcol_info) ||
+ (((field->vcol_info && org_field->vcol_info) ||
+ (!field->vcol_info && !org_field->vcol_info)) &&
+ field->field_index >= org_field->field_index))
+ {
+ my_error(ER_EXPRESSION_REFERS_TO_UNINIT_FIELD,
+ MYF(0),
+ org_field->field_name.str, field->field_name.str);
+ return 1;
+ }
+ }
+ return 0;
+}
+
+bool Item_field::update_vcol_processor(void *arg)
+{
+ MY_BITMAP *map= (MY_BITMAP *) arg;
+ if (field->vcol_info &&
+ !bitmap_fast_test_and_set(map, field->field_index))
+ {
+ field->vcol_info->expr->walk(&Item::update_vcol_processor, 0, arg);
+ field->vcol_info->expr->save_in_field(field, 0);
+ }
+ return 0;
+}
+
+
+bool Item::check_cols(uint c)
+{
+ if (c != 1)
+ {
+ my_error(ER_OPERAND_COLUMNS, MYF(0), c);
+ return 1;
+ }
+ return 0;
+}
+
+
+bool Item::check_type_or_binary(const char *opname,
+ const Type_handler *expect) const
+{
+ const Type_handler *handler= type_handler();
+ if (handler == expect ||
+ (handler->is_general_purpose_string_type() &&
+ collation.collation == &my_charset_bin))
+ return false;
+ my_error(ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION, MYF(0),
+ handler->name().ptr(), opname);
+ return true;
+}
+
+
+bool Item::check_type_general_purpose_string(const char *opname) const
+{
+ const Type_handler *handler= type_handler();
+ if (handler->is_general_purpose_string_type())
+ return false;
+ my_error(ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION, MYF(0),
+ handler->name().ptr(), opname);
+ return true;
+}
+
+
+bool Item::check_type_traditional_scalar(const char *opname) const
+{
+ const Type_handler *handler= type_handler();
+ if (handler->is_traditional_scalar_type())
+ return false;
+ my_error(ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION, MYF(0),
+ handler->name().ptr(), opname);
+ return true;
+}
+
+
+bool Item::check_type_can_return_int(const char *opname) const
+{
+ const Type_handler *handler= type_handler();
+ if (handler->can_return_int())
+ return false;
+ my_error(ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION, MYF(0),
+ handler->name().ptr(), opname);
+ return true;
+}
+
+
+bool Item::check_type_can_return_decimal(const char *opname) const
+{
+ const Type_handler *handler= type_handler();
+ if (handler->can_return_decimal())
+ return false;
+ my_error(ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION, MYF(0),
+ handler->name().ptr(), opname);
+ return true;
+}
+
+
+bool Item::check_type_can_return_real(const char *opname) const
+{
+ const Type_handler *handler= type_handler();
+ if (handler->can_return_real())
+ return false;
+ my_error(ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION, MYF(0),
+ handler->name().ptr(), opname);
+ return true;
+}
+
+
+bool Item::check_type_can_return_date(const char *opname) const
+{
+ const Type_handler *handler= type_handler();
+ if (handler->can_return_date())
+ return false;
+ my_error(ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION, MYF(0),
+ handler->name().ptr(), opname);
+ return true;
+}
+
+
+bool Item::check_type_can_return_time(const char *opname) const
+{
+ const Type_handler *handler= type_handler();
+ if (handler->can_return_time())
+ return false;
+ my_error(ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION, MYF(0),
+ handler->name().ptr(), opname);
+ return true;
+}
+
+
+bool Item::check_type_can_return_str(const char *opname) const
+{
+ const Type_handler *handler= type_handler();
+ if (handler->can_return_str())
+ return false;
+ my_error(ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION, MYF(0),
+ handler->name().ptr(), opname);
+ return true;
+}
+
+
+bool Item::check_type_can_return_text(const char *opname) const
+{
+ const Type_handler *handler= type_handler();
+ if (handler->can_return_text())
+ return false;
+ my_error(ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION, MYF(0),
+ handler->name().ptr(), opname);
+ return true;
+}
+
+
+bool Item::check_type_scalar(const char *opname) const
+{
+ /*
+ fixed==true usually means than the Item has an initialized
+ and reliable data type handler and attributes.
+ Item_outer_ref is an exception. It copies the data type and the attributes
+ from the referenced Item in the constructor, but then sets "fixed" to false,
+ and re-fixes itself again in fix_inner_refs().
+ This hack in Item_outer_ref should probably be refactored eventually.
+ Discuss with Sanja.
+ */
+ DBUG_ASSERT(is_fixed() || type() == REF_ITEM);
+ const Type_handler *handler= type_handler();
+ if (handler->is_scalar_type())
+ return false;
+ my_error(ER_OPERAND_COLUMNS, MYF(0), 1);
+ return true;
+}
+
+
+void Item::set_name(THD *thd, const char *str, size_t length, CHARSET_INFO *cs)
+{
+ if (!length)
+ {
+ /*
+ Null string are replaced by item_empty_name. This is used by AS or
+ internal function like last_insert_id() to detect if we need to
+ change the name later.
+ Used by sql_yacc.yy in select_alias handling
+ */
+ name.str= str ? item_used_name : item_empty_name;
+ name.length= 0;
+ return;
+ }
+
+ const char *str_start= str;
+ if (!cs->m_ctype || cs->mbminlen > 1)
+ {
+ str+= cs->scan(str, str + length, MY_SEQ_SPACES);
+ length-= (uint)(str - str_start);
+ }
+ else
+ {
+ /*
+ 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++;
+ }
+ }
+ if (str != str_start && !is_autogenerated_name())
+ {
+ char buff[SAFE_NAME_LEN];
+
+ strmake(buff, str_start,
+ MY_MIN(sizeof(buff)-1, length + (int) (str-str_start)));
+
+ if (length == 0)
+ push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+ ER_NAME_BECOMES_EMPTY,
+ ER_THD(thd, ER_NAME_BECOMES_EMPTY),
+ buff);
+ else
+ push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+ ER_REMOVED_SPACES, ER_THD(thd, ER_REMOVED_SPACES),
+ buff);
+ }
+ if (!my_charset_same(cs, system_charset_info))
+ {
+ size_t res_length;
+ name.str= sql_strmake_with_convert(thd, str, length, cs,
+ MAX_ALIAS_NAME, system_charset_info,
+ &res_length);
+ name.length= res_length;
+ }
+ else
+ name.str= thd->strmake(str, (name.length= MY_MIN(length,MAX_ALIAS_NAME)));
+}
+
+
+void Item::set_name_no_truncate(THD *thd, const char *str, uint length,
+ CHARSET_INFO *cs)
+{
+ if (!my_charset_same(cs, system_charset_info))
+ {
+ size_t res_length;
+ name.str= sql_strmake_with_convert(thd, str, length, cs,
+ UINT_MAX, system_charset_info,
+ &res_length);
+ name.length= res_length;
+ }
+ else
+ name.str= thd->strmake(str, (name.length= length));
+}
+
+
+/**
+ @details
+ This function is called when:
+ - Comparing items in the WHERE clause (when doing where optimization)
+ - When trying to find an ORDER BY/GROUP BY item in the SELECT part
+*/
+
+bool Item::eq(const Item *item, bool binary_cmp) const
+{
+ /*
+ Note, that this is never TRUE if item is a Item_param:
+ for all basic constants we have special checks, and Item_param's
+ type() can be only among basic constant types.
+ */
+ return type() == item->type() && name.str && item->name.str &&
+ !lex_string_cmp(system_charset_info, &name, &item->name);
+}
+
+
+Item *Item::safe_charset_converter(THD *thd, CHARSET_INFO *tocs)
+{
+ if (!needs_charset_converter(tocs))
+ return this;
+ Item_func_conv_charset *conv= new (thd->mem_root) Item_func_conv_charset(thd, this, tocs, 1);
+ return conv && conv->safe ? conv : NULL;
+}
+
+
+/**
+ Some pieces of the code do not support changing of
+ Item_cache to other Item types.
+
+ Example:
+ Item_singlerow_subselect has "Item_cache **row".
+ Creating of Item_func_conv_charset followed by THD::change_item_tree()
+ should not change row[i] from Item_cache directly to Item_func_conv_charset,
+ because Item_singlerow_subselect later calls Item_cache-specific methods,
+ e.g. row[i]->store() and row[i]->cache_value().
+
+ Let's wrap Item_func_conv_charset in a new Item_cache,
+ so the Item_cache-specific methods can still be used for
+ Item_singlerow_subselect::row[i] safely.
+
+ As a bonus we cache the converted value, instead of converting every time
+
+ TODO: we should eventually check all other use cases of change_item_tree().
+ Perhaps some more potentially dangerous substitution examples exist.
+*/
+
+Item *Item_cache::safe_charset_converter(THD *thd, CHARSET_INFO *tocs)
+{
+ if (!example)
+ return Item::safe_charset_converter(thd, tocs);
+ Item *conv= example->safe_charset_converter(thd, tocs);
+ if (conv == example)
+ return this;
+ Item_cache *cache;
+ if (!conv || conv->fix_fields(thd, (Item **) NULL) ||
+ unlikely(!(cache= new (thd->mem_root) Item_cache_str(thd, conv))))
+ return NULL; // Safe conversion is not possible, or OEM
+ cache->setup(thd, conv);
+ return cache;
+}
+
+
+/**
+ @details
+ Created mostly for mysql_prepare_table(). Important
+ when a string ENUM/SET column is described with a numeric default value:
+
+ CREATE TABLE t1(a SET('a') DEFAULT 1);
+
+ We cannot use generic Item::safe_charset_converter(), because
+ the latter returns a non-fixed Item, so val_str() crashes afterwards.
+ Override Item_num method, to return a fixed item.
+*/
+
+Item *Item_num::safe_charset_converter(THD *thd, CHARSET_INFO *tocs)
+{
+ /*
+ Item_num returns pure ASCII result,
+ so conversion is needed only in case of "tricky" character
+ sets like UCS2. If tocs is not "tricky", return the item itself.
+ */
+ if (!(tocs->state & MY_CS_NONASCII))
+ return this;
+
+ Item *conv;
+ if ((conv= const_charset_converter(thd, tocs, true)))
+ conv->fix_char_length(max_char_length());
+ return conv;
+}
+
+
+/**
+ Create character set converter for constant items
+ using Item_null, Item_string or Item_static_string_func.
+
+ @param tocs Character set to to convert the string to.
+ @param lossless Whether data loss is acceptable.
+ @param func_name Function name, or NULL.
+
+ @return this, if conversion is not needed,
+ NULL, if safe conversion is not possible, or
+ a new item representing the converted constant.
+*/
+Item *Item::const_charset_converter(THD *thd, CHARSET_INFO *tocs,
+ bool lossless,
+ const char *func_name)
+{
+ DBUG_ASSERT(const_item());
+ DBUG_ASSERT(is_fixed());
+ StringBuffer<64>tmp;
+ String *s= val_str(&tmp);
+ MEM_ROOT *mem_root= thd->mem_root;
+
+ if (!s)
+ return new (mem_root) Item_null(thd, (char *) func_name, tocs);
+
+ if (!needs_charset_converter(s->length(), tocs))
+ {
+ if (collation.collation == &my_charset_bin && tocs != &my_charset_bin &&
+ !this->check_well_formed_result(s, true))
+ return NULL;
+ return this;
+ }
+
+ uint conv_errors;
+ Item_string *conv= (func_name ?
+ new (mem_root)
+ Item_static_string_func(thd, Lex_cstring_strlen(func_name),
+ s, tocs, &conv_errors,
+ collation.derivation,
+ collation.repertoire) :
+ new (mem_root)
+ Item_string(thd, s, tocs, &conv_errors,
+ collation.derivation,
+ collation.repertoire));
+
+ if (unlikely(!conv || (conv_errors && lossless)))
+ {
+ /*
+ Safe conversion is not possible (or EOM).
+ We could not convert a string into the requested character set
+ without data loss. The target charset does not cover all the
+ characters from the string. Operation cannot be done correctly.
+ */
+ return NULL;
+ }
+ if (s->charset() == &my_charset_bin && tocs != &my_charset_bin &&
+ !conv->check_well_formed_result(true))
+ return NULL;
+ return conv;
+}
+
+
+Item *Item_param::safe_charset_converter(THD *thd, CHARSET_INFO *tocs)
+{
+ /*
+ Return "this" if in prepare. result_type may change at execition time,
+ to it's possible that the converter will not be needed at all:
+
+ PREPARE stmt FROM 'SELECT * FROM t1 WHERE field = ?';
+ SET @arg= 1;
+ EXECUTE stmt USING @arg;
+
+ In the above example result_type is STRING_RESULT at prepare time,
+ and INT_RESULT at execution time.
+ */
+ return !const_item() || state == NULL_VALUE ?
+ this : const_charset_converter(thd, tocs, true);
+}
+
+
+/**
+ Get the value of the function as a MYSQL_TIME structure.
+ As a extra convenience the time structure is reset on error or NULL values!
+*/
+
+bool Item::get_date_from_int(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+{
+ Longlong_hybrid value(val_int(), unsigned_flag);
+ return null_value || int_to_datetime_with_warn(thd, value,
+ ltime, fuzzydate,
+ field_table_or_null(),
+ field_name_or_null());
+}
+
+
+bool Item::get_date_from_real(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+{
+ double value= val_real();
+ return null_value || double_to_datetime_with_warn(thd, value,
+ ltime, fuzzydate,
+ field_table_or_null(),
+ field_name_or_null());
+}
+
+
+bool Item::get_date_from_string(THD *thd, MYSQL_TIME *to, date_mode_t mode)
+{
+ StringBuffer<MAX_DATETIME_FULL_WIDTH+1> tmp;
+ const TABLE_SHARE *s = field_table_or_null();
+ Temporal::Warn_push warn(thd, s ? s->db.str : nullptr,
+ s ? s->table_name.str : nullptr,
+ field_name_or_null(), to, mode);
+ Temporal_hybrid *t= new(to) Temporal_hybrid(thd, &warn, val_str(&tmp), mode);
+ return !t->is_valid_temporal();
+}
+
+
+const MY_LOCALE *Item::locale_from_val_str()
+{
+ StringBuffer<MAX_FIELD_WIDTH> tmp;
+ String *locale_name= val_str_ascii(&tmp);
+ const MY_LOCALE *lc;
+ if (!locale_name ||
+ !(lc= my_locale_by_name(locale_name->c_ptr_safe())))
+ {
+ THD *thd= current_thd;
+ push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+ ER_UNKNOWN_LOCALE,
+ ER_THD(thd, ER_UNKNOWN_LOCALE),
+ locale_name ? locale_name->c_ptr_safe() : "NULL");
+ lc= &my_locale_en_US;
+ }
+ return lc;
+}
+
+
+CHARSET_INFO *Item::default_charset()
+{
+ return current_thd->variables.collation_connection;
+}
+
+
+/*
+ Save value in field, but don't give any warnings
+
+ NOTES
+ This is used to temporary store and retrieve a value in a column,
+ for example in opt_range to adjust the key value to fit the column.
+*/
+
+int Item::save_in_field_no_warnings(Field *field, bool no_conversions)
+{
+ int res;
+ TABLE *table= field->table;
+ THD *thd= table->in_use;
+ Check_level_instant_set check_level_save(thd, CHECK_FIELD_IGNORE);
+ Sql_mode_save sms(thd);
+ thd->variables.sql_mode&= ~(MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE);
+ thd->variables.sql_mode|= MODE_INVALID_DATES;
+ MY_BITMAP *old_map= dbug_tmp_use_all_columns(table, &table->write_set);
+ res= save_in_field(field, no_conversions);
+ dbug_tmp_restore_column_map(&table->write_set, old_map);
+ return res;
+}
+
+#ifndef DBUG_OFF
+static inline
+void mark_unsupported_func(const char *where, const char *processor_name)
+{
+ char buff[64];
+ my_snprintf(buff, sizeof(buff), "%s::%s", where ? where: "", processor_name);
+ DBUG_ENTER(buff);
+ my_snprintf(buff, sizeof(buff), "%s returns TRUE: unsupported function", processor_name);
+ DBUG_PRINT("info", ("%s", buff));
+ DBUG_VOID_RETURN;
+}
+#else
+#define mark_unsupported_func(X,Y) {}
+#endif
+
+bool mark_unsupported_function(const char *where, void *store, uint result)
+{
+ Item::vcol_func_processor_result *res=
+ (Item::vcol_func_processor_result*) store;
+ uint old_errors= res->errors;
+ mark_unsupported_func(where, "check_vcol_func_processor");
+ res->errors|= result; /* Store type of expression */
+ /* Store the name to the highest violation (normally VCOL_IMPOSSIBLE) */
+ if (result > old_errors)
+ res->name= where ? where : "";
+ return false;
+}
+
+/* convenience helper for mark_unsupported_function() above */
+bool mark_unsupported_function(const char *w1, const char *w2,
+ void *store, uint result)
+{
+ char *ptr= (char*)current_thd->alloc(strlen(w1) + strlen(w2) + 1);
+ if (ptr)
+ strxmov(ptr, w1, w2, NullS);
+ return mark_unsupported_function(ptr, store, result);
+}
+
+
+bool Item_field::check_vcol_func_processor(void *arg)
+{
+ context= 0;
+ vcol_func_processor_result *res= (vcol_func_processor_result *) arg;
+ if (res && res->alter_info)
+ {
+ for (Key &k: res->alter_info->key_list)
+ {
+ if (k.type != Key::FOREIGN_KEY)
+ continue;
+ Foreign_key *fk= (Foreign_key*) &k;
+ if (fk->update_opt != FK_OPTION_CASCADE)
+ continue;
+ for (Key_part_spec& kp: fk->columns)
+ {
+ if (!lex_string_cmp(system_charset_info, &kp.field_name, &field_name))
+ {
+ return mark_unsupported_function(field_name.str, arg, VCOL_IMPOSSIBLE);
+ }
+ }
+ }
+ }
+ if (field && (field->unireg_check == Field::NEXT_NUMBER))
+ {
+ // Auto increment fields are unsupported
+ return mark_unsupported_function(field_name.str, arg, VCOL_FIELD_REF | VCOL_AUTO_INC);
+ }
+ return mark_unsupported_function(field_name.str, arg, VCOL_FIELD_REF);
+}
+
+
+Query_fragment::Query_fragment(THD *thd, sp_head *sphead,
+ const char *start, const char *end)
+{
+ DBUG_ASSERT(start <= end);
+ if (thd->lex->clone_spec_offset)
+ {
+ Lex_input_stream *lip= (& thd->m_parser_state->m_lip);
+ DBUG_ASSERT(lip->get_buf() <= start);
+ DBUG_ASSERT(end <= lip->get_end_of_query());
+ set(start - lip->get_buf(), end - start);
+ }
+ else if (sphead)
+ {
+ if (sphead->m_tmp_query)
+ {
+ // Normal SP statement
+ DBUG_ASSERT(sphead->m_tmp_query <= start);
+ set(start - sphead->m_tmp_query, end - start);
+ }
+ else
+ {
+ /*
+ We're in the "if" expression of a compound query:
+ if (expr)
+ do_something;
+ end if;
+ sphead->m_tmp_query is not set yet at this point, because
+ the "if" part of such statements is never put into the binary log.
+ Values of Rewritable_query_parameter::pos_in_query and
+ Rewritable_query_parameter:len_in_query will not be important,
+ so setting both to 0 should be fine.
+ */
+ set(0, 0);
+ }
+ }
+ else
+ {
+ // Non-SP statement
+ DBUG_ASSERT(thd->query() <= start);
+ DBUG_ASSERT(end <= thd->query_end());
+ set(start - thd->query(), end - start);
+ }
+}
+
+
+/*****************************************************************************
+ Item_sp_variable methods
+*****************************************************************************/
+
+Item_sp_variable::Item_sp_variable(THD *thd, const LEX_CSTRING *sp_var_name)
+ :Item_fixed_hybrid(thd), m_thd(0), m_name(*sp_var_name)
+#ifndef DBUG_OFF
+ , m_sp(0)
+#endif
+{
+}
+
+
+bool Item_sp_variable::fix_fields_from_item(THD *thd, Item **, const Item *it)
+{
+ m_thd= thd; /* NOTE: this must be set before any this_xxx() */
+
+ DBUG_ASSERT(it->is_fixed());
+
+ max_length= it->max_length;
+ decimals= it->decimals;
+ unsigned_flag= it->unsigned_flag;
+ with_param= 1;
+ if (thd->lex->current_select && thd->lex->current_select->master_unit()->item)
+ thd->lex->current_select->master_unit()->item->with_param= 1;
+ fixed= 1;
+ collation.set(it->collation.collation, it->collation.derivation);
+
+ return FALSE;
+}
+
+
+double Item_sp_variable::val_real()
+{
+ DBUG_ASSERT(fixed);
+ Item *it= this_item();
+ double ret= it->val_real();
+ null_value= it->null_value;
+ return ret;
+}
+
+
+longlong Item_sp_variable::val_int()
+{
+ DBUG_ASSERT(fixed);
+ Item *it= this_item();
+ longlong ret= it->val_int();
+ null_value= it->null_value;
+ return ret;
+}
+
+
+String *Item_sp_variable::val_str(String *sp)
+{
+ DBUG_ASSERT(fixed);
+ Item *it= this_item();
+ String *res= it->val_str(sp);
+
+ null_value= it->null_value;
+
+ if (!res)
+ return NULL;
+
+ /*
+ This way we mark returned value of val_str as const,
+ so that various functions (e.g. CONCAT) won't try to
+ modify the value of the Item. Analogous mechanism is
+ implemented for Item_param.
+ Without this trick Item_splocal could be changed as a
+ side-effect of expression computation. Here is an example
+ of what happens without it: suppose x is varchar local
+ variable in a SP with initial value 'ab' Then
+ select concat(x,'c');
+ would change x's value to 'abc', as Item_func_concat::val_str()
+ would use x's internal buffer to compute the result.
+ This is intended behaviour of Item_func_concat. Comments to
+ Item_param class contain some more details on the topic.
+ */
+
+ if (res != &str_value)
+ str_value.set(res->ptr(), res->length(), res->charset());
+ else
+ res->mark_as_const();
+
+ return &str_value;
+}
+
+
+bool Item_sp_variable::val_native(THD *thd, Native *to)
+{
+ return val_native_from_item(thd, this_item(), to);
+}
+
+
+my_decimal *Item_sp_variable::val_decimal(my_decimal *decimal_value)
+{
+ DBUG_ASSERT(fixed);
+ Item *it= this_item();
+ my_decimal *val= it->val_decimal(decimal_value);
+ null_value= it->null_value;
+ return val;
+}
+
+
+bool Item_sp_variable::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+{
+ DBUG_ASSERT(fixed);
+ Item *it= this_item();
+ bool val= it->get_date(thd, ltime, fuzzydate);
+ null_value= it->null_value;
+ return val;
+}
+
+
+bool Item_sp_variable::is_null()
+{
+ return this_item()->is_null();
+}
+
+void Item_sp_variable::make_send_field(THD *thd, Send_field *field)
+{
+ Item *it= this_item();
+
+ it->make_send_field(thd, field);
+ if (name.str)
+ field->col_name= name;
+ else
+ field->col_name= m_name;
+}
+
+/*****************************************************************************
+ Item_splocal methods
+*****************************************************************************/
+
+Item_splocal::Item_splocal(THD *thd,
+ const Sp_rcontext_handler *rh,
+ const LEX_CSTRING *sp_var_name,
+ uint sp_var_idx,
+ const Type_handler *handler,
+ uint pos_in_q, uint len_in_q):
+ Item_sp_variable(thd, sp_var_name),
+ Rewritable_query_parameter(pos_in_q, len_in_q),
+ Type_handler_hybrid_field_type(handler),
+ m_rcontext_handler(rh),
+ m_var_idx(sp_var_idx),
+ m_type(handler == &type_handler_row ? ROW_ITEM : CONST_ITEM)
+{
+ maybe_null= TRUE;
+}
+
+
+sp_rcontext *Item_splocal::get_rcontext(sp_rcontext *local_ctx) const
+{
+ return m_rcontext_handler->get_rcontext(local_ctx);
+}
+
+
+Item_field *Item_splocal::get_variable(sp_rcontext *ctx) const
+{
+ return get_rcontext(ctx)->get_variable(m_var_idx);
+}
+
+
+bool Item_splocal::fix_fields(THD *thd, Item **ref)
+{
+ DBUG_ASSERT(!fixed);
+ Item *item= get_variable(thd->spcont);
+ set_handler(item->type_handler());
+ return fix_fields_from_item(thd, ref, item);
+}
+
+
+Item *
+Item_splocal::this_item()
+{
+ DBUG_ASSERT(m_sp == m_thd->spcont->m_sp);
+ DBUG_ASSERT(fixed);
+ return get_variable(m_thd->spcont);
+}
+
+const Item *
+Item_splocal::this_item() const
+{
+ DBUG_ASSERT(m_sp == m_thd->spcont->m_sp);
+ DBUG_ASSERT(fixed);
+ return get_variable(m_thd->spcont);
+}
+
+
+Item **
+Item_splocal::this_item_addr(THD *thd, Item **)
+{
+ DBUG_ASSERT(m_sp == thd->spcont->m_sp);
+ DBUG_ASSERT(fixed);
+ return get_rcontext(thd->spcont)->get_variable_addr(m_var_idx);
+}
+
+
+void Item_splocal::print(String *str, enum_query_type)
+{
+ const LEX_CSTRING *prefix= m_rcontext_handler->get_name_prefix();
+ str->reserve(m_name.length + 8 + prefix->length);
+ str->append(prefix);
+ str->append(&m_name);
+ str->append('@');
+ str->qs_append(m_var_idx);
+}
+
+
+bool Item_splocal::set_value(THD *thd, sp_rcontext *ctx, Item **it)
+{
+ return get_rcontext(ctx)->set_variable(thd, get_var_idx(), it);
+}
+
+
+/**
+ These two declarations are different:
+ x INT;
+ ROW(x INT);
+ A ROW with one elements should not be comparable to scalar value.
+
+ TODO: Currently we don't support one argument with the function ROW(), so
+ this query returns a syntax error, meaning that more arguments are expected:
+ SELECT ROW(1);
+
+ Therefore, all around the code we assume that cols()==1 means a scalar value
+ and cols()>1 means a ROW value. With adding ROW SP variables this
+ assumption is not true any more. ROW variables with one element are
+ now possible.
+
+ To implement Item::check_cols() correctly, we now should extend it to
+ know if a ROW or a scalar value is being tested. For example,
+ these new prototypes should work:
+ virtual bool check_cols(Item_result result, uint c);
+ or
+ virtual bool check_cols(const Type_handler *type, uint c);
+
+ The current implementation of Item_splocal::check_cols() is a compromise
+ that should be more or less fine until we extend check_cols().
+ It disallows ROW variables to appear in a scalar context.
+ The "|| n == 1" part of the conditon is responsible for this.
+ For example, it disallows ROW variables to appear in SELECT list:
+
+DELIMITER $$;
+CREATE PROCEDURE p1()
+AS
+ a ROW (a INT);
+BEGIN
+ SELECT a;
+END;
+$$
+DELIMITER ;$$
+--error ER_OPERAND_COLUMNS
+CALL p1();
+
+ But is produces false negatives with ROW variables consisting of one element.
+ For example, this script fails:
+
+SET sql_mode=ORACLE;
+DROP PROCEDURE IF EXISTS p1;
+DELIMITER $$
+CREATE PROCEDURE p1
+AS
+ a ROW(a INT);
+ b ROW(a INT);
+BEGIN
+ SELECT a=b;
+END;
+$$
+DELIMITER ;
+CALL p1();
+
+ and returns "ERROR 1241 (21000): Operand should contain 1 column(s)".
+ This will be fixed that we change check_cols().
+*/
+
+bool Item_splocal::check_cols(uint n)
+{
+ DBUG_ASSERT(m_thd->spcont);
+ if (Type_handler_hybrid_field_type::cmp_type() != ROW_RESULT)
+ return Item::check_cols(n);
+
+ if (n != this_item()->cols() || n == 1)
+ {
+ my_error(ER_OPERAND_COLUMNS, MYF(0), n);
+ return true;
+ }
+ return false;
+}
+
+
+bool Item_splocal_row_field::fix_fields(THD *thd, Item **ref)
+{
+ DBUG_ASSERT(!fixed);
+ Item *item= get_variable(thd->spcont)->element_index(m_field_idx);
+ return fix_fields_from_item(thd, ref, item);
+}
+
+
+Item *
+Item_splocal_row_field::this_item()
+{
+ DBUG_ASSERT(m_sp == m_thd->spcont->m_sp);
+ DBUG_ASSERT(fixed);
+ return get_variable(m_thd->spcont)->element_index(m_field_idx);
+}
+
+
+const Item *
+Item_splocal_row_field::this_item() const
+{
+ DBUG_ASSERT(m_sp == m_thd->spcont->m_sp);
+ DBUG_ASSERT(fixed);
+ return get_variable(m_thd->spcont)->element_index(m_field_idx);
+}
+
+
+Item **
+Item_splocal_row_field::this_item_addr(THD *thd, Item **)
+{
+ DBUG_ASSERT(m_sp == thd->spcont->m_sp);
+ DBUG_ASSERT(fixed);
+ return get_variable(thd->spcont)->addr(m_field_idx);
+}
+
+
+void Item_splocal_row_field::print(String *str, enum_query_type)
+{
+ const LEX_CSTRING *prefix= m_rcontext_handler->get_name_prefix();
+ str->reserve(m_name.length + m_field_name.length + 8 + prefix->length);
+ str->append(prefix);
+ str->append(&m_name);
+ str->append('.');
+ str->append(&m_field_name);
+ str->append('@');
+ str->qs_append(m_var_idx);
+ str->append('[');
+ str->qs_append(m_field_idx);
+ str->append(']');
+}
+
+
+bool Item_splocal_row_field::set_value(THD *thd, sp_rcontext *ctx, Item **it)
+{
+ return get_rcontext(ctx)->set_variable_row_field(thd, m_var_idx, m_field_idx,
+ it);
+}
+
+
+bool Item_splocal_row_field_by_name::fix_fields(THD *thd, Item **it)
+{
+ DBUG_ASSERT(!fixed);
+ m_thd= thd;
+ if (get_rcontext(thd->spcont)->find_row_field_by_name_or_error(&m_field_idx,
+ m_var_idx,
+ m_field_name))
+ return true;
+ Item *item= get_variable(thd->spcont)->element_index(m_field_idx);
+ set_handler(item->type_handler());
+ return fix_fields_from_item(thd, it, item);
+}
+
+
+void Item_splocal_row_field_by_name::print(String *str, enum_query_type)
+{
+ const LEX_CSTRING *prefix= m_rcontext_handler->get_name_prefix();
+ // +16 should be enough for .NNN@[""]
+ if (str->reserve(m_name.length + 2 * m_field_name.length +
+ prefix->length + 16))
+ return;
+ str->qs_append(prefix);
+ str->qs_append(&m_name);
+ str->qs_append('.');
+ str->qs_append(&m_field_name);
+ str->qs_append('@');
+ str->qs_append(m_var_idx);
+ str->qs_append("[\"", 2);
+ str->qs_append(&m_field_name);
+ str->qs_append("\"]", 2);
+}
+
+
+bool Item_splocal_row_field_by_name::set_value(THD *thd, sp_rcontext *ctx, Item **it)
+{
+ DBUG_ASSERT(fixed); // Make sure m_field_idx is already set
+ return Item_splocal_row_field::set_value(thd, ctx, it);
+}
+
+
+/*****************************************************************************
+ Item_case_expr methods
+*****************************************************************************/
+
+LEX_CSTRING str_case_expr= { STRING_WITH_LEN("case_expr") };
+
+Item_case_expr::Item_case_expr(THD *thd, uint case_expr_id):
+ Item_sp_variable(thd, &str_case_expr),
+ m_case_expr_id(case_expr_id)
+{
+}
+
+
+bool Item_case_expr::fix_fields(THD *thd, Item **ref)
+{
+ Item *item= thd->spcont->get_case_expr(m_case_expr_id);
+ return fix_fields_from_item(thd, ref, item);
+}
+
+
+Item *
+Item_case_expr::this_item()
+{
+ DBUG_ASSERT(m_sp == m_thd->spcont->m_sp);
+
+ return m_thd->spcont->get_case_expr(m_case_expr_id);
+}
+
+
+
+const Item *
+Item_case_expr::this_item() const
+{
+ DBUG_ASSERT(m_sp == m_thd->spcont->m_sp);
+
+ return m_thd->spcont->get_case_expr(m_case_expr_id);
+}
+
+
+Item **
+Item_case_expr::this_item_addr(THD *thd, Item **)
+{
+ DBUG_ASSERT(m_sp == thd->spcont->m_sp);
+
+ return thd->spcont->get_case_expr_addr(m_case_expr_id);
+}
+
+
+void Item_case_expr::print(String *str, enum_query_type)
+{
+ if (str->reserve(MAX_INT_WIDTH + sizeof("case_expr@")))
+ return; /* purecov: inspected */
+ (void) str->append(STRING_WITH_LEN("case_expr@"));
+ str->qs_append(m_case_expr_id);
+}
+
+
+/*****************************************************************************
+ Item_name_const methods
+*****************************************************************************/
+
+double Item_name_const::val_real()
+{
+ DBUG_ASSERT(fixed);
+ double ret= value_item->val_real();
+ null_value= value_item->null_value;
+ return ret;
+}
+
+
+longlong Item_name_const::val_int()
+{
+ DBUG_ASSERT(fixed);
+ longlong ret= value_item->val_int();
+ null_value= value_item->null_value;
+ return ret;
+}
+
+
+String *Item_name_const::val_str(String *sp)
+{
+ DBUG_ASSERT(fixed);
+ String *ret= value_item->val_str(sp);
+ null_value= value_item->null_value;
+ return ret;
+}
+
+
+my_decimal *Item_name_const::val_decimal(my_decimal *decimal_value)
+{
+ DBUG_ASSERT(fixed);
+ my_decimal *val= value_item->val_decimal(decimal_value);
+ null_value= value_item->null_value;
+ return val;
+}
+
+bool Item_name_const::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+{
+ DBUG_ASSERT(fixed);
+ bool rc= value_item->get_date(thd, ltime, fuzzydate);
+ null_value= value_item->null_value;
+ return rc;
+}
+
+bool Item_name_const::val_native(THD *thd, Native *to)
+{
+ return val_native_from_item(thd, value_item, to);
+}
+
+bool Item_name_const::is_null()
+{
+ return value_item->is_null();
+}
+
+
+Item_name_const::Item_name_const(THD *thd, Item *name_arg, Item *val):
+ Item_fixed_hybrid(thd), value_item(val), name_item(name_arg)
+{
+ StringBuffer<128> name_buffer;
+ String *name_str;
+ Item::maybe_null= TRUE;
+ if (name_item->basic_const_item() &&
+ (name_str= name_item->val_str(&name_buffer))) // Can't have a NULL name
+ set_name(thd, name_str);
+}
+
+
+Item::Type Item_name_const::type() const
+{
+ /*
+
+ We are guarenteed that value_item->basic_const_item(), if not
+ an error is thrown that WRONG ARGUMENTS are supplied to
+ NAME_CONST function.
+ If type is FUNC_ITEM, then we have a fudged item_func_neg()
+ on our hands and return the underlying type.
+ For Item_func_set_collation()
+ e.g. NAME_CONST('name', 'value' COLLATE collation) we return its
+ 'value' argument type.
+ */
+ Item::Type value_type= value_item->type();
+ if (value_type == FUNC_ITEM)
+ {
+ /*
+ The second argument of NAME_CONST('name', 'value') must be
+ a simple constant item or a NEG_FUNC/COLLATE_FUNC.
+ */
+ DBUG_ASSERT(((Item_func *) value_item)->functype() ==
+ Item_func::NEG_FUNC ||
+ ((Item_func *) value_item)->functype() ==
+ Item_func::COLLATE_FUNC);
+ return ((Item_func *) value_item)->key_item()->type();
+ }
+ return value_type;
+}
+
+
+bool Item_name_const::fix_fields(THD *thd, Item **ref)
+{
+ if (value_item->fix_fields_if_needed(thd, &value_item) ||
+ name_item->fix_fields_if_needed(thd, &name_item) ||
+ !value_item->const_item() ||
+ !name_item->const_item())
+ {
+ my_error(ER_RESERVED_SYNTAX, MYF(0), "NAME_CONST");
+ return TRUE;
+ }
+ if (value_item->collation.derivation == DERIVATION_NUMERIC)
+ collation= DTCollation_numeric();
+ else
+ collation.set(value_item->collation.collation, DERIVATION_IMPLICIT);
+ max_length= value_item->max_length;
+ decimals= value_item->decimals;
+ unsigned_flag= value_item->unsigned_flag;
+ fixed= 1;
+ return FALSE;
+}
+
+
+void Item_name_const::print(String *str, enum_query_type query_type)
+{
+ str->append(STRING_WITH_LEN("NAME_CONST("));
+ name_item->print(str, query_type);
+ str->append(',');
+ value_item->print(str, query_type);
+ str->append(')');
+}
+
+
+/*
+ need a special class to adjust printing : references to aggregate functions
+ must not be printed as refs because the aggregate functions that are added to
+ the front of select list are not printed as well.
+*/
+class Item_aggregate_ref : public Item_ref
+{
+public:
+ Item_aggregate_ref(THD *thd, Name_resolution_context *context_arg,
+ Item **item, const LEX_CSTRING &table_name_arg,
+ const LEX_CSTRING &field_name_arg):
+ Item_ref(thd, context_arg, item, table_name_arg, field_name_arg) {}
+
+ void print (String *str, enum_query_type query_type) override
+ {
+ if (ref)
+ (*ref)->print(str, query_type);
+ else
+ Item_ident::print(str, query_type);
+ }
+ Ref_Type ref_type() override final { return AGGREGATE_REF; }
+};
+
+
+/**
+ Move SUM items out from item tree and replace with reference.
+
+ @param thd Thread handler
+ @param ref_pointer_array Pointer to array of reference fields
+ @param fields All fields in select
+ @param ref Pointer to item
+ @param split_flags Zero or more of the following flags
+ SPLIT_FUNC_SKIP_REGISTERED:
+ Function be must skipped for registered SUM
+ SUM items
+ SPLIT_SUM_SELECT
+ We are called on the select level and have to
+ register items operated on sum function
+
+ @note
+ All found SUM items are added FIRST in the fields list and
+ we replace the item with a reference.
+
+ If this is an item in the SELECT list then we also have to split out
+ all arguments to functions used together with the sum function.
+ For example in case of SELECT A*sum(B) we have to split out both
+ A and sum(B).
+ This is not needed for ORDER BY, GROUP BY or HAVING as all references
+ to items in the select list are already of type REF
+
+ thd->fatal_error() may be called if we are out of memory
+*/
+
+void Item::split_sum_func2(THD *thd, Ref_ptr_array ref_pointer_array,
+ List<Item> &fields, Item **ref,
+ uint split_flags)
+{
+ if (unlikely(type() == SUM_FUNC_ITEM))
+ {
+ /* An item of type Item_sum is registered if ref_by != 0 */
+ if ((split_flags & SPLIT_SUM_SKIP_REGISTERED) &&
+ ((Item_sum *) this)->ref_by)
+ return;
+ }
+ else if (type() == WINDOW_FUNC_ITEM || with_window_func)
+ {
+ /*
+ Skip the else part, window functions are very special functions:
+ they need to have their own fields in the temp. table, but they
+ need to be proceessed differently than regular aggregate functions
+
+ Call split_sum_func here so that each argument gets its fields to
+ point to the temporary table.
+ */
+ split_sum_func(thd, ref_pointer_array, fields, split_flags);
+ if (type() == FUNC_ITEM) {
+ return;
+ }
+ }
+ else
+ {
+ /* Not a SUM() function */
+ if (unlikely((!with_sum_func() && !(split_flags & SPLIT_SUM_SELECT))))
+ {
+ /*
+ This is not a SUM function and there are no SUM functions inside.
+ Nothing more to do.
+ */
+ return;
+ }
+ if (likely(with_sum_func() ||
+ (type() == FUNC_ITEM &&
+ (((Item_func *) this)->functype() ==
+ Item_func::ISNOTNULLTEST_FUNC ||
+ ((Item_func *) this)->functype() ==
+ Item_func::TRIG_COND_FUNC))))
+ {
+ /* Will call split_sum_func2() for all items */
+ split_sum_func(thd, ref_pointer_array, fields, split_flags);
+ return;
+ }
+
+ if (unlikely((!(used_tables() & ~PARAM_TABLE_BIT) ||
+ (type() == REF_ITEM &&
+ ((Item_ref*)this)->ref_type() != Item_ref::VIEW_REF))))
+ return;
+ }
+
+ /*
+ Replace item with a reference so that we can easily calculate
+ it (in case of sum functions) or copy it (in case of fields)
+
+ The test above is to ensure we don't do a reference for things
+ that are constants (PARAM_TABLE_BIT is in effect a constant)
+ or already referenced (for example an item in HAVING)
+ Exception is Item_direct_view_ref which we need to convert to
+ Item_ref to allow fields from view being stored in tmp table.
+ */
+ Item_ref *item_ref;
+ uint el= fields.elements;
+ /*
+ If this is an item_ref, get the original item
+ This is a safety measure if this is called for things that is
+ already a reference.
+ */
+ Item *real_itm= real_item();
+ ref_pointer_array[el]= real_itm;
+ if (type() == WINDOW_FUNC_ITEM)
+ {
+ if (!(item_ref= (new (thd->mem_root)
+ Item_direct_ref(thd,
+ &thd->lex->current_select->context,
+ &ref_pointer_array[el],
+ null_clex_str, name))))
+ return; // fatal_error is set
+ }
+ else
+ {
+ if (!(item_ref= (new (thd->mem_root)
+ Item_aggregate_ref(thd,
+ &thd->lex->current_select->context,
+ &ref_pointer_array[el],
+ null_clex_str, name))))
+ return; // fatal_error is set
+ }
+ if (type() == SUM_FUNC_ITEM)
+ item_ref->depended_from= ((Item_sum *) this)->depended_from();
+ fields.push_front(real_itm);
+ thd->change_item_tree(ref, item_ref);
+}
+
+
+static bool
+left_is_superset(const DTCollation *left, const DTCollation *right)
+{
+ /* Allow convert to Unicode */
+ if (left->collation->state & MY_CS_UNICODE &&
+ (left->derivation < right->derivation ||
+ (left->derivation == right->derivation &&
+ (!(right->collation->state & MY_CS_UNICODE) ||
+ /* The code below makes 4-byte utf8 a superset over 3-byte utf8 */
+ (left->collation->state & MY_CS_UNICODE_SUPPLEMENT &&
+ !(right->collation->state & MY_CS_UNICODE_SUPPLEMENT) &&
+ left->collation->mbmaxlen > right->collation->mbmaxlen &&
+ left->collation->mbminlen == right->collation->mbminlen)))))
+ return TRUE;
+ /* Allow convert from ASCII */
+ if (right->repertoire == MY_REPERTOIRE_ASCII &&
+ (left->derivation < right->derivation ||
+ (left->derivation == right->derivation &&
+ !(left->repertoire == MY_REPERTOIRE_ASCII))))
+ return TRUE;
+ /* Disallow conversion otherwise */
+ return FALSE;
+}
+
+/**
+ Aggregate two collations together taking
+ into account their coercibility (aka derivation):.
+
+ 0 == DERIVATION_EXPLICIT - an explicitly written COLLATE clause @n
+ 1 == DERIVATION_NONE - a mix of two different collations @n
+ 2 == DERIVATION_IMPLICIT - a column @n
+ 3 == DERIVATION_COERCIBLE - a string constant.
+
+ The most important rules are:
+ -# If collations are the same:
+ chose this collation, and the strongest derivation.
+ -# If collations are different:
+ - Character sets may differ, but only if conversion without
+ data loss is possible. The caller provides flags whether
+ character set conversion attempts should be done. If no
+ flags are substituted, then the character sets must be the same.
+ Currently processed flags are:
+ MY_COLL_ALLOW_SUPERSET_CONV - allow conversion to a superset
+ MY_COLL_ALLOW_COERCIBLE_CONV - allow conversion of a coercible value
+ - two EXPLICIT collations produce an error, e.g. this is wrong:
+ CONCAT(expr1 collate latin1_swedish_ci, expr2 collate latin1_german_ci)
+ - the side with smaller derivation value wins,
+ i.e. a column is stronger than a string constant,
+ an explicit COLLATE clause is stronger than a column.
+ - if derivations are the same, we have DERIVATION_NONE,
+ we'll wait for an explicit COLLATE clause which possibly can
+ come from another argument later: for example, this is valid,
+ but we don't know yet when collecting the first two arguments:
+ @code
+ CONCAT(latin1_swedish_ci_column,
+ latin1_german1_ci_column,
+ expr COLLATE latin1_german2_ci)
+ @endcode
+*/
+
+bool DTCollation::aggregate(const DTCollation &dt, uint flags)
+{
+ if (!my_charset_same(collation, dt.collation))
+ {
+ /*
+ We do allow to use binary strings (like BLOBS)
+ together with character strings.
+ Binaries have more precedence than a character
+ string of the same derivation.
+ */
+ if (collation == &my_charset_bin)
+ {
+ if (derivation <= dt.derivation)
+ {
+ /* Do nothing */
+ }
+ else
+ {
+ set(dt);
+ }
+ }
+ else if (dt.collation == &my_charset_bin)
+ {
+ if (dt.derivation <= derivation)
+ {
+ set(dt);
+ }
+ }
+ else if ((flags & MY_COLL_ALLOW_SUPERSET_CONV) &&
+ left_is_superset(this, &dt))
+ {
+ /* Do nothing */
+ }
+ else if ((flags & MY_COLL_ALLOW_SUPERSET_CONV) &&
+ left_is_superset(&dt, this))
+ {
+ set(dt);
+ }
+ else if ((flags & MY_COLL_ALLOW_COERCIBLE_CONV) &&
+ derivation < dt.derivation &&
+ dt.derivation >= DERIVATION_SYSCONST)
+ {
+ /* Do nothing */
+ }
+ else if ((flags & MY_COLL_ALLOW_COERCIBLE_CONV) &&
+ dt.derivation < derivation &&
+ derivation >= DERIVATION_SYSCONST)
+ {
+ set(dt);
+ }
+ else
+ {
+ // Cannot apply conversion
+ set(&my_charset_bin, DERIVATION_NONE,
+ (dt.repertoire|repertoire));
+ return 1;
+ }
+ }
+ else if (derivation < dt.derivation)
+ {
+ /* Do nothing */
+ }
+ else if (dt.derivation < derivation)
+ {
+ set(dt);
+ }
+ else
+ {
+ if (collation == dt.collation)
+ {
+ /* Do nothing */
+ }
+ else
+ {
+ if (derivation == DERIVATION_EXPLICIT)
+ {
+ set(0, DERIVATION_NONE, MY_REPERTOIRE_NONE);
+ return 1;
+ }
+ if (collation->state & MY_CS_BINSORT &&
+ dt.collation->state & MY_CS_BINSORT)
+ return 1;
+ if (collation->state & MY_CS_BINSORT)
+ return 0;
+ if (dt.collation->state & MY_CS_BINSORT)
+ {
+ set(dt);
+ return 0;
+ }
+ CHARSET_INFO *bin= get_charset_by_csname(collation->csname,
+ MY_CS_BINSORT,MYF(0));
+ set(bin, DERIVATION_NONE);
+ }
+ }
+ repertoire|= dt.repertoire;
+ return 0;
+}
+
+/******************************/
+static
+void my_coll_agg_error(DTCollation &c1, DTCollation &c2, const char *fname)
+{
+ my_error(ER_CANT_AGGREGATE_2COLLATIONS,MYF(0),
+ c1.collation->name,c1.derivation_name(),
+ c2.collation->name,c2.derivation_name(),
+ fname);
+}
+
+
+static
+void my_coll_agg_error(DTCollation &c1, DTCollation &c2, DTCollation &c3,
+ const char *fname)
+{
+ my_error(ER_CANT_AGGREGATE_3COLLATIONS,MYF(0),
+ c1.collation->name,c1.derivation_name(),
+ c2.collation->name,c2.derivation_name(),
+ c3.collation->name,c3.derivation_name(),
+ fname);
+}
+
+
+static
+void my_coll_agg_error(Item** args, uint count, const char *fname,
+ int item_sep)
+{
+ if (count == 2)
+ my_coll_agg_error(args[0]->collation, args[item_sep]->collation, fname);
+ else if (count == 3)
+ my_coll_agg_error(args[0]->collation, args[item_sep]->collation,
+ args[2*item_sep]->collation, fname);
+ else
+ my_error(ER_CANT_AGGREGATE_NCOLLATIONS,MYF(0),fname);
+}
+
+
+bool Type_std_attributes::agg_item_collations(DTCollation &c, const char *fname,
+ Item **av, uint count,
+ uint flags, int item_sep)
+{
+ uint i;
+ Item **arg;
+ bool unknown_cs= 0;
+
+ c.set(av[0]->collation);
+ for (i= 1, arg= &av[item_sep]; i < count; i++, arg+= item_sep)
+ {
+ if (c.aggregate((*arg)->collation, flags))
+ {
+ if (c.derivation == DERIVATION_NONE &&
+ c.collation == &my_charset_bin)
+ {
+ unknown_cs= 1;
+ continue;
+ }
+ my_coll_agg_error(av, count, fname, item_sep);
+ return TRUE;
+ }
+ }
+
+ if (unknown_cs &&
+ c.derivation != DERIVATION_EXPLICIT)
+ {
+ my_coll_agg_error(av, count, fname, item_sep);
+ return TRUE;
+ }
+
+ if ((flags & MY_COLL_DISALLOW_NONE) &&
+ c.derivation == DERIVATION_NONE)
+ {
+ my_coll_agg_error(av, count, fname, item_sep);
+ return TRUE;
+ }
+
+ /* If all arguments where numbers, reset to @@collation_connection */
+ if (flags & MY_COLL_ALLOW_NUMERIC_CONV &&
+ c.derivation == DERIVATION_NUMERIC)
+ c.set(Item::default_charset(), DERIVATION_COERCIBLE, MY_REPERTOIRE_NUMERIC);
+
+ return FALSE;
+}
+
+
+bool Type_std_attributes::agg_item_set_converter(const DTCollation &coll,
+ const char *fname,
+ Item **args, uint nargs,
+ uint flags, int item_sep)
+{
+ THD *thd= current_thd;
+ if (thd->lex->is_ps_or_view_context_analysis())
+ return false;
+ Item **arg, *safe_args[2]= {NULL, NULL};
+
+ /*
+ For better error reporting: save the first and the second argument.
+ We need this only if the the number of args is 3 or 2:
+ - for a longer argument list, "Illegal mix of collations"
+ doesn't display each argument's characteristics.
+ - if nargs is 1, then this error cannot happen.
+ */
+ if (nargs >=2 && nargs <= 3)
+ {
+ safe_args[0]= args[0];
+ safe_args[1]= args[item_sep];
+ }
+
+ bool res= FALSE;
+ uint i;
+
+ DBUG_ASSERT(!thd->stmt_arena->is_stmt_prepare());
+
+ for (i= 0, arg= args; i < nargs; i++, arg+= item_sep)
+ {
+ Item* conv= (*arg)->safe_charset_converter(thd, coll.collation);
+ if (conv == *arg)
+ continue;
+
+ if (!conv)
+ {
+ if (nargs >=2 && nargs <= 3)
+ {
+ /* restore the original arguments for better error message */
+ args[0]= safe_args[0];
+ args[item_sep]= safe_args[1];
+ }
+ my_coll_agg_error(args, nargs, fname, item_sep);
+ res= TRUE;
+ break; // we cannot return here, we need to restore "arena".
+ }
+
+ thd->change_item_tree(arg, conv);
+
+ if (conv->fix_fields_if_needed(thd, arg))
+ {
+ res= TRUE;
+ break; // we cannot return here, we need to restore "arena".
+ }
+ }
+ return res;
+}
+
+
+/**
+ @brief
+ Building clone for Item_func_or_sum
+
+ @param thd thread handle
+ @param mem_root part of the memory for the clone
+
+ @details
+ This method first builds clones of the arguments. If it is successful with
+ buiding the clones then it constructs a copy of this Item_func_or_sum object
+ and attaches to it the built clones of the arguments.
+
+ @return clone of the item
+ @retval 0 on a failure
+*/
+
+Item* Item_func_or_sum::build_clone(THD *thd)
+{
+ Item *copy_tmp_args[2]= {0,0};
+ Item **copy_args= copy_tmp_args;
+ if (arg_count > 2)
+ {
+ copy_args= static_cast<Item**>
+ (alloc_root(thd->mem_root, sizeof(Item*) * arg_count));
+ if (unlikely(!copy_args))
+ return 0;
+ }
+ for (uint i= 0; i < arg_count; i++)
+ {
+ Item *arg_clone= args[i]->build_clone(thd);
+ if (unlikely(!arg_clone))
+ return 0;
+ copy_args[i]= arg_clone;
+ }
+ Item_func_or_sum *copy= static_cast<Item_func_or_sum *>(get_copy(thd));
+ if (unlikely(!copy))
+ return 0;
+ if (arg_count > 2)
+ copy->args= copy_args;
+ else if (arg_count > 0)
+ {
+ copy->args= copy->tmp_arg;
+ memcpy(copy->args, copy_args, sizeof(Item *) * arg_count);
+ }
+ return copy;
+}
+
+Item_sp::Item_sp(THD *thd, Name_resolution_context *context_arg,
+ sp_name *name_arg) :
+ context(context_arg), m_name(name_arg), m_sp(NULL), func_ctx(NULL),
+ sp_result_field(NULL)
+{
+ dummy_table= (TABLE*) thd->calloc(sizeof(TABLE) + sizeof(TABLE_SHARE) +
+ sizeof(Query_arena));
+ dummy_table->s= (TABLE_SHARE*) (dummy_table + 1);
+ sp_query_arena= new(dummy_table->s + 1) Query_arena();
+ memset(&sp_mem_root, 0, sizeof(sp_mem_root));
+}
+
+Item_sp::Item_sp(THD *thd, Item_sp *item):
+ context(item->context), m_name(item->m_name),
+ m_sp(item->m_sp), func_ctx(NULL), sp_result_field(NULL)
+{
+ dummy_table= (TABLE*) thd->calloc(sizeof(TABLE)+ sizeof(TABLE_SHARE) +
+ sizeof(Query_arena));
+ dummy_table->s= (TABLE_SHARE*) (dummy_table+1);
+ sp_query_arena= new(dummy_table->s + 1) Query_arena();
+ memset(&sp_mem_root, 0, sizeof(sp_mem_root));
+}
+
+const char *
+Item_sp::func_name(THD *thd) const
+{
+ /* Calculate length to avoid reallocation of string for sure */
+ size_t len= (((m_name->m_explicit_name ? m_name->m_db.length : 0) +
+ m_name->m_name.length)*2 + //characters*quoting
+ 2 + // ` and `
+ (m_name->m_explicit_name ?
+ 3 : 0) + // '`', '`' and '.' for the db
+ 1 + // end of string
+ ALIGN_SIZE(1)); // to avoid String reallocation
+ String qname((char *)alloc_root(thd->mem_root, len), len,
+ system_charset_info);
+
+ qname.length(0);
+ if (m_name->m_explicit_name)
+ {
+ append_identifier(thd, &qname, &m_name->m_db);
+ qname.append('.');
+ }
+ append_identifier(thd, &qname, &m_name->m_name);
+ return qname.c_ptr_safe();
+}
+
+void
+Item_sp::cleanup()
+{
+ delete sp_result_field;
+ sp_result_field= NULL;
+ m_sp= NULL;
+ delete func_ctx;
+ func_ctx= NULL;
+ free_root(&sp_mem_root, MYF(0));
+ dummy_table->alias.free();
+}
+
+/**
+ @brief Checks if requested access to function can be granted to user.
+ If function isn't found yet, it searches function first.
+ If function can't be found or user don't have requested access
+ error is raised.
+
+ @param thd thread handler
+
+ @return Indication if the access was granted or not.
+ @retval FALSE Access is granted.
+ @retval TRUE Requested access can't be granted or function doesn't exists.
+
+*/
+bool
+Item_sp::sp_check_access(THD *thd)
+{
+ DBUG_ENTER("Item_sp::sp_check_access");
+ DBUG_ASSERT(m_sp);
+ DBUG_RETURN(m_sp->check_execute_access(thd));
+}
+
+/**
+ @brief Execute function & store value in field.
+
+ @return Function returns error status.
+ @retval FALSE on success.
+ @retval TRUE if an error occurred.
+*/
+bool Item_sp::execute(THD *thd, bool *null_value, Item **args, uint arg_count)
+{
+ if (unlikely(execute_impl(thd, args, arg_count)))
+ {
+ *null_value= 1;
+ process_error(thd);
+ if (thd->killed)
+ thd->send_kill_message();
+ return true;
+ }
+
+ /* Check that the field (the value) is not NULL. */
+
+ *null_value= sp_result_field->is_null();
+ return (*null_value);
+}
+
+/**
+ @brief Execute function and store the return value in the field.
+
+ @note This function was intended to be the concrete implementation of
+ the interface function execute. This was never realized.
+
+ @return The error state.
+ @retval FALSE on success
+ @retval TRUE if an error occurred.
+*/
+bool
+Item_sp::execute_impl(THD *thd, Item **args, uint arg_count)
+{
+ Sub_statement_state statement_state;
+ Security_context *save_security_ctx= thd->security_ctx;
+ enum enum_sp_data_access access=
+ (m_sp->daccess() == SP_DEFAULT_ACCESS) ?
+ SP_DEFAULT_ACCESS_MAPPING : m_sp->daccess();
+
+ DBUG_ENTER("Item_sp::execute_impl");
+
+ if (context && context->security_ctx)
+ {
+ /* Set view definer security context */
+ thd->security_ctx= context->security_ctx;
+ }
+
+ if (unlikely(sp_check_access(thd)))
+ {
+ thd->security_ctx= save_security_ctx;
+ DBUG_RETURN(TRUE);
+ }
+
+ /*
+ Throw an error if a non-deterministic function is called while
+ statement-based replication (SBR) is active.
+ */
+
+ if (unlikely(!m_sp->detistic() && !trust_function_creators &&
+ (access == SP_CONTAINS_SQL || access == SP_MODIFIES_SQL_DATA) &&
+ (mysql_bin_log.is_open() &&
+ thd->variables.binlog_format == BINLOG_FORMAT_STMT)))
+ {
+ my_error(ER_BINLOG_UNSAFE_ROUTINE, MYF(0));
+ thd->security_ctx= save_security_ctx;
+ DBUG_RETURN(TRUE);
+ }
+
+ /*
+ Disable the binlogging if this is not a SELECT statement. If this is a
+ SELECT, leave binlogging on, so execute_function() code writes the
+ function call into binlog.
+ */
+ thd->reset_sub_statement_state(&statement_state, SUB_STMT_FUNCTION);
+
+ /*
+ If this function is an aggregate function, we want to initialise the
+ mem_root only once per group. For a regular stored function, we will
+ initialise once for each call to execute_function.
+ */
+ m_sp->agg_type();
+ DBUG_ASSERT(m_sp->agg_type() == GROUP_AGGREGATE ||
+ (m_sp->agg_type() == NOT_AGGREGATE && !func_ctx));
+ if (!func_ctx)
+ {
+ init_sql_alloc(key_memory_sp_head_call_root, &sp_mem_root,
+ MEM_ROOT_BLOCK_SIZE, 0, MYF(0));
+ *sp_query_arena= Query_arena(&sp_mem_root,
+ Query_arena::STMT_INITIALIZED_FOR_SP);
+ }
+
+ bool err_status= m_sp->execute_function(thd, args, arg_count,
+ sp_result_field, &func_ctx,
+ sp_query_arena);
+ /*
+ We free the function context when the function finished executing normally
+ (quit_func == TRUE) or the function has exited with an error.
+ */
+ if (err_status || func_ctx->quit_func)
+ {
+ /* Free Items allocated during function execution. */
+ delete func_ctx;
+ func_ctx= NULL;
+ sp_query_arena->free_items();
+ free_root(&sp_mem_root, MYF(0));
+ memset(&sp_mem_root, 0, sizeof(sp_mem_root));
+ }
+ thd->restore_sub_statement_state(&statement_state);
+
+ thd->security_ctx= save_security_ctx;
+ DBUG_RETURN(err_status);
+}
+
+
+/**
+ @brief Initialize the result field by creating a temporary dummy table
+ and assign it to a newly created field object. Meta data used to
+ create the field is fetched from the sp_head belonging to the stored
+ proceedure found in the stored procedure functon cache.
+
+ @note This function should be called from fix_fields to init the result
+ field. It is some what related to Item_field.
+
+ @see Item_field
+
+ @param thd A pointer to the session and thread context.
+
+ @return Function return error status.
+ @retval TRUE is returned on an error
+ @retval FALSE is returned on success.
+*/
+
+bool
+Item_sp::init_result_field(THD *thd, uint max_length, uint maybe_null,
+ bool *null_value, LEX_CSTRING *name)
+{
+ DBUG_ENTER("Item_sp::init_result_field");
+
+ DBUG_ASSERT(m_sp != NULL);
+ DBUG_ASSERT(sp_result_field == NULL);
+
+ /*
+ A Field needs to be attached to a Table.
+ Below we "create" a dummy table by initializing
+ the needed pointers.
+ */
+ dummy_table->alias.set("", 0, table_alias_charset);
+ dummy_table->in_use= thd;
+ dummy_table->copy_blobs= TRUE;
+ dummy_table->s->table_cache_key= empty_clex_str;
+ dummy_table->s->table_name= empty_clex_str;
+ dummy_table->maybe_null= maybe_null;
+
+ if (!(sp_result_field= m_sp->create_result_field(max_length, name,
+ dummy_table)))
+ DBUG_RETURN(TRUE);
+
+ if (sp_result_field->pack_length() > sizeof(result_buf))
+ {
+ void *tmp;
+ if (!(tmp= thd->alloc(sp_result_field->pack_length())))
+ DBUG_RETURN(TRUE);
+ sp_result_field->move_field((uchar*) tmp);
+ }
+ else
+ sp_result_field->move_field(result_buf);
+
+ sp_result_field->null_ptr= (uchar *) null_value;
+ sp_result_field->null_bit= 1;
+
+ DBUG_RETURN(FALSE);
+}
+
+/**
+ @brief
+ Building clone for Item_ref
+
+ @param thd thread handle
+ @param mem_root part of the memory for the clone
+
+ @details
+ This method gets copy of the current item and also
+ builds clone for its reference.
+
+ @retval
+ clone of the item
+ 0 if an error occurred
+*/
+
+Item* Item_ref::build_clone(THD *thd)
+{
+ Item_ref *copy= (Item_ref *) get_copy(thd);
+ if (unlikely(!copy) ||
+ unlikely(!(copy->ref= (Item**) alloc_root(thd->mem_root,
+ sizeof(Item*)))) ||
+ unlikely(!(*copy->ref= (* ref)->build_clone(thd))))
+ return 0;
+ return copy;
+}
+
+
+/**********************************************/
+
+Item_field::Item_field(THD *thd, Field *f)
+ :Item_ident(thd, 0, null_clex_str,
+ Lex_cstring_strlen(*f->table_name), f->field_name),
+ item_equal(0),
+ have_privileges(NO_ACL), any_privileges(0)
+{
+ set_field(f);
+ /*
+ field_name and table_name should not point to garbage
+ if this item is to be reused
+ */
+ orig_table_name= table_name;
+ orig_field_name= field_name;
+ with_field= 1;
+}
+
+
+/**
+ Constructor used inside setup_wild().
+
+ Ensures that field, table, and database names will live as long as
+ Item_field (this is important in prepared statements).
+*/
+
+Item_field::Item_field(THD *thd, Name_resolution_context *context_arg,
+ Field *f)
+ :Item_ident(thd, context_arg, f->table->s->db,
+ Lex_cstring_strlen(*f->table_name), f->field_name),
+ item_equal(0),
+ have_privileges(NO_ACL), any_privileges(0)
+{
+ /*
+ We always need to provide Item_field with a fully qualified field
+ name to avoid ambiguity when executing prepared statements like
+ SELECT * from d1.t1, d2.t1; (assuming d1.t1 and d2.t1 have columns
+ with same names).
+ This is because prepared statements never deal with wildcards in
+ select list ('*') and always fix fields using fully specified path
+ (i.e. db.table.column).
+ No check for OOM: if db_name is NULL, we'll just get
+ "Field not found" error.
+ We need to copy db_name, table_name and field_name because they must
+ be allocated in the statement memory, not in table memory (the table
+ structure can go away and pop up again between subsequent executions
+ of a prepared statement or after the close_tables_for_reopen() call
+ in mysql_multi_update_prepare() or due to wildcard expansion in stored
+ procedures).
+ */
+ {
+ if (db_name.str)
+ orig_db_name= thd->strmake_lex_cstring(db_name);
+ if (table_name.str)
+ orig_table_name= thd->strmake_lex_cstring(table_name);
+ if (field_name.str)
+ orig_field_name= thd->strmake_lex_cstring(field_name);
+ /*
+ We don't restore 'name' in cleanup because it's not changed
+ during execution. Still we need it to point to persistent
+ memory if this item is to be reused.
+ */
+ name= orig_field_name;
+ }
+ set_field(f);
+ with_field= 1;
+}
+
+
+Item_field::Item_field(THD *thd, Name_resolution_context *context_arg,
+ const LEX_CSTRING &db_arg,
+ const LEX_CSTRING &table_name_arg,
+ const LEX_CSTRING &field_name_arg)
+ :Item_ident(thd, context_arg, db_arg, table_name_arg, field_name_arg),
+ field(0), item_equal(0),
+ have_privileges(NO_ACL), any_privileges(0)
+{
+ SELECT_LEX *select= thd->lex->current_select;
+ collation.set(DERIVATION_IMPLICIT);
+ if (select && select->parsing_place != IN_HAVING)
+ select->select_n_where_fields++;
+ with_field= 1;
+}
+
+/**
+ Constructor need to process subselect with temporary tables (see Item)
+*/
+
+Item_field::Item_field(THD *thd, Item_field *item)
+ :Item_ident(thd, item),
+ field(item->field),
+ item_equal(item->item_equal),
+ have_privileges(item->have_privileges),
+ any_privileges(item->any_privileges)
+{
+ collation.set(DERIVATION_IMPLICIT);
+ with_field= 1;
+}
+
+
+bool Item_field::is_json_type()
+{
+ if (!field->check_constraint ||
+ field->check_constraint->expr->type() != FUNC_ITEM)
+ return FALSE;
+
+ Item_func *f= (Item_func *) field->check_constraint->expr;
+ return f->functype() == Item_func::JSON_VALID_FUNC;
+}
+
+
+void Item_field::set_field(Field *field_par)
+{
+ field=result_field=field_par; // for easy coding with fields
+ maybe_null=field->maybe_null();
+ Type_std_attributes::set(field_par->type_std_attributes());
+ table_name= Lex_cstring_strlen(*field_par->table_name);
+ field_name= field_par->field_name;
+ db_name= field_par->table->s->db;
+ alias_name_used= field_par->table->alias_name_used;
+
+ fixed= 1;
+ if (field->table->s->tmp_table == SYSTEM_TMP_TABLE)
+ any_privileges= 0;
+}
+
+
+/**
+ Reset this item to point to a field from the new temporary table.
+ This is used when we create a new temporary table for each execution
+ of prepared statement.
+*/
+
+void Item_field::reset_field(Field *f)
+{
+ set_field(f);
+ /* 'name' is pointing at field->field_name of old field */
+ name= f->field_name;
+}
+
+
+void Item_field::load_data_print_for_log_event(THD *thd, String *to) const
+{
+ append_identifier(thd, to, name.str, name.length);
+}
+
+
+bool Item_field::load_data_set_no_data(THD *thd, const Load_data_param *param)
+{
+ if (field->load_data_set_no_data(thd, param->is_fixed_length()))
+ return true;
+ /*
+ TODO: We probably should not throw warning for each field.
+ But how about intention to always have the same number
+ of warnings in THD::cuted_fields (and get rid of cuted_fields
+ in the end ?)
+ */
+ thd->cuted_fields++;
+ push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+ ER_WARN_TOO_FEW_RECORDS,
+ ER_THD(thd, ER_WARN_TOO_FEW_RECORDS),
+ thd->get_stmt_da()->current_row_for_warning());
+ return false;
+}
+
+
+bool Item_field::enumerate_field_refs_processor(void *arg)
+{
+ Field_enumerator *fe= (Field_enumerator*)arg;
+ fe->visit_field(this);
+ return FALSE;
+}
+
+bool Item_field::update_table_bitmaps_processor(void *arg)
+{
+ update_table_bitmaps();
+ return FALSE;
+}
+
+static inline void set_field_to_new_field(Field **field, Field **new_field)
+{
+ if (*field && (*field)->table == new_field[0]->table)
+ {
+ Field *newf= new_field[(*field)->field_index];
+ if ((*field)->ptr == newf->ptr)
+ *field= newf;
+ }
+}
+
+bool Item_field::switch_to_nullable_fields_processor(void *arg)
+{
+ Field **new_fields= (Field **)arg;
+ set_field_to_new_field(&field, new_fields);
+ set_field_to_new_field(&result_field, new_fields);
+ maybe_null= field && field->maybe_null();
+ return 0;
+}
+
+const char *Item_ident::full_name() const
+{
+ char *tmp;
+ if (!table_name.str || !field_name.str)
+ return field_name.str ? field_name.str : name.str ? name.str : "tmp_field";
+
+ if (db_name.str && db_name.str[0])
+ {
+ THD *thd= current_thd;
+ tmp=(char*) thd->alloc((uint) db_name.length+ (uint) table_name.length +
+ (uint) field_name.length+3);
+ strxmov(tmp,db_name.str,".",table_name.str,".",field_name.str,NullS);
+ }
+ else
+ {
+ if (table_name.str[0])
+ {
+ THD *thd= current_thd;
+ tmp= (char*) thd->alloc((uint) table_name.length +
+ field_name.length + 2);
+ strxmov(tmp, table_name.str, ".", field_name.str, NullS);
+ }
+ else
+ return field_name.str;
+ }
+ return tmp;
+}
+
+void Item_ident::print(String *str, enum_query_type query_type)
+{
+ THD *thd= current_thd;
+ char d_name_buff[MAX_ALIAS_NAME], t_name_buff[MAX_ALIAS_NAME];
+ LEX_CSTRING d_name= db_name;
+ LEX_CSTRING t_name= table_name;
+ bool use_table_name= table_name.str && table_name.str[0];
+ bool use_db_name= use_table_name && db_name.str && db_name.str[0] &&
+ !alias_name_used;
+
+ if (use_db_name && (query_type & QT_ITEM_IDENT_SKIP_DB_NAMES))
+ use_db_name= !thd->db.str || strcmp(thd->db.str, db_name.str);
+
+ if (use_db_name)
+ use_db_name= !(cached_table && cached_table->belong_to_view &&
+ cached_table->belong_to_view->compact_view_format);
+
+ if (use_table_name && (query_type & QT_ITEM_IDENT_SKIP_TABLE_NAMES))
+ {
+ /*
+ Don't print the table name if it's the only table in the context
+ XXX technically, that's a sufficient, but too strong condition
+ */
+ if (!context)
+ use_db_name= use_table_name= false;
+ else if (context->outer_context)
+ use_table_name= true;
+ else if (context->last_name_resolution_table == context->first_name_resolution_table)
+ use_db_name= use_table_name= false;
+ else if (!context->last_name_resolution_table &&
+ !context->first_name_resolution_table->next_name_resolution_table)
+ use_db_name= use_table_name= false;
+ }
+
+ if ((query_type & QT_ITEM_IDENT_DISABLE_DB_TABLE_NAMES))
+ {
+ // Don't print db or table name irrespective of any other settings.
+ use_db_name= use_table_name= false;
+ }
+
+ if (!field_name.str || !field_name.str[0])
+ {
+ append_identifier(thd, str, STRING_WITH_LEN("tmp_field"));
+ return;
+ }
+
+ if (lower_case_table_names== 1 ||
+ (lower_case_table_names == 2 && !alias_name_used))
+ {
+ if (use_table_name)
+ {
+ strmov(t_name_buff, table_name.str);
+ my_casedn_str(files_charset_info, t_name_buff);
+ t_name= Lex_cstring_strlen(t_name_buff);
+ }
+ if (use_db_name)
+ {
+ strmov(d_name_buff, db_name.str);
+ my_casedn_str(files_charset_info, d_name_buff);
+ d_name= Lex_cstring_strlen(d_name_buff);
+ }
+ }
+
+ if (use_db_name)
+ {
+ append_identifier(thd, str, d_name.str, (uint) d_name.length);
+ str->append('.');
+ DBUG_ASSERT(use_table_name);
+ }
+ if (use_table_name)
+ {
+ append_identifier(thd, str, t_name.str, (uint) t_name.length);
+ str->append('.');
+ }
+ append_identifier(thd, str, &field_name);
+}
+
+/* ARGSUSED */
+String *Item_field::val_str(String *str)
+{
+ DBUG_ASSERT(fixed == 1);
+ if ((null_value=field->is_null()))
+ return 0;
+ str->set_charset(str_value.charset());
+ return field->val_str(str,&str_value);
+}
+
+
+double Item_field::val_real()
+{
+ DBUG_ASSERT(fixed == 1);
+ if ((null_value=field->is_null()))
+ return 0.0;
+ return field->val_real();
+}
+
+
+longlong Item_field::val_int()
+{
+ DBUG_ASSERT(fixed == 1);
+ if ((null_value=field->is_null()))
+ return 0;
+ return field->val_int();
+}
+
+
+my_decimal *Item_field::val_decimal(my_decimal *decimal_value)
+{
+ if ((null_value= field->is_null()))
+ return 0;
+ return field->val_decimal(decimal_value);
+}
+
+
+String *Item_field::str_result(String *str)
+{
+ if ((null_value=result_field->is_null()))
+ return 0;
+ str->set_charset(str_value.charset());
+ return result_field->val_str(str,&str_value);
+}
+
+bool Item_field::get_date(THD *thd, MYSQL_TIME *ltime,date_mode_t fuzzydate)
+{
+ if ((null_value=field->is_null()) || field->get_date(ltime,fuzzydate))
+ {
+ bzero((char*) ltime,sizeof(*ltime));
+ return 1;
+ }
+ return 0;
+}
+
+bool Item_field::get_date_result(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+{
+ if ((null_value= result_field->is_null()) ||
+ result_field->get_date(ltime, fuzzydate))
+ {
+ bzero((char*) ltime,sizeof(*ltime));
+ return true;
+ }
+ return false;
+}
+
+
+bool Item_field::val_native(THD *thd, Native *to)
+{
+ return val_native_from_field(field, to);
+}
+
+
+bool Item_field::val_native_result(THD *thd, Native *to)
+{
+ return val_native_from_field(result_field, to);
+}
+
+
+longlong Item_field::val_datetime_packed(THD *thd)
+{
+ DBUG_ASSERT(fixed == 1);
+ if ((null_value= field->is_null()))
+ return 0;
+ return field->val_datetime_packed(thd);
+}
+
+
+longlong Item_field::val_time_packed(THD *thd)
+{
+ DBUG_ASSERT(fixed == 1);
+ if ((null_value= field->is_null()))
+ return 0;
+ return field->val_time_packed(thd);
+}
+
+
+void Item_field::save_result(Field *to)
+{
+ save_field_in_field(result_field, &null_value, to, TRUE);
+}
+
+
+double Item_field::val_result()
+{
+ if ((null_value=result_field->is_null()))
+ return 0.0;
+ return result_field->val_real();
+}
+
+longlong Item_field::val_int_result()
+{
+ if ((null_value=result_field->is_null()))
+ return 0;
+ return result_field->val_int();
+}
+
+
+my_decimal *Item_field::val_decimal_result(my_decimal *decimal_value)
+{
+ if ((null_value= result_field->is_null()))
+ return 0;
+ return result_field->val_decimal(decimal_value);
+}
+
+
+bool Item_field::val_bool_result()
+{
+ if ((null_value= result_field->is_null()))
+ return false;
+ return result_field->val_bool();
+}
+
+
+bool Item_field::is_null_result()
+{
+ return (null_value=result_field->is_null());
+}
+
+
+bool Item_field::eq(const Item *item, bool binary_cmp) const
+{
+ Item *real_item2= ((Item *) item)->real_item();
+ if (real_item2->type() != FIELD_ITEM)
+ return 0;
+
+ Item_field *item_field= (Item_field*) real_item2;
+ if (item_field->field && field)
+ return item_field->field == field;
+ /*
+ We may come here when we are trying to find a function in a GROUP BY
+ clause from the select list.
+ In this case the '100 % correct' way to do this would be to first
+ run fix_fields() on the GROUP BY item and then retry this function, but
+ I think it's better to relax the checking a bit as we will in
+ most cases do the correct thing by just checking the field name.
+ (In cases where we would choose wrong we would have to generate a
+ ER_NON_UNIQ_ERROR).
+ */
+ return (!lex_string_cmp(system_charset_info, &item_field->name,
+ &field_name) &&
+ (!item_field->table_name.str || !table_name.str ||
+ (!my_strcasecmp(table_alias_charset, item_field->table_name.str,
+ table_name.str) &&
+ (!item_field->db_name.str || !db_name.str ||
+ (item_field->db_name.str && !strcmp(item_field->db_name.str,
+ db_name.str))))));
+}
+
+
+table_map Item_field::used_tables() const
+{
+ if (field->table->const_table)
+ return 0; // const item
+ return (get_depended_from() ? OUTER_REF_TABLE_BIT : field->table->map);
+}
+
+table_map Item_field::all_used_tables() const
+{
+ return (get_depended_from() ? OUTER_REF_TABLE_BIT : field->table->map);
+}
+
+
+bool Item_field::find_not_null_fields(table_map allowed)
+{
+ if (field->table->const_table)
+ return false;
+ if (!get_depended_from() && field->real_maybe_null())
+ bitmap_set_bit(&field->table->tmp_set, field->field_index);
+ return false;
+}
+
+
+/*
+ @Note thd->fatal_error can be set in case of OOM
+*/
+
+void Item_field::fix_after_pullout(st_select_lex *new_parent, Item **ref,
+ bool merge)
+{
+ if (new_parent == get_depended_from())
+ depended_from= NULL;
+ if (context)
+ {
+ bool need_change= false;
+ /*
+ Suppose there are nested selects:
+
+ select_id=1
+ select_id=2
+ select_id=3 <----+
+ select_id=4 -+
+ select_id=5 --+
+
+ Suppose, pullout operation has moved anything that had select_id=4 or 5
+ in to select_id=3.
+
+ If this Item_field had a name resolution context pointing into select_lex
+ with id=4 or id=5, it needs a new name resolution context.
+
+ However, it could also be that this object is a part of outer reference:
+ Item_ref(Item_field(field in select with select_id=1))).
+ - The Item_ref object has a context with select_id=5, and so needs a new
+ name resolution context.
+ - The Item_field object has a context with select_id=1, and doesn't need
+ a new name resolution context.
+
+ So, the following loop walks from Item_field's current context upwards.
+ If we find that the select we've been pulled out to is up there, we
+ create the new name resolution context. Otherwise, we don't.
+ */
+ for (Name_resolution_context *ct= context; ct; ct= ct->outer_context)
+ {
+ if (new_parent == ct->select_lex)
+ {
+ need_change= true;
+ break;
+ }
+ }
+ if (!need_change)
+ return;
+
+ if (!merge)
+ {
+ /*
+ It is transformation without merge.
+ This field was "outer" for the inner SELECT where it was taken and
+ moved up.
+ "Outer" fields uses normal SELECT_LEX context of upper SELECTs for
+ name resolution, so we can switch everything to it safely.
+ */
+ this->context= &new_parent->context;
+ return;
+ }
+
+ Name_resolution_context *ctx= new Name_resolution_context();
+ if (!ctx)
+ return; // Fatal error set
+ if (context->select_lex == new_parent)
+ {
+ /*
+ This field was pushed in then pulled out
+ (for example left part of IN)
+ */
+ ctx->outer_context= context->outer_context;
+ }
+ else if (context->outer_context)
+ {
+ /* just pull to the upper context */
+ ctx->outer_context= context->outer_context->outer_context;
+ }
+ else
+ {
+ /* No upper context (merging Derived/VIEW where context chain ends) */
+ ctx->outer_context= NULL;
+ }
+ ctx->table_list= context->first_name_resolution_table;
+ ctx->select_lex= new_parent;
+ if (context->select_lex == NULL)
+ ctx->select_lex= NULL;
+ ctx->first_name_resolution_table= context->first_name_resolution_table;
+ ctx->last_name_resolution_table= context->last_name_resolution_table;
+ ctx->error_processor= context->error_processor;
+ ctx->error_processor_data= context->error_processor_data;
+ ctx->resolve_in_select_list= context->resolve_in_select_list;
+ ctx->security_ctx= context->security_ctx;
+ this->context=ctx;
+ }
+}
+
+
+Item *Item_field::get_tmp_table_item(THD *thd)
+{
+ Item_field *new_item= new (thd->mem_root) Item_temptable_field(thd, this);
+ if (new_item)
+ new_item->field= new_item->result_field;
+ return new_item;
+}
+
+longlong Item_field::val_int_endpoint(bool left_endp, bool *incl_endp)
+{
+ longlong res= val_int();
+ return null_value? LONGLONG_MIN : res;
+}
+
+
+bool Item_basic_value::eq(const Item *item, bool binary_cmp) const
+{
+ const Item_const *c0, *c1;
+ const Type_handler *h0, *h1;
+ /*
+ - Test get_item_const() for NULL filters out Item_param
+ bound in a way that needs a data type conversion
+ (e.g. non-integer value in a LIMIT clause).
+ Item_param::get_item_const() return NULL in such cases.
+ - Test for type_handler_for_comparison() equality makes sure
+ that values of different data type groups do not get detected
+ as equal (e.g. numbers vs strings, time vs datetime).
+ - Test for cast_to_int_type_handler() equality distinguishes
+ values with dual properties. For example, VARCHAR 'abc' and hex
+ hybrid 0x616263 are equal in string context, but they are not equal
+ if the hybrid appears in integer context (it behaves as integer then).
+ Here we have no full information about the context, so treat them
+ as not equal.
+ QQ: We could pass Value_source::Context here instead of
+ "bool binary_cmp", to make substitution more delicate.
+ See Field::get_equal_const_item().
+ */
+ bool res= (c0= get_item_const()) &&
+ (c1= item->get_item_const()) &&
+ (h0= type_handler())->type_handler_for_comparison() ==
+ (h1= item->type_handler())->type_handler_for_comparison() &&
+ h0->cast_to_int_type_handler()->type_handler_for_comparison() ==
+ h1->cast_to_int_type_handler()->type_handler_for_comparison();
+ if (res)
+ {
+ switch (c0->const_is_null() + c1->const_is_null()) {
+ case 2: // Two NULLs
+ res= true;
+ break;
+ case 1: // NULL and non-NULL
+ res= false;
+ break;
+ case 0: // Two non-NULLs
+ res= h0->Item_const_eq(c0, c1, binary_cmp);
+ }
+ }
+ DBUG_EXECUTE_IF("Item_basic_value",
+ push_warning_printf(current_thd,
+ Sql_condition::WARN_LEVEL_NOTE,
+ ER_UNKNOWN_ERROR, "%seq=%d a=%s b=%s",
+ binary_cmp ? "bin_" : "", (int) res,
+ DbugStringItemTypeValue(current_thd, this).c_ptr(),
+ DbugStringItemTypeValue(current_thd, item).c_ptr()
+ ););
+ return res;
+}
+
+
+/**
+ Create an item from a string we KNOW points to a valid longlong
+ end \\0 terminated number string.
+ This is always 'signed'. Unsigned values are created with Item_uint()
+*/
+
+Item_int::Item_int(THD *thd, const char *str_arg, size_t length):
+ Item_num(thd)
+{
+ char *end_ptr= (char*) str_arg + length;
+ int error;
+ value= my_strtoll10(str_arg, &end_ptr, &error);
+ max_length= (uint) (end_ptr - str_arg);
+ name.str= str_arg;
+ /*
+ We can't trust max_length as in show_routine_code we are using "Pos" as
+ the field name.
+ */
+ name.length= !str_arg[max_length] ? max_length : strlen(str_arg);
+}
+
+
+my_decimal *Item_int::val_decimal(my_decimal *decimal_value)
+{
+ int2my_decimal(E_DEC_FATAL_ERROR, value, unsigned_flag, decimal_value);
+ return decimal_value;
+}
+
+String *Item_int::val_str(String *str)
+{
+ str->set_int(value, unsigned_flag, collation.collation);
+ return str;
+}
+
+void Item_int::print(String *str, enum_query_type query_type)
+{
+ StringBuffer<LONGLONG_BUFFER_SIZE+1> buf;
+ // my_charset_bin is good enough for numbers
+ buf.set_int(value, unsigned_flag, &my_charset_bin);
+ str->append(buf);
+}
+
+
+Item *Item_bool::neg_transformer(THD *thd)
+{
+ value= !value;
+ name= null_clex_str;
+ return this;
+}
+
+
+Item_uint::Item_uint(THD *thd, const char *str_arg, size_t length):
+ Item_int(thd, str_arg, length)
+{
+ unsigned_flag= 1;
+}
+
+
+Item_uint::Item_uint(THD *thd, const char *str_arg, longlong i, uint length):
+ Item_int(thd, str_arg, i, length)
+{
+ unsigned_flag= 1;
+}
+
+
+Item_decimal::Item_decimal(THD *thd, const char *str_arg, size_t length,
+ CHARSET_INFO *charset):
+ Item_num(thd)
+{
+ str2my_decimal(E_DEC_FATAL_ERROR, str_arg, length, charset, &decimal_value);
+ name.str= str_arg;
+ name.length= safe_strlen(str_arg);
+ decimals= (uint8) decimal_value.frac;
+ max_length= my_decimal_precision_to_length_no_truncation(decimal_value.intg +
+ decimals,
+ decimals,
+ unsigned_flag);
+}
+
+Item_decimal::Item_decimal(THD *thd, longlong val, bool unsig):
+ Item_num(thd)
+{
+ int2my_decimal(E_DEC_FATAL_ERROR, val, unsig, &decimal_value);
+ decimals= (uint8) decimal_value.frac;
+ max_length= my_decimal_precision_to_length_no_truncation(decimal_value.intg +
+ decimals,
+ decimals,
+ unsigned_flag);
+}
+
+
+Item_decimal::Item_decimal(THD *thd, double val, int precision, int scale):
+ Item_num(thd)
+{
+ double2my_decimal(E_DEC_FATAL_ERROR, val, &decimal_value);
+ decimals= (uint8) decimal_value.frac;
+ max_length= my_decimal_precision_to_length_no_truncation(decimal_value.intg +
+ decimals,
+ decimals,
+ unsigned_flag);
+}
+
+
+Item_decimal::Item_decimal(THD *thd, const char *str, const my_decimal *val_arg,
+ uint decimal_par, uint length):
+ Item_num(thd)
+{
+ my_decimal2decimal(val_arg, &decimal_value);
+ name.str= str;
+ name.length= safe_strlen(str);
+ decimals= (uint8) decimal_par;
+ max_length= length;
+}
+
+
+Item_decimal::Item_decimal(THD *thd, const my_decimal *value_par):
+ Item_num(thd)
+{
+ my_decimal2decimal(value_par, &decimal_value);
+ decimals= (uint8) decimal_value.frac;
+ max_length= my_decimal_precision_to_length_no_truncation(decimal_value.intg +
+ decimals,
+ decimals,
+ unsigned_flag);
+}
+
+
+Item_decimal::Item_decimal(THD *thd, const uchar *bin, int precision, int scale):
+ Item_num(thd),
+ decimal_value(bin, precision, scale)
+{
+ decimals= (uint8) decimal_value.frac;
+ max_length= my_decimal_precision_to_length_no_truncation(precision, decimals,
+ unsigned_flag);
+}
+
+
+void Item_decimal::set_decimal_value(my_decimal *value_par)
+{
+ my_decimal2decimal(value_par, &decimal_value);
+ decimals= (uint8) decimal_value.frac;
+ unsigned_flag= !decimal_value.sign();
+ max_length= my_decimal_precision_to_length_no_truncation(decimal_value.intg +
+ decimals,
+ decimals,
+ unsigned_flag);
+}
+
+
+Item *Item_decimal::clone_item(THD *thd)
+{
+ return new (thd->mem_root) Item_decimal(thd, name.str, &decimal_value, decimals,
+ max_length);
+}
+
+
+String *Item_float::val_str(String *str)
+{
+ str->set_real(value, decimals, &my_charset_numeric);
+ return str;
+}
+
+
+my_decimal *Item_float::val_decimal(my_decimal *decimal_value)
+{
+ double2my_decimal(E_DEC_FATAL_ERROR, value, decimal_value);
+ return (decimal_value);
+}
+
+
+Item *Item_float::clone_item(THD *thd)
+{
+ return new (thd->mem_root) Item_float(thd, name.str, value, decimals,
+ max_length);
+}
+
+
+void Item_string::print(String *str, enum_query_type query_type)
+{
+ const bool print_introducer=
+ !(query_type & QT_WITHOUT_INTRODUCERS) && is_cs_specified();
+ if (print_introducer)
+ {
+ str->append('_');
+ str->append(collation.collation->csname);
+ }
+
+ str->append('\'');
+
+ if (query_type & QT_TO_SYSTEM_CHARSET)
+ {
+ if (print_introducer)
+ {
+ /*
+ Because we wrote an introducer, we must print str_value in its
+ charset, and the resulting bytes must not be changed until they
+ reach the end client.
+ But the caller is asking for system_charset_info, and may later
+ convert into character_set_results. That means two conversions: we
+ must ensure that they don't change our printed bytes.
+ So we print str_value in the least common denominator of the three
+ charsets involved: ASCII. Non-ASCII characters are printed as \xFF
+ sequences (which is ASCII too). This way, our bytes will not be
+ changed.
+ */
+ ErrConvString tmp(str_value.ptr(), str_value.length(), &my_charset_bin);
+ str->append(tmp.ptr());
+ }
+ else
+ {
+ str_value.print(str, system_charset_info);
+ }
+ }
+ else
+ {
+ // Caller wants a result in the charset of str_value.
+ str_value.print(str);
+ }
+
+ str->append('\'');
+}
+
+
+double Item_string::val_real()
+{
+ return double_from_string_with_check(&str_value);
+}
+
+
+/**
+ @todo
+ Give error if we wanted a signed integer and we got an unsigned one
+*/
+longlong Item_string::val_int()
+{
+ return longlong_from_string_with_check(&str_value);
+}
+
+
+my_decimal *Item_string::val_decimal(my_decimal *decimal_value)
+{
+ return val_decimal_from_string(decimal_value);
+}
+
+
+double Item_null::val_real()
+{
+ null_value=1;
+ return 0.0;
+}
+longlong Item_null::val_int()
+{
+ null_value=1;
+ return 0;
+}
+/* ARGSUSED */
+String *Item_null::val_str(String *str)
+{
+ null_value=1;
+ return 0;
+}
+
+my_decimal *Item_null::val_decimal(my_decimal *decimal_value)
+{
+ return 0;
+}
+
+
+longlong Item_null::val_datetime_packed(THD *)
+{
+ null_value= true;
+ return 0;
+}
+
+
+longlong Item_null::val_time_packed(THD *)
+{
+ null_value= true;
+ return 0;
+}
+
+
+bool Item_null::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+{
+ set_zero_time(ltime, MYSQL_TIMESTAMP_NONE);
+ return (null_value= true);
+}
+
+
+Item *Item_null::safe_charset_converter(THD *thd, CHARSET_INFO *tocs)
+{
+ return this;
+}
+
+Item *Item_null::clone_item(THD *thd)
+{
+ return new (thd->mem_root) Item_null(thd, name.str);
+}
+
+
+Item_basic_constant *
+Item_null::make_string_literal_concat(THD *thd, const LEX_CSTRING *str)
+{
+ DBUG_ASSERT(thd->variables.sql_mode & MODE_EMPTY_STRING_IS_NULL);
+ if (str->length)
+ {
+ CHARSET_INFO *cs= thd->variables.collation_connection;
+ my_repertoire_t repertoire= my_string_repertoire(cs, str->str, str->length);
+ return new (thd->mem_root) Item_string(thd,
+ str->str, (uint) str->length, cs,
+ DERIVATION_COERCIBLE, repertoire);
+ }
+ return this;
+}
+
+
+/*********************** Item_param related ******************************/
+
+Item_param::Item_param(THD *thd, const LEX_CSTRING *name_arg,
+ uint pos_in_query_arg, uint len_in_query_arg):
+ Item_basic_value(thd),
+ Rewritable_query_parameter(pos_in_query_arg, len_in_query_arg),
+ /*
+ Set handler to type_handler_null. Its data type test methods such as:
+ - is_scalar_type()
+ - can_return_int()
+ - can_return_real(),
+ - is_general_purpose_string_type()
+ all return "true". This is needed to avoid any "illegal parameter type"
+ errors in Item::check_type_xxx() at PS prepare time.
+ */
+ Type_handler_hybrid_field_type(&type_handler_null),
+ state(NO_VALUE),
+ m_empty_string_is_null(false),
+ indicator(STMT_INDICATOR_NONE),
+ m_out_param_info(NULL),
+ /*
+ Set m_is_settable_routine_parameter to "true" by default.
+ This is needed for client-server protocol,
+ whose parameters are always settable.
+ For dynamic SQL, settability depends on the type of Item passed
+ as an actual parameter. See Item_param::set_from_item().
+ */
+ m_is_settable_routine_parameter(true),
+ m_clones(thd->mem_root)
+{
+ name= *name_arg;
+ /*
+ Since we can't say whenever this item can be NULL or cannot be NULL
+ before mysql_stmt_execute(), so we assuming that it can be NULL until
+ value is set.
+ */
+ maybe_null= 1;
+}
+
+
+/* Add reference to Item_param used in a copy of CTE to its master as a clone */
+
+bool Item_param::add_as_clone(THD *thd)
+{
+ LEX *lex= thd->lex;
+ my_ptrdiff_t master_pos= pos_in_query + lex->clone_spec_offset;
+ List_iterator_fast<Item_param> it(lex->param_list);
+ Item_param *master_param;
+ while ((master_param = it++))
+ {
+ if (master_pos == master_param->pos_in_query)
+ return master_param->register_clone(this);
+ }
+ DBUG_ASSERT(false);
+ return false;
+}
+
+
+/* Update all clones of Item_param to sync their values with the item's value */
+
+void Item_param::sync_clones()
+{
+ Item_param **c_ptr= m_clones.begin();
+ Item_param **end= m_clones.end();
+ for ( ; c_ptr < end; c_ptr++)
+ {
+ Item_param *c= *c_ptr;
+ /* Scalar-type members: */
+ c->maybe_null= maybe_null;
+ c->null_value= null_value;
+ c->Type_std_attributes::operator=(*this);
+ c->Type_handler_hybrid_field_type::operator=(*this);
+
+ c->state= state;
+ c->m_empty_string_is_null= m_empty_string_is_null;
+
+ c->value.PValue_simple::operator=(value);
+ c->value.Type_handler_hybrid_field_type::operator=(value);
+ type_handler()->Item_param_setup_conversion(current_thd, c);
+
+ /* Class-type members: */
+ c->value.m_decimal= value.m_decimal;
+ /*
+ Note that String's assignment op properly sets m_is_alloced to 'false',
+ which is correct here: c->str_value doesn't own anything.
+ */
+ c->value.m_string= value.m_string;
+ c->value.m_string_ptr= value.m_string_ptr;
+ }
+}
+
+
+void Item_param::set_null()
+{
+ DBUG_ENTER("Item_param::set_null");
+ /*
+ These are cleared after each execution by reset() method or by setting
+ other value.
+ */
+ null_value= 1;
+ /*
+ Because of NULL and string values we need to set max_length for each new
+ placeholder value: user can submit NULL for any placeholder type, and
+ string length can be different in each execution.
+ */
+ max_length= 0;
+ decimals= 0;
+ state= NULL_VALUE;
+ DBUG_VOID_RETURN;
+}
+
+void Item_param::set_int(longlong i, uint32 max_length_arg)
+{
+ DBUG_ENTER("Item_param::set_int");
+ DBUG_ASSERT(value.type_handler()->cmp_type() == INT_RESULT);
+ value.integer= (longlong) i;
+ state= SHORT_DATA_VALUE;
+ collation= DTCollation_numeric();
+ max_length= max_length_arg;
+ decimals= 0;
+ maybe_null= 0;
+ null_value= 0;
+ DBUG_VOID_RETURN;
+}
+
+void Item_param::set_double(double d)
+{
+ DBUG_ENTER("Item_param::set_double");
+ DBUG_ASSERT(value.type_handler()->cmp_type() == REAL_RESULT);
+ value.real= d;
+ state= SHORT_DATA_VALUE;
+ collation= DTCollation_numeric();
+ max_length= DBL_DIG + 8;
+ decimals= NOT_FIXED_DEC;
+ maybe_null= 0;
+ null_value= 0;
+ DBUG_VOID_RETURN;
+}
+
+
+/**
+ Set decimal parameter value from string.
+
+ @param str character string
+ @param length string length
+
+ @note
+ As we use character strings to send decimal values in
+ binary protocol, we use str2my_decimal to convert it to
+ internal decimal value.
+*/
+
+void Item_param::set_decimal(const char *str, ulong length)
+{
+ char *end;
+ DBUG_ENTER("Item_param::set_decimal");
+ DBUG_ASSERT(value.type_handler()->cmp_type() == DECIMAL_RESULT);
+
+ end= (char*) str+length;
+ str2my_decimal(E_DEC_FATAL_ERROR, str, &value.m_decimal, &end);
+ state= SHORT_DATA_VALUE;
+ decimals= value.m_decimal.frac;
+ collation= DTCollation_numeric();
+ max_length=
+ my_decimal_precision_to_length_no_truncation(value.m_decimal.precision(),
+ decimals, unsigned_flag);
+ maybe_null= 0;
+ null_value= 0;
+ DBUG_VOID_RETURN;
+}
+
+void Item_param::set_decimal(const my_decimal *dv, bool unsigned_arg)
+{
+ DBUG_ASSERT(value.type_handler()->cmp_type() == DECIMAL_RESULT);
+ state= SHORT_DATA_VALUE;
+
+ my_decimal2decimal(dv, &value.m_decimal);
+
+ decimals= (uint8) value.m_decimal.frac;
+ collation= DTCollation_numeric();
+ unsigned_flag= unsigned_arg;
+ max_length= my_decimal_precision_to_length(value.m_decimal.intg + decimals,
+ decimals, unsigned_flag);
+ maybe_null= 0;
+ null_value= 0;
+}
+
+
+void Item_param::fix_temporal(uint32 max_length_arg, uint decimals_arg)
+{
+ state= SHORT_DATA_VALUE;
+ collation= DTCollation_numeric();
+ max_length= max_length_arg;
+ decimals= decimals_arg;
+ maybe_null= 0;
+ null_value= 0;
+}
+
+
+void Item_param::set_time(const MYSQL_TIME *tm,
+ uint32 max_length_arg, uint decimals_arg)
+{
+ DBUG_ASSERT(value.type_handler()->cmp_type() == TIME_RESULT);
+ value.time= *tm;
+ maybe_null= 0;
+ null_value= 0;
+ fix_temporal(max_length_arg, decimals_arg);
+}
+
+
+/**
+ Set parameter value from MYSQL_TIME value.
+
+ @param tm datetime value to set (time_type is ignored)
+ @param type type of datetime value
+ @param max_length_arg max length of datetime value as string
+
+ @note
+ If we value to be stored is not normalized, zero value will be stored
+ instead and proper warning will be produced. This function relies on
+ the fact that even wrong value sent over binary protocol fits into
+ MAX_DATE_STRING_REP_LENGTH buffer.
+*/
+void Item_param::set_time(MYSQL_TIME *tm, timestamp_type time_type,
+ uint32 max_length_arg)
+{
+ DBUG_ENTER("Item_param::set_time");
+ DBUG_ASSERT(value.type_handler()->cmp_type() == TIME_RESULT);
+
+ value.time= *tm;
+ value.time.time_type= time_type;
+
+ if (check_datetime_range(&value.time))
+ {
+ ErrConvTime str(&value.time);
+ make_truncated_value_warning(current_thd, Sql_condition::WARN_LEVEL_WARN,
+ &str, time_type, NULL, NULL, NULL);
+ set_zero_time(&value.time, time_type);
+ }
+ maybe_null= 0;
+ null_value= 0;
+ fix_temporal(max_length_arg,
+ tm->second_part > 0 ? TIME_SECOND_PART_DIGITS : 0);
+ DBUG_VOID_RETURN;
+}
+
+
+bool Item_param::set_str(const char *str, ulong length,
+ CHARSET_INFO *fromcs, CHARSET_INFO *tocs)
+{
+ DBUG_ENTER("Item_param::set_str");
+ DBUG_ASSERT(value.type_handler()->cmp_type() == STRING_RESULT);
+ /*
+ Assign string with no conversion: data is converted only after it's
+ been written to the binary log.
+ */
+ uint dummy_errors;
+ if (unlikely(value.m_string.copy(str, length, fromcs, tocs, &dummy_errors)))
+ DBUG_RETURN(TRUE);
+ /*
+ Set str_value_ptr to make sure it's in sync with str_value.
+ This is needed in case if we're called from Item_param::set_value(),
+ from the code responsible for setting OUT parameters in
+ sp_head::execute_procedure(). This makes sure that
+ Protocol_binary::send_out_parameters() later gets a valid value
+ from Item_param::val_str().
+ Note, for IN parameters, Item_param::convert_str_value() will be called
+ later, which will convert the value from the client character set to the
+ connection character set, and will reset both str_value and str_value_ptr.
+ */
+ value.m_string_ptr.set(value.m_string.ptr(),
+ value.m_string.length(),
+ value.m_string.charset());
+ state= SHORT_DATA_VALUE;
+ collation.set(tocs, DERIVATION_COERCIBLE);
+ max_length= length;
+ maybe_null= 0;
+ null_value= 0;
+ /* max_length and decimals are set after charset conversion */
+ /* sic: str may be not null-terminated, don't add DBUG_PRINT here */
+ DBUG_RETURN(FALSE);
+}
+
+
+bool Item_param::set_longdata(const char *str, ulong length)
+{
+ DBUG_ENTER("Item_param::set_longdata");
+ DBUG_ASSERT(value.type_handler()->cmp_type() == STRING_RESULT);
+
+ /*
+ If client character set is multibyte, end of long data packet
+ may hit at the middle of a multibyte character. Additionally,
+ if binary log is open we must write long data value to the
+ binary log in character set of client. This is why we can't
+ convert long data to connection character set as it comes
+ (here), and first have to concatenate all pieces together,
+ write query to the binary log and only then perform conversion.
+ */
+ if (value.m_string.length() + length > current_thd->variables.max_allowed_packet)
+ {
+ my_message(ER_UNKNOWN_ERROR,
+ "Parameter of prepared statement which is set through "
+ "mysql_send_long_data() is longer than "
+ "'max_allowed_packet' bytes",
+ MYF(0));
+ DBUG_RETURN(true);
+ }
+
+ if (value.m_string.append(str, length, &my_charset_bin))
+ DBUG_RETURN(TRUE);
+ state= LONG_DATA_VALUE;
+ maybe_null= 0;
+ null_value= 0;
+
+ DBUG_RETURN(FALSE);
+}
+
+
+void Item_param::CONVERSION_INFO::set(THD *thd, CHARSET_INFO *fromcs)
+{
+ CHARSET_INFO *tocs= thd->variables.collation_connection;
+
+ character_set_of_placeholder= fromcs;
+ character_set_client= thd->variables.character_set_client;
+ /*
+ Setup source and destination character sets so that they
+ are different only if conversion is necessary: this will
+ make later checks easier.
+ */
+ uint32 dummy_offset;
+ final_character_set_of_str_value=
+ String::needs_conversion(0, fromcs, tocs, &dummy_offset) ?
+ tocs : fromcs;
+}
+
+
+bool Item_param::CONVERSION_INFO::convert(THD *thd, String *str)
+{
+ return thd->convert_string(str,
+ character_set_of_placeholder,
+ final_character_set_of_str_value);
+}
+
+
+/**
+ Set parameter value from Item.
+
+ @param thd Current thread
+ @param item Item
+
+ @retval
+ 0 OK
+ @retval
+ 1 Out of memory
+*/
+
+bool Item_param::set_from_item(THD *thd, Item *item)
+{
+ DBUG_ENTER("Item_param::set_from_item");
+ m_is_settable_routine_parameter= item->get_settable_routine_parameter();
+ if (limit_clause_param)
+ {
+ longlong val= item->val_int();
+ if (item->null_value)
+ {
+ set_null();
+ DBUG_RETURN(false);
+ }
+ else
+ {
+ unsigned_flag= item->unsigned_flag;
+ set_handler(item->type_handler());
+ DBUG_RETURN(set_limit_clause_param(val));
+ }
+ }
+ struct st_value tmp;
+ if (!item->save_in_value(thd, &tmp))
+ {
+ const Type_handler *h= item->type_handler();
+ set_handler(h);
+ DBUG_RETURN(set_value(thd, item, &tmp, h));
+ }
+ else
+ set_null();
+
+ DBUG_RETURN(0);
+}
+
+/**
+ Resets parameter after execution.
+
+ @note
+ We clear null_value here instead of setting it in set_* methods,
+ because we want more easily handle case for long data.
+*/
+
+void Item_param::reset()
+{
+ DBUG_ENTER("Item_param::reset");
+ /* Shrink string buffer if it's bigger than max possible CHAR column */
+ if (value.m_string.alloced_length() > MAX_CHAR_WIDTH)
+ value.m_string.free();
+ else
+ value.m_string.length(0);
+ value.m_string_ptr.length(0);
+ /*
+ We must prevent all charset conversions until data has been written
+ to the binary log.
+ */
+ value.m_string.set_charset(&my_charset_bin);
+ collation.set(&my_charset_bin, DERIVATION_COERCIBLE);
+ state= NO_VALUE;
+ maybe_null= 1;
+ null_value= 0;
+ DBUG_VOID_RETURN;
+}
+
+
+int Item_param::save_in_field(Field *field, bool no_conversions)
+{
+ field->set_notnull();
+
+ /*
+ There's no "default" intentionally, to make compiler complain
+ when adding a new XXX_VALUE value.
+ Garbage (e.g. in case of a memory overrun) is handled after the switch.
+ */
+ switch (state) {
+ case SHORT_DATA_VALUE:
+ case LONG_DATA_VALUE:
+ return value.type_handler()->Item_save_in_field(this, field, no_conversions);
+ case NULL_VALUE:
+ return set_field_to_null_with_conversions(field, no_conversions);
+ case DEFAULT_VALUE:
+ return field->save_in_field_default_value(field->table->pos_in_table_list->
+ top_table() !=
+ field->table->pos_in_table_list);
+ case IGNORE_VALUE:
+ return field->save_in_field_ignore_value(field->table->pos_in_table_list->
+ top_table() !=
+ field->table->pos_in_table_list);
+ case NO_VALUE:
+ DBUG_ASSERT(0); // Should not be possible
+ return true;
+ }
+ DBUG_ASSERT(0); // Garbage
+ return 1;
+}
+
+
+bool Item_param::is_evaluable_expression() const
+{
+ switch (state) {
+ case SHORT_DATA_VALUE:
+ case LONG_DATA_VALUE:
+ case NULL_VALUE:
+ return true;
+ case NO_VALUE:
+ return true; // Not assigned yet, so we don't know
+ case IGNORE_VALUE:
+ case DEFAULT_VALUE:
+ break;
+ }
+ return false;
+}
+
+
+bool Item_param::can_return_value() const
+{
+ // There's no "default". See comments in Item_param::save_in_field().
+ switch (state) {
+ case SHORT_DATA_VALUE:
+ case LONG_DATA_VALUE:
+ return true;
+ case IGNORE_VALUE:
+ case DEFAULT_VALUE:
+ invalid_default_param();
+ // fall through
+ case NULL_VALUE:
+ return false;
+ case NO_VALUE:
+ DBUG_ASSERT(0); // Should not be possible
+ return false;
+ }
+ DBUG_ASSERT(0); // Garbage
+ return false;
+}
+
+
+void Item_param::invalid_default_param() const
+{
+ my_message(ER_INVALID_DEFAULT_PARAM,
+ ER_THD(current_thd, ER_INVALID_DEFAULT_PARAM), MYF(0));
+}
+
+
+bool Item_param::get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate)
+{
+ /*
+ LIMIT clause parameter should not call get_date()
+ For non-LIMIT parameters, handlers must be the same.
+ */
+ DBUG_ASSERT(type_handler()->result_type() ==
+ value.type_handler()->result_type());
+ if (state == SHORT_DATA_VALUE &&
+ value.type_handler()->cmp_type() == TIME_RESULT)
+ {
+ *res= value.time;
+ return 0;
+ }
+ return type_handler()->Item_get_date_with_warn(thd, this, res, fuzzydate);
+}
+
+
+double Item_param::PValue::val_real(const Type_std_attributes *attr) const
+{
+ switch (type_handler()->cmp_type()) {
+ case REAL_RESULT:
+ return real;
+ case INT_RESULT:
+ return attr->unsigned_flag
+ ? (double) (ulonglong) integer
+ : (double) integer;
+ case DECIMAL_RESULT:
+ return m_decimal.to_double();
+ case STRING_RESULT:
+ return double_from_string_with_check(&m_string);
+ case TIME_RESULT:
+ /*
+ This works for example when user says SELECT ?+0.0 and supplies
+ time value for the placeholder.
+ */
+ return TIME_to_double(&time);
+ case ROW_RESULT:
+ DBUG_ASSERT(0);
+ break;
+ }
+ return 0.0;
+}
+
+
+longlong Item_param::PValue::val_int(const Type_std_attributes *attr) const
+{
+ switch (type_handler()->cmp_type()) {
+ case REAL_RESULT:
+ return Converter_double_to_longlong(real, attr->unsigned_flag).result();
+ case INT_RESULT:
+ return integer;
+ case DECIMAL_RESULT:
+ return m_decimal.to_longlong(attr->unsigned_flag);
+ case STRING_RESULT:
+ return longlong_from_string_with_check(&m_string);
+ case TIME_RESULT:
+ return (longlong) TIME_to_ulonglong(&time);
+ case ROW_RESULT:
+ DBUG_ASSERT(0);
+ break;
+ }
+ return 0;
+}
+
+
+my_decimal *Item_param::PValue::val_decimal(my_decimal *dec,
+ const Type_std_attributes *attr)
+{
+ switch (type_handler()->cmp_type()) {
+ case DECIMAL_RESULT:
+ return &m_decimal;
+ case REAL_RESULT:
+ double2my_decimal(E_DEC_FATAL_ERROR, real, dec);
+ return dec;
+ case INT_RESULT:
+ int2my_decimal(E_DEC_FATAL_ERROR, integer, attr->unsigned_flag, dec);
+ return dec;
+ case STRING_RESULT:
+ return decimal_from_string_with_check(dec, &m_string);
+ case TIME_RESULT:
+ return TIME_to_my_decimal(&time, dec);
+ case ROW_RESULT:
+ DBUG_ASSERT(0);
+ break;
+ }
+ return 0;
+}
+
+
+String *Item_param::PValue::val_str(String *str,
+ const Type_std_attributes *attr)
+{
+ switch (type_handler()->cmp_type()) {
+ case STRING_RESULT:
+ return &m_string_ptr;
+ case REAL_RESULT:
+ str->set_real(real, NOT_FIXED_DEC, &my_charset_bin);
+ return str;
+ case INT_RESULT:
+ str->set_int(integer, attr->unsigned_flag, &my_charset_bin);
+ return str;
+ case DECIMAL_RESULT:
+ if (m_decimal.to_string_native(str, 0, 0, 0) <= 1)
+ return str;
+ return NULL;
+ case TIME_RESULT:
+ {
+ if (str->reserve(MAX_DATE_STRING_REP_LENGTH))
+ return NULL;
+ str->length((uint) my_TIME_to_str(&time, (char*) str->ptr(),
+ attr->decimals));
+ str->set_charset(&my_charset_bin);
+ return str;
+ }
+ case ROW_RESULT:
+ DBUG_ASSERT(0);
+ break;
+ }
+ return NULL;
+}
+
+
+/**
+ Return Param item values in string format, for generating the dynamic
+ query used in update/binary logs.
+
+ @todo
+ - Change interface and implementation to fill log data in place
+ and avoid one more memcpy/alloc between str and log string.
+ - In case of error we need to notify replication
+ that binary log contains wrong statement
+*/
+
+const String *Item_param::value_query_val_str(THD *thd, String *str) const
+{
+ switch (value.type_handler()->cmp_type()) {
+ case INT_RESULT:
+ str->set_int(value.integer, unsigned_flag, &my_charset_bin);
+ return str;
+ case REAL_RESULT:
+ str->set_real(value.real, NOT_FIXED_DEC, &my_charset_bin);
+ return str;
+ case DECIMAL_RESULT:
+ if (value.m_decimal.to_string_native(str, 0, 0, 0) > 1)
+ return &my_null_string;
+ return str;
+ case TIME_RESULT:
+ {
+ static const uint32 typelen= 9; // "TIMESTAMP" is the longest type name
+ char *buf, *ptr;
+ str->length(0);
+ /*
+ TODO: in case of error we need to notify replication
+ that binary log contains wrong statement
+ */
+ if (str->reserve(MAX_DATE_STRING_REP_LENGTH + 3 + typelen))
+ return NULL;
+
+ /* Create date string inplace */
+ switch (value.time.time_type) {
+ case MYSQL_TIMESTAMP_DATE:
+ str->append(STRING_WITH_LEN("DATE"));
+ break;
+ case MYSQL_TIMESTAMP_TIME:
+ str->append(STRING_WITH_LEN("TIME"));
+ break;
+ case MYSQL_TIMESTAMP_DATETIME:
+ str->append(STRING_WITH_LEN("TIMESTAMP"));
+ break;
+ case MYSQL_TIMESTAMP_ERROR:
+ case MYSQL_TIMESTAMP_NONE:
+ break;
+ }
+ DBUG_ASSERT(str->length() <= typelen);
+ buf= str->c_ptr_quick();
+ ptr= buf + str->length();
+ *ptr++= '\'';
+ ptr+= (uint) my_TIME_to_str(&value.time, ptr, decimals);
+ *ptr++= '\'';
+ str->length((uint32) (ptr - buf));
+ return str;
+ }
+ case STRING_RESULT:
+ {
+ str->length(0);
+ append_query_string(value.cs_info.character_set_client, str,
+ value.m_string.ptr(), value.m_string.length(),
+ thd->variables.sql_mode & MODE_NO_BACKSLASH_ESCAPES);
+ return str;
+ }
+ case ROW_RESULT:
+ DBUG_ASSERT(0);
+ break;
+ }
+ return NULL;
+}
+
+
+const String *Item_param::query_val_str(THD *thd, String* str) const
+{
+ // There's no "default". See comments in Item_param::save_in_field().
+ switch (state) {
+ case SHORT_DATA_VALUE:
+ case LONG_DATA_VALUE:
+ return value_query_val_str(thd, str);
+ case IGNORE_VALUE:
+ case DEFAULT_VALUE:
+ return &my_default_string;
+ case NULL_VALUE:
+ return &my_null_string;
+ case NO_VALUE:
+ DBUG_ASSERT(0); // Should not be possible
+ return NULL;
+ }
+ DBUG_ASSERT(0); // Garbage
+ return NULL;
+}
+
+
+/**
+ Convert string from client character set to the character set of
+ connection.
+*/
+
+bool Item_param::convert_str_value(THD *thd)
+{
+ bool rc= FALSE;
+ if ((state == SHORT_DATA_VALUE || state == LONG_DATA_VALUE) &&
+ value.type_handler()->cmp_type() == STRING_RESULT)
+ {
+ rc= value.cs_info.convert_if_needed(thd, &value.m_string);
+ /* Here str_value is guaranteed to be in final_character_set_of_str_value */
+
+ /*
+ str_value_ptr is returned from val_str(). It must be not alloced
+ to prevent it's modification by val_str() invoker.
+ */
+ value.m_string_ptr.set(value.m_string.ptr(), value.m_string.length(),
+ value.m_string.charset());
+ /* Synchronize item charset and length with value charset */
+ fix_charset_and_length_from_str_value(value.m_string, DERIVATION_COERCIBLE);
+ }
+ return rc;
+}
+
+
+bool Item_param::basic_const_item() const
+{
+ switch (state) {
+ case LONG_DATA_VALUE:
+ case NULL_VALUE:
+ return true;
+ case SHORT_DATA_VALUE:
+ return type_handler()->cmp_type() != TIME_RESULT;
+ case DEFAULT_VALUE:
+ case IGNORE_VALUE:
+ invalid_default_param();
+ return false;
+ case NO_VALUE:
+ break;
+ }
+ return false;
+}
+
+
+Item *Item_param::value_clone_item(THD *thd)
+{
+ MEM_ROOT *mem_root= thd->mem_root;
+ switch (value.type_handler()->cmp_type()) {
+ case INT_RESULT:
+ return (unsigned_flag ?
+ new (mem_root) Item_uint(thd, name.str, value.integer, max_length) :
+ new (mem_root) Item_int(thd, name.str, value.integer, max_length));
+ case REAL_RESULT:
+ return new (mem_root) Item_float(thd, name.str, value.real, decimals,
+ max_length);
+ case DECIMAL_RESULT:
+ return 0; // Should create Item_decimal. See MDEV-11361.
+ case STRING_RESULT:
+ return new (mem_root) Item_string(thd, name,
+ Lex_cstring(value.m_string.c_ptr_quick(),
+ value.m_string.length()),
+ value.m_string.charset(),
+ collation.derivation,
+ collation.repertoire);
+ case TIME_RESULT:
+ break;
+ case ROW_RESULT:
+ DBUG_ASSERT(0);
+ break;
+ }
+ return 0;
+}
+
+
+/* see comments in the header file */
+
+Item *
+Item_param::clone_item(THD *thd)
+{
+ // There's no "default". See comments in Item_param::save_in_field().
+ switch (state) {
+ case IGNORE_VALUE:
+ case DEFAULT_VALUE:
+ invalid_default_param();
+ // fall through
+ case NULL_VALUE:
+ return new (thd->mem_root) Item_null(thd, name.str);
+ case SHORT_DATA_VALUE:
+ case LONG_DATA_VALUE:
+ {
+ DBUG_ASSERT(type_handler()->cmp_type() == value.type_handler()->cmp_type());
+ return value_clone_item(thd);
+ }
+ case NO_VALUE:
+ return 0;
+ }
+ DBUG_ASSERT(0); // Garbage
+ return 0;
+}
+
+
+/* End of Item_param related */
+
+void Item_param::print(String *str, enum_query_type query_type)
+{
+ if (state == NO_VALUE)
+ {
+ str->append('?');
+ }
+ else if (state == DEFAULT_VALUE)
+ {
+ str->append("default");
+ }
+ else if (state == IGNORE_VALUE)
+ {
+ str->append("ignore");
+ }
+ else
+ {
+ char buffer[STRING_BUFFER_USUAL_SIZE];
+ String tmp(buffer, sizeof(buffer), &my_charset_bin);
+ const String *res;
+ res= query_val_str(current_thd, &tmp);
+ str->append(*res);
+ }
+}
+
+
+/**
+ Preserve the original parameter types and values
+ when re-preparing a prepared statement.
+
+ @details Copy parameter type information and conversion
+ function pointers from a parameter of the old statement
+ to the corresponding parameter of the new one.
+
+ Move parameter values from the old parameters to the new
+ one. We simply "exchange" the values, which allows
+ to save on allocation and character set conversion in
+ case a parameter is a string or a blob/clob.
+
+ The old parameter gets the value of this one, which
+ ensures that all memory of this parameter is freed
+ correctly.
+
+ @param[in] src parameter item of the original
+ prepared statement
+*/
+
+void
+Item_param::set_param_type_and_swap_value(Item_param *src)
+{
+ Type_std_attributes::set(src);
+ set_handler(src->type_handler());
+
+ maybe_null= src->maybe_null;
+ null_value= src->null_value;
+ state= src->state;
+
+ value.swap(src->value);
+}
+
+
+void Item_param::set_default()
+{
+ m_is_settable_routine_parameter= false;
+ state= DEFAULT_VALUE;
+ /*
+ When Item_param is set to DEFAULT_VALUE:
+ - its val_str() and val_decimal() return NULL
+ - get_date() returns true
+ It's important also to have null_value==true for DEFAULT_VALUE.
+ Otherwise the callers of val_xxx() and get_date(), e.g. Item::send(),
+ can misbehave (e.g. crash on asserts).
+ */
+ null_value= true;
+}
+
+void Item_param::set_ignore()
+{
+ m_is_settable_routine_parameter= false;
+ state= IGNORE_VALUE;
+ null_value= true;
+}
+
+/**
+ This operation is intended to store some item value in Item_param to be
+ used later.
+
+ @param thd thread context
+ @param ctx stored procedure runtime context
+ @param it a pointer to an item in the tree
+
+ @return Error status
+ @retval TRUE on error
+ @retval FALSE on success
+*/
+
+bool
+Item_param::set_value(THD *thd, sp_rcontext *ctx, Item **it)
+{
+ Item *arg= *it;
+ struct st_value tmp;
+ /*
+ The OUT parameter is bound to some data type.
+ It's important not to touch m_type_handler,
+ to make sure the next mysql_stmt_execute()
+ correctly fetches the value from the client-server protocol,
+ using set_param_func().
+ */
+ if (arg->save_in_value(thd, &tmp) ||
+ set_value(thd, arg, &tmp, arg->type_handler()))
+ {
+ set_null();
+ return false;
+ }
+ /* It is wrapper => other set_* shoud set null_value */
+ DBUG_ASSERT(null_value == false);
+ return false;
+}
+
+
+/**
+ Setter of Item_param::m_out_param_info.
+
+ m_out_param_info is used to store information about store routine
+ OUT-parameters, such as stored routine name, database, stored routine
+ variable name. It is supposed to be set in sp_head::execute() after
+ Item_param::set_value() is called.
+*/
+
+void
+Item_param::set_out_param_info(Send_field *info)
+{
+ m_out_param_info= info;
+ set_handler(m_out_param_info->type_handler());
+}
+
+
+/**
+ Getter of Item_param::m_out_param_info.
+
+ m_out_param_info is used to store information about store routine
+ OUT-parameters, such as stored routine name, database, stored routine
+ variable name. It is supposed to be retrieved in
+ Protocol_binary::send_out_parameters() during creation of OUT-parameter
+ result set.
+*/
+
+const Send_field *
+Item_param::get_out_param_info() const
+{
+ return m_out_param_info;
+}
+
+
+/**
+ Fill meta-data information for the corresponding column in a result set.
+ If this is an OUT-parameter of a stored procedure, preserve meta-data of
+ stored-routine variable.
+
+ @param field container for meta-data to be filled
+*/
+
+void Item_param::make_send_field(THD *thd, Send_field *field)
+{
+ Item::make_send_field(thd, field);
+
+ if (!m_out_param_info)
+ return;
+
+ /*
+ This is an OUT-parameter of stored procedure. We should use
+ OUT-parameter info to fill out the names.
+ */
+
+ *field= *m_out_param_info;
+}
+
+bool Item_param::append_for_log(THD *thd, String *str)
+{
+ StringBuffer<STRING_BUFFER_USUAL_SIZE> buf;
+ const String *val= query_val_str(thd, &buf);
+ return str->append(*val);
+}
+
+
+/****************************************************************************
+ Item_copy_string
+****************************************************************************/
+
+double Item_copy_string::val_real()
+{
+ int err_not_used;
+ char *end_not_used;
+ return (null_value ? 0.0 :
+ str_value.charset()->strntod((char*) str_value.ptr(),
+ str_value.length(),
+ &end_not_used, &err_not_used));
+}
+
+longlong Item_copy_string::val_int()
+{
+ int err;
+ return null_value ? 0 : str_value.charset()->strntoll(str_value.ptr(),
+ str_value.length(), 10,
+ (char**) 0, &err);
+}
+
+
+int Item_copy_string::save_in_field(Field *field, bool no_conversions)
+{
+ return save_str_value_in_field(field, &str_value);
+}
+
+
+void Item_copy_string::copy()
+{
+ String *res=item->val_str(&str_value);
+ if (res && res != &str_value)
+ str_value.copy(*res);
+ null_value=item->null_value;
+}
+
+/* ARGSUSED */
+String *Item_copy_string::val_str(String *str)
+{
+ // Item_copy_string is used without fix_fields call
+ if (null_value)
+ return (String*) 0;
+ return &str_value;
+}
+
+
+my_decimal *Item_copy_string::val_decimal(my_decimal *decimal_value)
+{
+ // Item_copy_string is used without fix_fields call
+ if (null_value)
+ return (my_decimal *) 0;
+ string2my_decimal(E_DEC_FATAL_ERROR, &str_value, decimal_value);
+ return (decimal_value);
+}
+
+
+/*
+ Functions to convert item to field (for send_result_set_metadata)
+*/
+
+void Item_ref_null_helper::save_val(Field *to)
+{
+ DBUG_ASSERT(fixed == 1);
+ (*ref)->save_val(to);
+ owner->was_null|= null_value= (*ref)->null_value;
+}
+
+
+double Item_ref_null_helper::val_real()
+{
+ DBUG_ASSERT(fixed == 1);
+ double tmp= (*ref)->val_result();
+ owner->was_null|= null_value= (*ref)->null_value;
+ return tmp;
+}
+
+
+longlong Item_ref_null_helper::val_int()
+{
+ DBUG_ASSERT(fixed == 1);
+ longlong tmp= (*ref)->val_int_result();
+ owner->was_null|= null_value= (*ref)->null_value;
+ return tmp;
+}
+
+
+my_decimal *Item_ref_null_helper::val_decimal(my_decimal *decimal_value)
+{
+ DBUG_ASSERT(fixed == 1);
+ my_decimal *val= (*ref)->val_decimal_result(decimal_value);
+ owner->was_null|= null_value= (*ref)->null_value;
+ return val;
+}
+
+
+bool Item_ref_null_helper::val_bool()
+{
+ DBUG_ASSERT(fixed == 1);
+ bool val= (*ref)->val_bool_result();
+ owner->was_null|= null_value= (*ref)->null_value;
+ return val;
+}
+
+
+String* Item_ref_null_helper::val_str(String* s)
+{
+ DBUG_ASSERT(fixed == 1);
+ String* tmp= (*ref)->str_result(s);
+ owner->was_null|= null_value= (*ref)->null_value;
+ return tmp;
+}
+
+
+bool Item_ref_null_helper::val_native(THD *thd, Native *to)
+{
+ return (owner->was_null|= val_native_from_item(thd, *ref, to));
+}
+
+
+bool Item_ref_null_helper::get_date(THD *thd, MYSQL_TIME *ltime,
+ date_mode_t fuzzydate)
+{
+ return (owner->was_null|= null_value= (*ref)->get_date_result(thd, ltime,
+ fuzzydate));
+}
+
+
+/**
+ Mark item and SELECT_LEXs as dependent if item was resolved in
+ outer SELECT.
+
+ @param thd thread handler
+ @param last select from which current item depend
+ @param current current select
+ @param resolved_item item which was resolved in outer SELECT(for warning)
+ @param mark_item item which should be marked (can be differ in case of
+ substitution)
+ @param suppress_warning_output flag specifying whether to suppress output of
+ a warning message
+*/
+
+static bool mark_as_dependent(THD *thd, SELECT_LEX *last, SELECT_LEX *current,
+ Item_ident *resolved_item,
+ Item_ident *mark_item,
+ bool suppress_warning_output)
+{
+ DBUG_ENTER("mark_as_dependent");
+ DBUG_PRINT("info", ("current select: %d (%p) last: %d (%p)",
+ current->select_number, current,
+ (last ? last->select_number : 0), last));
+
+ /* store pointer on SELECT_LEX from which item is dependent */
+ if (mark_item && mark_item->can_be_depended)
+ {
+ DBUG_PRINT("info", ("mark_item: %p lex: %p", mark_item, last));
+ mark_item->depended_from= last;
+ }
+ if (current->mark_as_dependent(thd, last,
+ /** resolved_item psergey-thu **/ mark_item))
+ DBUG_RETURN(TRUE);
+ if ((thd->lex->describe & DESCRIBE_EXTENDED) && !suppress_warning_output)
+ {
+ const char *db_name= (resolved_item->db_name.str ?
+ resolved_item->db_name.str : "");
+ const char *table_name= (resolved_item->table_name.str ?
+ resolved_item->table_name.str : "");
+ push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
+ ER_WARN_FIELD_RESOLVED,
+ ER_THD(thd,ER_WARN_FIELD_RESOLVED),
+ db_name, (db_name[0] ? "." : ""),
+ table_name, (table_name [0] ? "." : ""),
+ resolved_item->field_name.str,
+ current->select_number, last->select_number);
+ }
+ DBUG_RETURN(FALSE);
+}
+
+
+/**
+ Mark range of selects and resolved identifier (field/reference)
+ item as dependent.
+
+ @param thd thread handler
+ @param last_select select where resolved_item was resolved
+ @param current_sel current select (select where resolved_item was placed)
+ @param found_field field which was found during resolving
+ @param found_item Item which was found during resolving (if resolved
+ identifier belongs to VIEW)
+ @param resolved_item Identifier which was resolved
+ @param suppress_warning_output flag specifying whether to suppress output of
+ a warning message
+
+ @note
+ We have to mark all items between current_sel (including) and
+ last_select (excluding) as dependent (select before last_select should
+ be marked with actual table mask used by resolved item, all other with
+ OUTER_REF_TABLE_BIT) and also write dependence information to Item of
+ resolved identifier.
+*/
+
+void mark_select_range_as_dependent(THD *thd, SELECT_LEX *last_select,
+ SELECT_LEX *current_sel,
+ Field *found_field, Item *found_item,
+ Item_ident *resolved_item,
+ bool suppress_warning_output)
+{
+ /*
+ Go from current SELECT to SELECT where field was resolved (it
+ have to be reachable from current SELECT, because it was already
+ done once when we resolved this field and cached result of
+ resolving)
+ */
+ SELECT_LEX *previous_select= current_sel;
+ for (; previous_select->context.outer_select() != last_select;
+ previous_select= previous_select->context.outer_select())
+ {
+ Item_subselect *prev_subselect_item=
+ previous_select->master_unit()->item;
+ prev_subselect_item->used_tables_cache|= OUTER_REF_TABLE_BIT;
+ prev_subselect_item->const_item_cache= 0;
+ }
+
+ Item_subselect *prev_subselect_item=
+ previous_select->master_unit()->item;
+ Item_ident *dependent= resolved_item;
+ if (found_field == view_ref_found)
+ {
+ Item::Type type= found_item->type();
+ prev_subselect_item->used_tables_cache|=
+ found_item->used_tables();
+ dependent= ((type == Item::REF_ITEM || type == Item::FIELD_ITEM) ?
+ (Item_ident*) found_item :
+ 0);
+ }
+ else
+ prev_subselect_item->used_tables_cache|=
+ found_field->table->map;
+ prev_subselect_item->const_item_cache= 0;
+ mark_as_dependent(thd, last_select, current_sel, resolved_item,
+ dependent, suppress_warning_output);
+}
+
+
+/**
+ Search a GROUP BY clause for a field with a certain name.
+
+ Search the GROUP BY list for a column named as find_item. When searching
+ preference is given to columns that are qualified with the same table (and
+ database) name as the one being searched for.
+
+ @param find_item the item being searched for
+ @param group_list GROUP BY clause
+
+ @return
+ - the found item on success
+ - NULL if find_item is not in group_list
+*/
+
+static Item** find_field_in_group_list(Item *find_item, ORDER *group_list)
+{
+ LEX_CSTRING db_name;
+ LEX_CSTRING table_name;
+ LEX_CSTRING field_name;
+ ORDER *found_group= NULL;
+ int found_match_degree= 0;
+ char name_buff[SAFE_NAME_LEN+1];
+
+ if (find_item->type() == Item::FIELD_ITEM ||
+ find_item->type() == Item::REF_ITEM)
+ {
+ db_name= ((Item_ident*) find_item)->db_name;
+ table_name= ((Item_ident*) find_item)->table_name;
+ field_name= ((Item_ident*) find_item)->field_name;
+ }
+ else
+ return NULL;
+
+ if (db_name.str && lower_case_table_names)
+ {
+ /* Convert database to lower case for comparison */
+ strmake_buf(name_buff, db_name.str);
+ my_casedn_str(files_charset_info, name_buff);
+ db_name= Lex_cstring_strlen(name_buff);
+ }
+
+ DBUG_ASSERT(field_name.str != 0);
+
+ for (ORDER *cur_group= group_list ; cur_group ; cur_group= cur_group->next)
+ {
+ int cur_match_degree= 0;
+
+ /* SELECT list element with explicit alias */
+ if ((*(cur_group->item))->name.str && !table_name.str &&
+ !(*(cur_group->item))->is_autogenerated_name() &&
+ !lex_string_cmp(system_charset_info,
+ &(*(cur_group->item))->name, &field_name))
+ {
+ ++cur_match_degree;
+ }
+ /* Reference on the field or view/derived field. */
+ else if ((*(cur_group->item))->type() == Item::FIELD_ITEM ||
+ (*(cur_group->item))->type() == Item::REF_ITEM )
+ {
+ Item_ident *cur_field= (Item_ident*) *cur_group->item;
+ const char *l_db_name= cur_field->db_name.str;
+ const char *l_table_name= cur_field->table_name.str;
+ LEX_CSTRING *l_field_name= &cur_field->field_name;
+
+ DBUG_ASSERT(l_field_name->str != 0);
+
+ if (!lex_string_cmp(system_charset_info,
+ l_field_name, &field_name))
+ ++cur_match_degree;
+ else
+ continue;
+
+ if (l_table_name && table_name.str)
+ {
+ /* If field_name is qualified by a table name. */
+ if (my_strcasecmp(table_alias_charset, l_table_name, table_name.str))
+ /* Same field names, different tables. */
+ return NULL;
+
+ ++cur_match_degree;
+ if (l_db_name && db_name.str)
+ {
+ /* If field_name is also qualified by a database name. */
+ if (strcmp(l_db_name, db_name.str))
+ /* Same field names, different databases. */
+ return NULL;
+ ++cur_match_degree;
+ }
+ }
+ }
+ else
+ continue;
+
+ if (cur_match_degree > found_match_degree)
+ {
+ found_match_degree= cur_match_degree;
+ found_group= cur_group;
+ }
+ else if (found_group && (cur_match_degree == found_match_degree) &&
+ !(*(found_group->item))->eq((*(cur_group->item)), 0))
+ {
+ /*
+ If the current resolve candidate matches equally well as the current
+ best match, they must reference the same column, otherwise the field
+ is ambiguous.
+ */
+ my_error(ER_NON_UNIQ_ERROR, MYF(0),
+ find_item->full_name(), current_thd->where);
+ return NULL;
+ }
+ }
+
+ if (found_group)
+ return found_group->item;
+ else
+ return NULL;
+}
+
+
+/**
+ Resolve a column reference in a sub-select.
+
+ Resolve a column reference (usually inside a HAVING clause) against the
+ SELECT and GROUP BY clauses of the query described by 'select'. The name
+ resolution algorithm searches both the SELECT and GROUP BY clauses, and in
+ case of a name conflict prefers GROUP BY column names over SELECT names. If
+ both clauses contain different fields with the same names, a warning is
+ issued that name of 'ref' is ambiguous. We extend ANSI SQL in that when no
+ GROUP BY column is found, then a HAVING name is resolved as a possibly
+ derived SELECT column. This extension is allowed only if the
+ MODE_ONLY_FULL_GROUP_BY sql mode isn't enabled.
+
+ @param thd current thread
+ @param ref column reference being resolved
+ @param select the select that ref is resolved against
+
+ @note
+ The resolution procedure is:
+ - Search for a column or derived column named col_ref_i [in table T_j]
+ in the SELECT clause of Q.
+ - Search for a column named col_ref_i [in table T_j]
+ in the GROUP BY clause of Q.
+ - If found different columns with the same name in GROUP BY and SELECT:
+ - if the condition that uses this column name is pushed down into
+ the HAVING clause return the SELECT column
+ - else issue a warning and return the GROUP BY column.
+ - Otherwise
+ - if the MODE_ONLY_FULL_GROUP_BY mode is enabled return error
+ - else return the found SELECT column.
+
+
+ @return
+ - NULL - there was an error, and the error was already reported
+ - not_found_item - the item was not resolved, no error was reported
+ - resolved item - if the item was resolved
+*/
+
+static Item**
+resolve_ref_in_select_and_group(THD *thd, Item_ident *ref, SELECT_LEX *select)
+{
+ Item **group_by_ref= NULL;
+ Item **select_ref= NULL;
+ ORDER *group_list= select->group_list.first;
+ bool ambiguous_fields= FALSE;
+ uint counter;
+ enum_resolution_type resolution;
+
+ /*
+ Search for a column or derived column named as 'ref' in the SELECT
+ clause of the current select.
+ */
+ if (!(select_ref= find_item_in_list(ref, *(select->get_item_list()),
+ &counter, REPORT_EXCEPT_NOT_FOUND,
+ &resolution)))
+ return NULL; /* Some error occurred. */
+ if (resolution == RESOLVED_AGAINST_ALIAS)
+ ref->alias_name_used= TRUE;
+
+ /* If this is a non-aggregated field inside HAVING, search in GROUP BY. */
+ if (select->having_fix_field && !ref->with_sum_func() && group_list)
+ {
+ group_by_ref= find_field_in_group_list(ref, group_list);
+
+ /* Check if the fields found in SELECT and GROUP BY are the same field. */
+ if (group_by_ref && (select_ref != not_found_item) &&
+ !((*group_by_ref)->eq(*select_ref, 0)) &&
+ (!select->having_fix_field_for_pushed_cond))
+ {
+ ambiguous_fields= TRUE;
+ push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+ ER_NON_UNIQ_ERROR,
+ ER_THD(thd,ER_NON_UNIQ_ERROR), ref->full_name(),
+ thd->where);
+
+ }
+ }
+
+ if (thd->variables.sql_mode & MODE_ONLY_FULL_GROUP_BY &&
+ select->having_fix_field &&
+ select_ref != not_found_item && !group_by_ref &&
+ !ref->alias_name_used)
+ {
+ /*
+ Report the error if fields was found only in the SELECT item list and
+ the strict mode is enabled.
+ */
+ my_error(ER_NON_GROUPING_FIELD_USED, MYF(0),
+ ref->name.str, "HAVING");
+ return NULL;
+ }
+ if (select_ref != not_found_item || group_by_ref)
+ {
+ if (select_ref != not_found_item && !ambiguous_fields)
+ {
+ DBUG_ASSERT(*select_ref != 0);
+ if (!select->ref_pointer_array[counter])
+ {
+ my_error(ER_ILLEGAL_REFERENCE, MYF(0),
+ ref->name.str, "forward reference in item list");
+ return NULL;
+ }
+ DBUG_ASSERT((*select_ref)->is_fixed());
+ return &select->ref_pointer_array[counter];
+ }
+ if (group_by_ref)
+ return group_by_ref;
+ DBUG_ASSERT(FALSE);
+ return NULL; /* So there is no compiler warning. */
+ }
+
+ return (Item**) not_found_item;
+}
+
+
+/*
+ @brief
+ Whether a table belongs to an outer select.
+
+ @param table table to check
+ @param select current select
+
+ @details
+ Try to find select the table belongs to by ascending the derived tables chain.
+*/
+
+static
+bool is_outer_table(TABLE_LIST *table, SELECT_LEX *select)
+{
+ DBUG_ASSERT(table->select_lex != select);
+ TABLE_LIST *tl;
+
+ if (table->belong_to_view &&
+ table->belong_to_view->select_lex == select)
+ return FALSE;
+
+ for (tl= select->master_unit()->derived;
+ tl && tl->is_merged_derived();
+ select= tl->select_lex, tl= select->master_unit()->derived)
+ {
+ if (tl->select_lex == table->select_lex)
+ return FALSE;
+ }
+ return TRUE;
+}
+
+
+/**
+ Resolve the name of an outer select column reference.
+
+ @param[in] thd current thread
+ @param[in,out] from_field found field reference or (Field*)not_found_field
+ @param[in,out] reference view column if this item was resolved to a
+ view column
+
+ @description
+ The method resolves the column reference represented by 'this' as a column
+ present in outer selects that contain current select.
+
+ In prepared statements, because of cache, find_field_in_tables()
+ can resolve fields even if they don't belong to current context.
+ In this case this method only finds appropriate context and marks
+ current select as dependent. The found reference of field should be
+ provided in 'from_field'.
+
+ The cache is critical for prepared statements of type:
+
+ SELECT a FROM (SELECT a FROM test.t1) AS s1 NATURAL JOIN t2 AS s2;
+
+ This is internally converted to a join similar to
+
+ SELECT a FROM t1 AS s1,t2 AS s2 WHERE t2.a=t1.a;
+
+ Without the cache, we would on re-prepare not know if 'a' did match
+ s1.a or s2.a.
+
+ @note
+ This is the inner loop of Item_field::fix_fields:
+ @code
+ for each outer query Q_k beginning from the inner-most one
+ {
+ search for a column or derived column named col_ref_i
+ [in table T_j] in the FROM clause of Q_k;
+
+ if such a column is not found
+ Search for a column or derived column named col_ref_i
+ [in table T_j] in the SELECT and GROUP clauses of Q_k.
+ }
+ @endcode
+
+ @retval
+ 1 column succefully resolved and fix_fields() should continue.
+ @retval
+ 0 column fully fixed and fix_fields() should return FALSE
+ @retval
+ -1 error occurred
+*/
+
+int
+Item_field::fix_outer_field(THD *thd, Field **from_field, Item **reference)
+{
+ enum_parsing_place place= NO_MATTER;
+ bool field_found= (*from_field != not_found_field);
+ bool upward_lookup= FALSE;
+ TABLE_LIST *table_list;
+
+ /* Calculate the TABLE_LIST for the table */
+ table_list= (cached_table ? cached_table :
+ field_found && (*from_field) != view_ref_found ?
+ (*from_field)->table->pos_in_table_list : 0);
+ /*
+ If there are outer contexts (outer selects, but current select is
+ not derived table or view) try to resolve this reference in the
+ outer contexts.
+
+ We treat each subselect as a separate namespace, so that different
+ subselects may contain columns with the same names. The subselects
+ are searched starting from the innermost.
+ */
+ Name_resolution_context *last_checked_context= context;
+ Item **ref= (Item **) not_found_item;
+ SELECT_LEX *current_sel= thd->lex->current_select;
+ Name_resolution_context *outer_context= 0;
+ SELECT_LEX *select= 0;
+ /* Currently derived tables cannot be correlated */
+ if ((current_sel->master_unit()->first_select()->get_linkage() !=
+ DERIVED_TABLE_TYPE) &&
+ current_sel->master_unit()->outer_select())
+ outer_context= context->outer_context;
+
+ /*
+ This assert is to ensure we have an outer contex when *from_field
+ is set.
+ If this would not be the case, we would assert in mark_as_dependent
+ as last_checked_countex == context
+ */
+ DBUG_ASSERT(outer_context || !*from_field ||
+ *from_field == not_found_field);
+ for (;
+ outer_context;
+ outer_context= outer_context->outer_context)
+ {
+ select= outer_context->select_lex;
+ Item_subselect *prev_subselect_item=
+ last_checked_context->select_lex->master_unit()->item;
+ last_checked_context= outer_context;
+ upward_lookup= TRUE;
+
+ place= prev_subselect_item->parsing_place;
+ /*
+ If outer_field is set, field was already found by first call
+ to find_field_in_tables(). Only need to find appropriate context.
+ */
+ if (field_found && outer_context->select_lex !=
+ table_list->select_lex)
+ continue;
+ /*
+ In case of a view, find_field_in_tables() writes the pointer to
+ the found view field into '*reference', in other words, it
+ substitutes this Item_field with the found expression.
+ */
+ if (field_found || (*from_field= find_field_in_tables(thd, this,
+ outer_context->
+ first_name_resolution_table,
+ outer_context->
+ last_name_resolution_table,
+ reference,
+ IGNORE_EXCEPT_NON_UNIQUE,
+ TRUE, TRUE)) !=
+ not_found_field)
+ {
+ if (*from_field)
+ {
+ if (thd->variables.sql_mode & MODE_ONLY_FULL_GROUP_BY &&
+ select->cur_pos_in_select_list != UNDEF_POS)
+ {
+ /*
+ As this is an outer field it should be added to the list of
+ non aggregated fields of the outer select.
+ */
+ if (select->join)
+ {
+ marker= select->cur_pos_in_select_list;
+ select->join->non_agg_fields.push_back(this, thd->mem_root);
+ }
+ else
+ {
+ /*
+ join is absent if it is upper SELECT_LEX of non-select
+ command
+ */
+ DBUG_ASSERT(select->master_unit()->outer_select() == NULL &&
+ (thd->lex->sql_command != SQLCOM_SELECT &&
+ thd->lex->sql_command != SQLCOM_UPDATE_MULTI &&
+ thd->lex->sql_command != SQLCOM_DELETE_MULTI &&
+ thd->lex->sql_command != SQLCOM_INSERT_SELECT &&
+ thd->lex->sql_command != SQLCOM_REPLACE_SELECT));
+ }
+ }
+ if (*from_field != view_ref_found)
+ {
+ prev_subselect_item->used_tables_cache|= (*from_field)->table->map;
+ prev_subselect_item->const_item_cache= 0;
+ set_field(*from_field);
+ if (!last_checked_context->select_lex->having_fix_field &&
+ select->group_list.elements &&
+ (place == SELECT_LIST || place == IN_HAVING))
+ {
+ Item_outer_ref *rf;
+ /*
+ If an outer field is resolved in a grouping select then it
+ is replaced for an Item_outer_ref object. Otherwise an
+ Item_field object is used.
+ The new Item_outer_ref object is saved in the inner_refs_list of
+ the outer select. Here it is only created. It can be fixed only
+ after the original field has been fixed and this is done in the
+ fix_inner_refs() function.
+ */
+ ;
+ if (!(rf= new (thd->mem_root) Item_outer_ref(thd, context, this)))
+ return -1;
+ thd->change_item_tree(reference, rf);
+ select->inner_refs_list.push_back(rf, thd->mem_root);
+ rf->in_sum_func= thd->lex->in_sum_func;
+ }
+ /*
+ A reference is resolved to a nest level that's outer or the same as
+ the nest level of the enclosing set function : adjust the value of
+ max_arg_level for the function if it's needed.
+ */
+ if (thd->lex->in_sum_func &&
+ thd->lex->in_sum_func->nest_level >= select->nest_level)
+ {
+ Item::Type ref_type= (*reference)->type();
+ set_if_bigger(thd->lex->in_sum_func->max_arg_level,
+ select->nest_level);
+ set_field(*from_field);
+ fixed= 1;
+ mark_as_dependent(thd, last_checked_context->select_lex,
+ context->select_lex, this,
+ ((ref_type == REF_ITEM ||
+ ref_type == FIELD_ITEM) ?
+ (Item_ident*) (*reference) : 0), false);
+ return 0;
+ }
+ }
+ else
+ {
+ Item::Type ref_type= (*reference)->type();
+ prev_subselect_item->used_tables_and_const_cache_join(*reference);
+ mark_as_dependent(thd, last_checked_context->select_lex,
+ context->select_lex, this,
+ ((ref_type == REF_ITEM || ref_type == FIELD_ITEM) ?
+ (Item_ident*) (*reference) :
+ 0), false);
+ if (thd->lex->in_sum_func &&
+ thd->lex->in_sum_func->nest_level >= select->nest_level)
+ {
+ set_if_bigger(thd->lex->in_sum_func->max_arg_level,
+ select->nest_level);
+ }
+ /*
+ A reference to a view field had been found and we
+ substituted it instead of this Item (find_field_in_tables
+ does it by assigning the new value to *reference), so now
+ we can return from this function.
+ */
+ return 0;
+ }
+ }
+ break;
+ }
+
+ /* Search in SELECT and GROUP lists of the outer select. */
+ if (place != IN_WHERE && place != IN_ON)
+ {
+ if (!(ref= resolve_ref_in_select_and_group(thd, this, select)))
+ return -1; /* Some error occurred (e.g. ambiguous names). */
+ if (ref != not_found_item)
+ {
+ DBUG_ASSERT(*ref && (*ref)->is_fixed());
+ prev_subselect_item->used_tables_and_const_cache_join(*ref);
+ break;
+ }
+ }
+
+ /*
+ Reference is not found in this select => this subquery depend on
+ outer select (or we just trying to find wrong identifier, in this
+ case it does not matter which used tables bits we set)
+ */
+ prev_subselect_item->used_tables_cache|= OUTER_REF_TABLE_BIT;
+ prev_subselect_item->const_item_cache= 0;
+ }
+
+ DBUG_ASSERT(ref != 0);
+ if (!*from_field)
+ return -1;
+ if (ref == not_found_item && *from_field == not_found_field)
+ {
+ if (upward_lookup)
+ {
+ // We can't say exactly what absent table or field
+ my_error(ER_BAD_FIELD_ERROR, MYF(0), full_name(), thd->where);
+ }
+ else
+ {
+ /* Call find_field_in_tables only to report the error */
+ find_field_in_tables(thd, this,
+ context->first_name_resolution_table,
+ context->last_name_resolution_table,
+ reference, REPORT_ALL_ERRORS,
+ !any_privileges, TRUE);
+ }
+ return -1;
+ }
+ else if (ref != not_found_item)
+ {
+ Item *save;
+ Item_ref *rf;
+
+ /* Should have been checked in resolve_ref_in_select_and_group(). */
+ DBUG_ASSERT(*ref && (*ref)->is_fixed());
+ /*
+ Here, a subset of actions performed by Item_ref::set_properties
+ is not enough. So we pass ptr to NULL into Item_[direct]_ref
+ constructor, so no initialization is performed, and call
+ fix_fields() below.
+ */
+ save= *ref;
+ *ref= NULL; // Don't call set_properties()
+ rf= (place == IN_HAVING ?
+ new (thd->mem_root)
+ Item_ref(thd, context, ref, table_name,
+ field_name, alias_name_used) :
+ (!select->group_list.elements ?
+ new (thd->mem_root)
+ Item_direct_ref(thd, context, ref, table_name,
+ field_name, alias_name_used) :
+ new (thd->mem_root)
+ Item_outer_ref(thd, context, ref, table_name,
+ field_name, alias_name_used)));
+ *ref= save;
+ if (!rf)
+ return -1;
+
+ if (place != IN_HAVING && select->group_list.elements)
+ {
+ outer_context->select_lex->inner_refs_list.push_back((Item_outer_ref*)rf,
+ thd->mem_root);
+ ((Item_outer_ref*)rf)->in_sum_func= thd->lex->in_sum_func;
+ }
+ thd->change_item_tree(reference, rf);
+ /*
+ rf is Item_ref => never substitute other items (in this case)
+ during fix_fields() => we can use rf after fix_fields()
+ */
+ DBUG_ASSERT(!rf->fixed); // Assured by Item_ref()
+ if (rf->fix_fields(thd, reference) || rf->check_cols(1))
+ return -1;
+
+ /*
+ We can not "move" aggregate function in the place where
+ its arguments are not defined.
+ */
+ set_max_sum_func_level(thd, select);
+ mark_as_dependent(thd, last_checked_context->select_lex,
+ context->select_lex, rf,
+ rf, false);
+
+ return 0;
+ }
+ else
+ {
+ /*
+ We can not "move" aggregate function in the place where
+ its arguments are not defined.
+ */
+ set_max_sum_func_level(thd, select);
+ mark_as_dependent(thd, last_checked_context->select_lex,
+ context->select_lex,
+ this, (Item_ident*)*reference, false);
+ if (last_checked_context->select_lex->having_fix_field)
+ {
+ Item_ref *rf;
+ rf= new (thd->mem_root) Item_ref(thd, context,
+ (*from_field)->table->s->db,
+ Lex_cstring_strlen((*from_field)->
+ table->alias.c_ptr()),
+ field_name);
+ if (!rf)
+ return -1;
+ thd->change_item_tree(reference, rf);
+ /*
+ rf is Item_ref => never substitute other items (in this case)
+ during fix_fields() => we can use rf after fix_fields()
+ */
+ DBUG_ASSERT(!rf->fixed); // Assured by Item_ref()
+ if (rf->fix_fields(thd, reference) || rf->check_cols(1))
+ return -1;
+ return 0;
+ }
+ }
+ return 1;
+}
+
+
+/**
+ Resolve the name of a column reference.
+
+ The method resolves the column reference represented by 'this' as a column
+ present in one of: FROM clause, SELECT clause, GROUP BY clause of a query
+ Q, or in outer queries that contain Q.
+
+ The name resolution algorithm used is (where [T_j] is an optional table
+ name that qualifies the column name):
+
+ @code
+ resolve_column_reference([T_j].col_ref_i)
+ {
+ search for a column or derived column named col_ref_i
+ [in table T_j] in the FROM clause of Q;
+
+ if such a column is NOT found AND // Lookup in outer queries.
+ there are outer queries
+ {
+ for each outer query Q_k beginning from the inner-most one
+ {
+ search for a column or derived column named col_ref_i
+ [in table T_j] in the FROM clause of Q_k;
+
+ if such a column is not found
+ Search for a column or derived column named col_ref_i
+ [in table T_j] in the SELECT and GROUP clauses of Q_k.
+ }
+ }
+ }
+ @endcode
+
+ Notice that compared to Item_ref::fix_fields, here we first search the FROM
+ clause, and then we search the SELECT and GROUP BY clauses.
+
+ @param[in] thd current thread
+ @param[in,out] reference view column if this item was resolved to a
+ view column
+
+ @retval
+ TRUE if error
+ @retval
+ FALSE on success
+*/
+
+bool Item_field::fix_fields(THD *thd, Item **reference)
+{
+ DBUG_ASSERT(fixed == 0);
+ Field *from_field= (Field *)not_found_field;
+ bool outer_fixed= false;
+ SELECT_LEX *select= thd->lex->current_select;
+
+ if (select && select->in_tvc)
+ {
+ my_error(ER_FIELD_REFERENCE_IN_TVC, MYF(0), full_name());
+ return(1);
+ }
+
+ if (!field) // If field is not checked
+ {
+ TABLE_LIST *table_list;
+ /*
+ In case of view, find_field_in_tables() write pointer to view field
+ expression to 'reference', i.e. it substitute that expression instead
+ of this Item_field
+ */
+ DBUG_ASSERT(context);
+ if ((from_field= find_field_in_tables(thd, this,
+ context->first_name_resolution_table,
+ context->last_name_resolution_table,
+ reference,
+ thd->lex->use_only_table_context ?
+ REPORT_ALL_ERRORS :
+ IGNORE_EXCEPT_NON_UNIQUE,
+ !any_privileges,
+ TRUE)) ==
+ not_found_field)
+ {
+ int ret;
+
+ /* Look up in current select's item_list to find aliased fields */
+ if (select && select->is_item_list_lookup)
+ {
+ uint counter;
+ enum_resolution_type resolution;
+ Item** res= find_item_in_list(this,
+ select->item_list,
+ &counter, REPORT_EXCEPT_NOT_FOUND,
+ &resolution);
+ if (!res)
+ return 1;
+ if (resolution == RESOLVED_AGAINST_ALIAS)
+ alias_name_used= TRUE;
+ if (res != (Item **)not_found_item)
+ {
+ if ((*res)->type() == Item::FIELD_ITEM)
+ {
+ /*
+ It's an Item_field referencing another Item_field in the select
+ list.
+ Use the field from the Item_field in the select list and leave
+ the Item_field instance in place.
+ */
+
+ Field *new_field= (*((Item_field**)res))->field;
+
+ if (unlikely(new_field == NULL))
+ {
+ /* The column to which we link isn't valid. */
+ my_error(ER_BAD_FIELD_ERROR, MYF(0), (*res)->name.str,
+ thd->where);
+ return(1);
+ }
+
+ /*
+ We can not "move" aggregate function in the place where
+ its arguments are not defined.
+ */
+ set_max_sum_func_level(thd, select);
+ set_field(new_field);
+ depended_from= (*((Item_field**)res))->depended_from;
+ return 0;
+ }
+ else
+ {
+ /*
+ It's not an Item_field in the select list so we must make a new
+ Item_ref to point to the Item in the select list and replace the
+ Item_field created by the parser with the new Item_ref.
+ */
+ Item_ref *rf= new (thd->mem_root)
+ Item_ref(thd, context, db_name, table_name, field_name);
+ if (!rf)
+ return 1;
+ bool err= rf->fix_fields(thd, (Item **) &rf) || rf->check_cols(1);
+ if (err)
+ return TRUE;
+
+ thd->change_item_tree(reference,
+ select->context_analysis_place ==
+ IN_GROUP_BY &&
+ alias_name_used ? *rf->ref : rf);
+
+ /*
+ We can not "move" aggregate function in the place where
+ its arguments are not defined.
+ */
+ set_max_sum_func_level(thd, select);
+ return FALSE;
+ }
+ }
+ }
+
+ if (unlikely(!select))
+ {
+ my_error(ER_BAD_FIELD_ERROR, MYF(0), full_name(), thd->where);
+ goto error;
+ }
+ if ((ret= fix_outer_field(thd, &from_field, reference)) < 0)
+ goto error;
+ outer_fixed= TRUE;
+ if (!ret)
+ goto mark_non_agg_field;
+ }
+ else if (!from_field)
+ goto error;
+
+ table_list= (cached_table ? cached_table :
+ from_field != view_ref_found ?
+ from_field->table->pos_in_table_list : 0);
+ if (!outer_fixed && table_list && table_list->select_lex &&
+ context->select_lex &&
+ table_list->select_lex != context->select_lex &&
+ !context->select_lex->is_merged_child_of(table_list->select_lex) &&
+ is_outer_table(table_list, context->select_lex))
+ {
+ int ret;
+ if ((ret= fix_outer_field(thd, &from_field, reference)) < 0)
+ goto error;
+ outer_fixed= 1;
+ if (!ret)
+ goto mark_non_agg_field;
+ }
+
+ if (thd->lex->in_sum_func &&
+ thd->lex->in_sum_func->nest_level ==
+ select->nest_level)
+ set_if_bigger(thd->lex->in_sum_func->max_arg_level,
+ select->nest_level);
+ /*
+ if it is not expression from merged VIEW we will set this field.
+
+ We can leave expression substituted from view for next PS/SP rexecution
+ (i.e. do not register this substitution for reverting on cleanup()
+ (register_item_tree_changing())), because this subtree will be
+ fix_field'ed during setup_tables()->setup_underlying() (i.e. before
+ all other expressions of query, and references on tables which do
+ not present in query will not make problems.
+
+ Also we suppose that view can't be changed during PS/SP life.
+ */
+ if (from_field == view_ref_found)
+ return FALSE;
+
+ set_field(from_field);
+ }
+ else if (should_mark_column(thd->column_usage))
+ {
+ TABLE *table= field->table;
+ MY_BITMAP *current_bitmap, *other_bitmap;
+ if (thd->column_usage == MARK_COLUMNS_READ)
+ {
+ current_bitmap= table->read_set;
+ other_bitmap= table->write_set;
+ }
+ else
+ {
+ current_bitmap= table->write_set;
+ other_bitmap= table->read_set;
+ }
+ if (!bitmap_fast_test_and_set(current_bitmap, field->field_index))
+ {
+ if (!bitmap_is_set(other_bitmap, field->field_index))
+ {
+ /* First usage of column */
+ table->used_fields++; // Used to optimize loops
+ /* purecov: begin inspected */
+ table->covering_keys.intersect(field->part_of_key);
+ /* purecov: end */
+ }
+ }
+ }
+#ifndef NO_EMBEDDED_ACCESS_CHECKS
+ if (any_privileges)
+ {
+ const char *db, *tab;
+ db= field->table->s->db.str;
+ tab= field->table->s->table_name.str;
+ if (!(have_privileges= (get_column_grant(thd, &field->table->grant,
+ db, tab, field_name.str) &
+ VIEW_ANY_ACL)))
+ {
+ my_error(ER_COLUMNACCESS_DENIED_ERROR, MYF(0),
+ "ANY", thd->security_ctx->priv_user,
+ thd->security_ctx->host_or_ip, field_name.str, tab);
+ goto error;
+ }
+ }
+#endif
+ fixed= 1;
+ if (field->vcol_info)
+ fix_session_vcol_expr_for_read(thd, field, field->vcol_info);
+ if (thd->variables.sql_mode & MODE_ONLY_FULL_GROUP_BY &&
+ !outer_fixed && !thd->lex->in_sum_func &&
+ select &&
+ select->cur_pos_in_select_list != UNDEF_POS &&
+ select->join)
+ {
+ select->join->non_agg_fields.push_back(this, thd->mem_root);
+ marker= select->cur_pos_in_select_list;
+ }
+mark_non_agg_field:
+ /*
+ table->pos_in_table_list can be 0 when fixing partition functions
+ or virtual fields.
+ */
+ if (fixed && (thd->variables.sql_mode & MODE_ONLY_FULL_GROUP_BY) &&
+ field->table->pos_in_table_list)
+ {
+ /*
+ Mark selects according to presence of non aggregated fields.
+ Fields from outer selects added to the aggregate function
+ outer_fields list as it's unknown at the moment whether it's
+ aggregated or not.
+ We're using the select lex of the cached table (if present).
+ */
+ SELECT_LEX *select_lex;
+ if (cached_table)
+ select_lex= cached_table->select_lex;
+ else if (!(select_lex= field->table->pos_in_table_list->select_lex))
+ {
+ /*
+ This can only happen when there is no real table in the query.
+ We are using the field's resolution context. context->select_lex is eee
+ safe for use because it's either the SELECT we want to use
+ (the current level) or a stub added by non-SELECT queries.
+ */
+ select_lex= context->select_lex;
+ }
+ if (!thd->lex->in_sum_func)
+ select_lex->set_non_agg_field_used(true);
+ else
+ {
+ if (outer_fixed)
+ thd->lex->in_sum_func->outer_fields.push_back(this, thd->mem_root);
+ else if (thd->lex->in_sum_func->nest_level !=
+ select->nest_level)
+ select_lex->set_non_agg_field_used(true);
+ }
+ }
+ return FALSE;
+
+error:
+ context->process_error(thd);
+ return TRUE;
+}
+
+bool Item_field::post_fix_fields_part_expr_processor(void *int_arg)
+{
+ DBUG_ASSERT(fixed);
+ if (field->vcol_info)
+ field->vcol_info->mark_as_in_partitioning_expr();
+ /*
+ Update table_name to be real table name, not the alias. Because alias is
+ reallocated for every statement, and this item has a long life time */
+ table_name= field->table->s->table_name;
+ return FALSE;
+}
+
+bool Item_field::check_valid_arguments_processor(void *bool_arg)
+{
+ Virtual_column_info *vcol= field->vcol_info;
+ if (!vcol)
+ return FALSE;
+ return vcol->expr->walk(&Item::check_partition_func_processor, 0, NULL)
+ || vcol->expr->walk(&Item::check_valid_arguments_processor, 0, NULL);
+}
+
+void Item_field::cleanup()
+{
+ DBUG_ENTER("Item_field::cleanup");
+ Item_ident::cleanup();
+ depended_from= NULL;
+ /*
+ Even if this object was created by direct link to field in setup_wild()
+ it will be linked correctly next time by name of field and table alias.
+ I.e. we can drop 'field'.
+ */
+ field= 0;
+ item_equal= NULL;
+ null_value= FALSE;
+ DBUG_VOID_RETURN;
+}
+
+/**
+ Find a field among specified multiple equalities.
+
+ The function first searches the field among multiple equalities
+ of the current level (in the cond_equal->current_level list).
+ If it fails, it continues searching in upper levels accessed
+ through a pointer cond_equal->upper_levels.
+ The search terminates as soon as a multiple equality containing
+ the field is found.
+
+ @param cond_equal reference to list of multiple equalities where
+ the field (this object) is to be looked for
+
+ @return
+ - First Item_equal containing the field, if success
+ - 0, otherwise
+*/
+
+Item_equal *Item_field::find_item_equal(COND_EQUAL *cond_equal)
+{
+ Item_equal *item= 0;
+ while (cond_equal)
+ {
+ List_iterator_fast<Item_equal> li(cond_equal->current_level);
+ while ((item= li++))
+ {
+ if (item->contains(field))
+ return item;
+ }
+ /*
+ The field is not found in any of the multiple equalities
+ of the current level. Look for it in upper levels
+ */
+ cond_equal= cond_equal->upper_levels;
+ }
+ return 0;
+}
+
+
+/**
+ Set a pointer to the multiple equality the field reference belongs to
+ (if any).
+
+ The function looks for a multiple equality containing the field item
+ among those referenced by arg.
+ In the case such equality exists the function does the following.
+ If the found multiple equality contains a constant, then the field
+ reference is substituted for this constant, otherwise it sets a pointer
+ to the multiple equality in the field item.
+
+
+ @param arg reference to list of multiple equalities where
+ the field (this object) is to be looked for
+
+ @note
+ This function is supposed to be called as a callback parameter in calls
+ of the compile method.
+
+ @return
+ - pointer to the replacing constant item, if the field item was substituted
+ - pointer to the field item, otherwise.
+*/
+
+Item *Item_field::propagate_equal_fields(THD *thd,
+ const Context &ctx,
+ COND_EQUAL *arg)
+{
+ if (!(item_equal= find_item_equal(arg)))
+ return this;
+ if (!field->can_be_substituted_to_equal_item(ctx, item_equal))
+ {
+ item_equal= NULL;
+ return this;
+ }
+ Item *item= item_equal->get_const();
+ if (!item)
+ {
+ /*
+ The found Item_equal is Okey, but it does not have a constant
+ item yet. Keep this->item_equal point to the found Item_equal.
+ */
+ return this;
+ }
+ if (!(item= field->get_equal_const_item(thd, ctx, item)))
+ {
+ /*
+ Could not do safe conversion from the original constant item
+ to a field-compatible constant item.
+ For example, we tried to optimize:
+ WHERE date_column=' garbage ' AND LENGTH(date_column)=8;
+ to
+ WHERE date_column=' garbage ' AND LENGTH(DATE'XXXX-YY-ZZ');
+ but failed to create a valid DATE literal from the given string literal.
+
+ Do not do constant propagation in such cases and unlink
+ "this" from the found Item_equal (as this equality not useful).
+ */
+ item_equal= NULL;
+ return this;
+ }
+ return item;
+}
+
+
+/**
+ Replace an Item_field for an equal Item_field that evaluated earlier
+ (if any).
+
+ If this->item_equal points to some item and coincides with arg then
+ the function returns a pointer to an item that is taken from
+ the very beginning of the item_equal list which the Item_field
+ object refers to (belongs to) unless item_equal contains a constant
+ item. In this case the function returns this constant item,
+ (if the substitution does not require conversion).
+ If the Item_field object does not refer any Item_equal object
+ 'this' is returned .
+
+ @param arg NULL or points to so some item of the Item_equal type
+
+
+ @note
+ This function is supposed to be called as a callback parameter in calls
+ of the transformer method.
+
+ @return
+ - pointer to a replacement Item_field if there is a better equal item or
+ a pointer to a constant equal item;
+ - this - otherwise.
+*/
+
+Item *Item_field::replace_equal_field(THD *thd, uchar *arg)
+{
+ REPLACE_EQUAL_FIELD_ARG* param= (REPLACE_EQUAL_FIELD_ARG*)arg;
+ if (item_equal && item_equal == param->item_equal)
+ {
+ Item *const_item2= item_equal->get_const();
+ if (const_item2)
+ {
+ /*
+ Currently we don't allow to create Item_equal with compare_type()
+ different from its Item_field's cmp_type().
+ Field_xxx::test_if_equality_guarantees_uniqueness() prevent this.
+ Also, Item_field::propagate_equal_fields() does not allow to assign
+ this->item_equal to any instances of Item_equal if "this" is used
+ in a non-native comparison context, or with an incompatible collation.
+ So the fact that we have (item_equal != NULL) means that the currently
+ processed function (the owner of "this") uses the field in its native
+ comparison context, and it's safe to replace it to the constant from
+ item_equal.
+ */
+ DBUG_ASSERT(type_handler_for_comparison()->cmp_type() ==
+ item_equal->compare_type_handler()->cmp_type());
+ return const_item2;
+ }
+ Item_ident *subst=
+ (Item_ident *) (item_equal->get_first(param->context_tab, this));
+ if (subst)
+ {
+ Item_field *subst2= (Item_field *) (subst->real_item());
+ if (subst2 && !field->eq(subst2->field))
+ return subst2;
+ }
+ }
+ return this;
+}
+
+
+void Item::init_make_send_field(Send_field *tmp_field,
+ const Type_handler *h)
+{
+ tmp_field->db_name= empty_clex_str;
+ tmp_field->org_table_name= empty_clex_str;
+ tmp_field->org_col_name= empty_clex_str;
+ tmp_field->table_name= empty_clex_str;
+ tmp_field->col_name= name;
+ tmp_field->flags= (maybe_null ? 0 : NOT_NULL_FLAG) |
+ (my_binary_compare(charset_for_protocol()) ?
+ BINARY_FLAG : 0);
+ tmp_field->set_handler(h);
+ tmp_field->length=max_length;
+ tmp_field->decimals=decimals;
+ if (unsigned_flag)
+ tmp_field->flags |= UNSIGNED_FLAG;
+ static_cast<Send_field_extended_metadata>(*tmp_field)=
+ Send_field_extended_metadata();
+ h->Item_append_extended_type_info(tmp_field, this);
+}
+
+void Item::make_send_field(THD *thd, Send_field *tmp_field)
+{
+ init_make_send_field(tmp_field, type_handler());
+}
+
+
+void Item_empty_string::make_send_field(THD *thd, Send_field *tmp_field)
+{
+ init_make_send_field(tmp_field, string_type_handler());
+}
+
+
+/**
+ Verifies that the input string is well-formed according to its character set.
+ @param send_error If true, call my_error if string is not well-formed.
+
+ Will truncate input string if it is not well-formed.
+
+ @return
+ If well-formed: input string.
+ If not well-formed:
+ if strict mode: NULL pointer and we set this Item's value to NULL
+ if not strict mode: input string truncated up to last good character
+ */
+String *Item::check_well_formed_result(String *str, bool send_error)
+{
+ /* Check whether we got a well-formed string */
+ CHARSET_INFO *cs= str->charset();
+ uint wlen= str->well_formed_length();
+ null_value= false;
+ if (unlikely(wlen < str->length()))
+ {
+ THD *thd= current_thd;
+ char hexbuf[7];
+ uint diff= str->length() - wlen;
+ set_if_smaller(diff, 3);
+ octet2hex(hexbuf, str->ptr() + wlen, diff);
+ if (send_error)
+ {
+ my_error(ER_INVALID_CHARACTER_STRING, MYF(0),
+ cs->csname, hexbuf);
+ return 0;
+ }
+ if (thd->is_strict_mode())
+ {
+ null_value= 1;
+ str= 0;
+ }
+ else
+ {
+ str->length(wlen);
+ }
+ push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+ ER_INVALID_CHARACTER_STRING,
+ ER_THD(thd, ER_INVALID_CHARACTER_STRING), cs->csname,
+ hexbuf);
+ }
+ return str;
+}
+
+
+/**
+ Copy a string with optional character set conversion.
+*/
+bool
+String_copier_for_item::copy_with_warn(CHARSET_INFO *dstcs, String *dst,
+ CHARSET_INFO *srccs, const char *src,
+ uint32 src_length, uint32 nchars)
+{
+ if (unlikely((dst->copy(dstcs, srccs, src, src_length, nchars, this))))
+ return true; // EOM
+ const char *pos;
+ if (unlikely(pos= well_formed_error_pos()))
+ {
+ ErrConvString err(pos, src_length - (pos - src), &my_charset_bin);
+ push_warning_printf(m_thd, Sql_condition::WARN_LEVEL_WARN,
+ ER_INVALID_CHARACTER_STRING,
+ ER_THD(m_thd, ER_INVALID_CHARACTER_STRING),
+ srccs == &my_charset_bin ?
+ dstcs->csname : srccs->csname,
+ err.ptr());
+ return false;
+ }
+ if (unlikely(pos= cannot_convert_error_pos()))
+ {
+ char buf[16];
+ int mblen= srccs->charlen(pos, src + src_length);
+ DBUG_ASSERT(mblen > 0 && mblen * 2 + 1 <= (int) sizeof(buf));
+ octet2hex(buf, pos, mblen);
+ push_warning_printf(m_thd, Sql_condition::WARN_LEVEL_WARN,
+ ER_CANNOT_CONVERT_CHARACTER,
+ ER_THD(m_thd, ER_CANNOT_CONVERT_CHARACTER),
+ srccs->csname, buf, dstcs->csname);
+ return false;
+ }
+ return false;
+}
+
+
+/*
+ Compare two items using a given collation
+
+ SYNOPSIS
+ eq_by_collation()
+ item item to compare with
+ binary_cmp TRUE <-> compare as binaries
+ cs collation to use when comparing strings
+
+ DESCRIPTION
+ This method works exactly as Item::eq if the collation cs coincides with
+ the collation of the compared objects. Otherwise, first the collations that
+ differ from cs are replaced for cs and then the items are compared by
+ Item::eq. After the comparison the original collations of items are
+ restored.
+
+ RETURN
+ 1 compared items has been detected as equal
+ 0 otherwise
+*/
+
+bool Item::eq_by_collation(Item *item, bool binary_cmp, CHARSET_INFO *cs)
+{
+ CHARSET_INFO *save_cs= 0;
+ CHARSET_INFO *save_item_cs= 0;
+ if (collation.collation != cs)
+ {
+ save_cs= collation.collation;
+ collation.collation= cs;
+ }
+ if (item->collation.collation != cs)
+ {
+ save_item_cs= item->collation.collation;
+ item->collation.collation= cs;
+ }
+ bool res= eq(item, binary_cmp);
+ if (save_cs)
+ collation.collation= save_cs;
+ if (save_item_cs)
+ item->collation.collation= save_item_cs;
+ return res;
+}
+
+
+/* ARGSUSED */
+void Item_field::make_send_field(THD *thd, Send_field *tmp_field)
+{
+ field->make_send_field(tmp_field);
+ DBUG_ASSERT(tmp_field->table_name.str != 0);
+ if (name.str)
+ {
+ DBUG_ASSERT(name.length == strlen(name.str));
+ tmp_field->col_name= name; // Use user supplied name
+ }
+ if (table_name.str)
+ tmp_field->table_name= table_name;
+ if (db_name.str)
+ tmp_field->db_name= db_name;
+}
+
+
+/**
+ Save a field value in another field
+
+ @param from Field to take the value from
+ @param [out] null_value Pointer to the null_value flag to set
+ @param to Field to save the value in
+ @param no_conversions How to deal with NULL value
+
+ @details
+ The function takes the value of the field 'from' and, if this value
+ is not null, it saves in the field 'to' setting off the flag referenced
+ by 'null_value'. Otherwise this flag is set on and field 'to' is
+ also set to null possibly with conversion.
+
+ @note
+ This function is used by the functions Item_field::save_in_field,
+ Item_field::save_org_in_field and Item_ref::save_in_field
+
+ @retval FALSE OK
+ @retval TRUE Error
+
+*/
+
+static int save_field_in_field(Field *from, bool *null_value,
+ Field *to, bool no_conversions)
+{
+ int res;
+ DBUG_ENTER("save_field_in_field");
+ if (from->is_null())
+ {
+ (*null_value)= 1;
+ DBUG_RETURN(set_field_to_null_with_conversions(to, no_conversions));
+ }
+ to->set_notnull();
+
+ /*
+ If we're setting the same field as the one we're reading from there's
+ nothing to do. This can happen in 'SET x = x' type of scenarios.
+ */
+ if (to == from)
+ {
+ (*null_value)= 0;
+ DBUG_RETURN(0);
+ }
+
+ res= field_conv(to, from);
+ (*null_value)= 0;
+ DBUG_RETURN(res);
+}
+
+
+fast_field_copier Item_field::setup_fast_field_copier(Field *to)
+{
+ return to->get_fast_field_copier(field);
+}
+
+void Item_field::save_in_result_field(bool no_conversions)
+{
+ bool unused;
+ save_field_in_field(field, &unused, result_field, no_conversions);
+}
+
+/**
+ Set a field's value from a item.
+*/
+
+void Item_field::save_org_in_field(Field *to,
+ fast_field_copier fast_field_copier_func)
+{
+ DBUG_ENTER("Item_field::save_org_in_field");
+ DBUG_PRINT("enter", ("setup: %p data: %p",
+ to, fast_field_copier_func));
+ if (fast_field_copier_func)
+ {
+ if (field->is_null())
+ {
+ null_value= TRUE;
+ set_field_to_null_with_conversions(to, TRUE);
+ DBUG_VOID_RETURN;
+ }
+ to->set_notnull();
+ if (to == field)
+ {
+ null_value= 0;
+ DBUG_VOID_RETURN;
+ }
+ (*fast_field_copier_func)(to, field);
+ }
+ else
+ save_field_in_field(field, &null_value, to, TRUE);
+ DBUG_VOID_RETURN;
+}
+
+
+int Item_field::save_in_field(Field *to, bool no_conversions)
+{
+ return save_field_in_field(result_field, &null_value, to, no_conversions);
+}
+
+
+/**
+ Store null in field.
+
+ This is used on INSERT.
+ Allow NULL to be inserted in timestamp and auto_increment values.
+
+ @param field Field where we want to store NULL
+
+ @retval
+ 0 ok
+ @retval
+ 1 Field doesn't support NULL values and can't handle 'field = NULL'
+*/
+
+int Item_null::save_in_field(Field *field, bool no_conversions)
+{
+ return set_field_to_null_with_conversions(field, no_conversions);
+}
+
+
+/**
+ Store null in field.
+
+ @param field Field where we want to store NULL
+
+ @retval
+ 0 OK
+ @retval
+ 1 Field doesn't support NULL values
+*/
+
+int Item_null::save_safe_in_field(Field *field)
+{
+ return set_field_to_null(field);
+}
+
+
+/*
+ This implementation can lose str_value content, so if the
+ Item uses str_value to store something, it should
+ reimplement it's ::save_in_field() as Item_string, for example, does.
+
+ Note: all Item_XXX::val_str(str) methods must NOT assume that
+ str != str_value. For example, see fix for bug #44743.
+*/
+int Item::save_str_in_field(Field *field, bool no_conversions)
+{
+ String *result;
+ CHARSET_INFO *cs= collation.collation;
+ char buff[MAX_FIELD_WIDTH]; // Alloc buffer for small columns
+ str_value.set_quick(buff, sizeof(buff), cs);
+ result=val_str(&str_value);
+ if (null_value)
+ {
+ str_value.set_quick(0, 0, cs);
+ return set_field_to_null_with_conversions(field, no_conversions);
+ }
+
+ /* NOTE: If null_value == FALSE, "result" must be not NULL. */
+
+ field->set_notnull();
+ int error= field->store(result->ptr(),result->length(),cs);
+ str_value.set_quick(0, 0, cs);
+ return error;
+}
+
+
+int Item::save_real_in_field(Field *field, bool no_conversions)
+{
+ double nr= val_real();
+ if (null_value)
+ return set_field_to_null_with_conversions(field, no_conversions);
+ field->set_notnull();
+ return field->store(nr);
+}
+
+
+int Item::save_decimal_in_field(Field *field, bool no_conversions)
+{
+ VDec value(this);
+ if (value.is_null())
+ return set_field_to_null_with_conversions(field, no_conversions);
+ field->set_notnull();
+ return field->store_decimal(value.ptr());
+}
+
+
+int Item::save_int_in_field(Field *field, bool no_conversions)
+{
+ longlong nr= val_int();
+ if (null_value)
+ return set_field_to_null_with_conversions(field, no_conversions);
+ field->set_notnull();
+ return field->store(nr, unsigned_flag);
+}
+
+
+int Item::save_in_field(Field *field, bool no_conversions)
+{
+ int error= type_handler()->Item_save_in_field(this, field, no_conversions);
+ return error ? error : (field->table->in_use->is_error() ? 1 : 0);
+}
+
+
+bool Item::save_in_param(THD *thd, Item_param *param)
+{
+ return param->set_from_item(thd, this);
+}
+
+
+int Item_string::save_in_field(Field *field, bool no_conversions)
+{
+ String *result;
+ result=val_str(&str_value);
+ return save_str_value_in_field(field, result);
+}
+
+
+Item *Item_string::clone_item(THD *thd)
+{
+ LEX_CSTRING val;
+ str_value.get_value(&val);
+ return new (thd->mem_root) Item_string(thd, name, val, collation.collation);
+}
+
+
+Item_basic_constant *
+Item_string::make_string_literal_concat(THD *thd, const LEX_CSTRING *str)
+{
+ append(str->str, (uint32) str->length);
+ if (!(collation.repertoire & MY_REPERTOIRE_EXTENDED))
+ {
+ // If the string has been pure ASCII so far, check the new part.
+ CHARSET_INFO *cs= thd->variables.collation_connection;
+ collation.repertoire|= my_string_repertoire(cs, str->str, str->length);
+ }
+ return this;
+}
+
+
+/*
+ If "this" is a reasonably short pure ASCII string literal,
+ try to parse known ODBC-style date, time or timestamp literals,
+ e.g:
+ SELECT {d'2001-01-01'};
+ SELECT {t'10:20:30'};
+ SELECT {ts'2001-01-01 10:20:30'};
+*/
+Item *Item_string::make_odbc_literal(THD *thd, const LEX_CSTRING *typestr)
+{
+ Item_literal *res;
+ const Type_handler *h;
+ if (collation.repertoire == MY_REPERTOIRE_ASCII &&
+ str_value.length() < MAX_DATE_STRING_REP_LENGTH * 4 &&
+ (h= Type_handler::odbc_literal_type_handler(typestr)) &&
+ (res= h->create_literal_item(thd, val_str(NULL), false)))
+ return res;
+ /*
+ h->create_literal_item() returns NULL if failed to parse the string,
+ or the string format did not match the type, e.g.: {d'2001-01-01 10:10:10'}
+ */
+ return this;
+}
+
+
+static int save_int_value_in_field (Field *field, longlong nr,
+ bool null_value, bool unsigned_flag)
+{
+ if (null_value)
+ return set_field_to_null(field);
+ field->set_notnull();
+ return field->store(nr, unsigned_flag);
+}
+
+
+int Item_int::save_in_field(Field *field, bool no_conversions)
+{
+ return save_int_value_in_field (field, val_int(), null_value, unsigned_flag);
+}
+
+
+Item *Item_int::clone_item(THD *thd)
+{
+ return new (thd->mem_root) Item_int(thd, name.str, value, max_length, unsigned_flag);
+}
+
+
+void Item_datetime::set(longlong packed, enum_mysql_timestamp_type ts_type)
+{
+ unpack_time(packed, &ltime, ts_type);
+}
+
+int Item_datetime::save_in_field(Field *field, bool no_conversions)
+{
+ field->set_notnull();
+ return field->store_time_dec(&ltime, decimals);
+}
+
+longlong Item_datetime::val_int()
+{
+ return TIME_to_ulonglong(&ltime);
+}
+
+int Item_decimal::save_in_field(Field *field, bool no_conversions)
+{
+ field->set_notnull();
+ return field->store_decimal(&decimal_value);
+}
+
+
+Item *Item_int_with_ref::clone_item(THD *thd)
+{
+ DBUG_ASSERT(ref->const_item());
+ /*
+ We need to evaluate the constant to make sure it works with
+ parameter markers.
+ */
+ return (ref->unsigned_flag ?
+ new (thd->mem_root)
+ Item_uint(thd, ref->name.str, ref->val_int(), ref->max_length) :
+ new (thd->mem_root)
+ Item_int(thd, ref->name.str, ref->val_int(), ref->max_length));
+}
+
+
+Item *Item::neg(THD *thd)
+{
+ return new (thd->mem_root) Item_func_neg(thd, this);
+}
+
+Item *Item_int::neg(THD *thd)
+{
+ /*
+ The following if should never be true with code generated by
+ our parser as LONGLONG_MIN values will be stored as decimal.
+ The code is here in case someone generates an int from inside
+ MariaDB
+ */
+ if (unlikely(value == LONGLONG_MIN))
+ {
+ /* Precision for int not big enough; Convert constant to decimal */
+ Item_decimal *item= new (thd->mem_root) Item_decimal(thd, value, 0);
+ return item ? item->neg(thd) : item;
+ }
+ if (value > 0)
+ max_length++;
+ else if (value < 0 && max_length)
+ max_length--;
+ value= -value;
+ name= null_clex_str;
+ return this;
+}
+
+Item *Item_decimal::neg(THD *thd)
+{
+ my_decimal_neg(&decimal_value);
+ unsigned_flag= 0;
+ name= null_clex_str;
+ max_length= my_decimal_precision_to_length_no_truncation(
+ decimal_value.intg + decimals, decimals, unsigned_flag);
+ return this;
+}
+
+Item *Item_float::neg(THD *thd)
+{
+ if (value > 0)
+ max_length++;
+ else if (value < 0 && max_length)
+ max_length--;
+ value= -value;
+ presentation= 0;
+ name= null_clex_str;
+ return this;
+}
+
+Item *Item_uint::neg(THD *thd)
+{
+ Item_decimal *item;
+ if (((ulonglong)value) <= LONGLONG_MAX)
+ return new (thd->mem_root) Item_int(thd, -value, max_length+1);
+ if (value == LONGLONG_MIN)
+ return new (thd->mem_root) Item_int(thd, value, max_length+1);
+ if (!(item= new (thd->mem_root) Item_decimal(thd, value, 1)))
+ return 0;
+ return item->neg(thd);
+}
+
+
+Item *Item_uint::clone_item(THD *thd)
+{
+ return new (thd->mem_root) Item_uint(thd, name.str, value, max_length);
+}
+
+static uint nr_of_decimals(const char *str, const char *end)
+{
+ const char *decimal_point;
+
+ /* Find position for '.' */
+ for (;;)
+ {
+ if (str == end)
+ return 0;
+ if (*str == 'e' || *str == 'E')
+ return NOT_FIXED_DEC;
+ if (*str++ == '.')
+ break;
+ }
+ decimal_point= str;
+ for ( ; str < end && my_isdigit(system_charset_info, *str) ; str++)
+ ;
+ if (str < end && (*str == 'e' || *str == 'E'))
+ return NOT_FIXED_DEC;
+ /*
+ QQ:
+ The number of decimal digist in fact should be (str - decimal_point - 1).
+ But it seems the result of nr_of_decimals() is never used!
+
+ In case of 'e' and 'E' nr_of_decimals returns NOT_FIXED_DEC.
+ In case if there is no 'e' or 'E' parser code in sql_yacc.yy
+ never calls Item_float::Item_float() - it creates Item_decimal instead.
+
+ The only piece of code where we call Item_float::Item_float(str, len)
+ without having 'e' or 'E' is item_xmlfunc.cc, but this Item_float
+ never appears in metadata itself. Changing the code to return
+ (str - decimal_point - 1) does not make any changes in the test results.
+
+ This should be addressed somehow.
+ Looks like a reminder from before real DECIMAL times.
+ */
+ return (uint) (str - decimal_point);
+}
+
+
+/**
+ This function is only called during parsing:
+ - when parsing SQL query from sql_yacc.yy
+ - when parsing XPath query from item_xmlfunc.cc
+ We will signal an error if value is not a true double value (overflow):
+ eng: Illegal %s '%-.192s' value found during parsing
+
+ Note: the string is NOT null terminated when called from item_xmlfunc.cc,
+ so this->name will contain some SQL query tail behind the "length" bytes.
+ This is Ok for now, as this Item is never seen in SHOW,
+ or EXPLAIN, or anywhere else in metadata.
+ Item->name should be fixed to use LEX_STRING eventually.
+*/
+
+Item_float::Item_float(THD *thd, const char *str_arg, size_t length):
+ Item_num(thd)
+{
+ int error;
+ char *end_not_used;
+ value= my_charset_bin.strntod((char*) str_arg, length, &end_not_used, &error);
+ if (unlikely(error))
+ {
+ char tmp[NAME_LEN + 2];
+ my_snprintf(tmp, sizeof(tmp), "%.*s", static_cast<int>(length), str_arg);
+ my_error(ER_ILLEGAL_VALUE_FOR_TYPE, MYF(0), "double", tmp);
+ }
+ presentation= name.str= str_arg;
+ name.length= strlen(str_arg);
+ decimals=(uint8) nr_of_decimals(str_arg, str_arg+length);
+ max_length=(uint32)length;
+}
+
+
+int Item_float::save_in_field(Field *field, bool no_conversions)
+{
+ double nr= val_real();
+ if (null_value)
+ return set_field_to_null(field);
+ field->set_notnull();
+ return field->store(nr);
+}
+
+
+void Item_float::print(String *str, enum_query_type query_type)
+{
+ if (presentation)
+ {
+ str->append(presentation);
+ return;
+ }
+ char buffer[20];
+ String num(buffer, sizeof(buffer), &my_charset_bin);
+ num.set_real(value, decimals, &my_charset_bin);
+ str->append(num);
+}
+
+
+inline uint char_val(char X)
+{
+ return (uint) (X >= '0' && X <= '9' ? X-'0' :
+ X >= 'A' && X <= 'Z' ? X-'A'+10 :
+ X-'a'+10);
+}
+
+
+void Item_hex_constant::hex_string_init(THD *thd, const char *str, size_t str_length)
+{
+ max_length=(uint)((str_length+1)/2);
+ char *ptr=(char*) thd->alloc(max_length+1);
+ if (!ptr)
+ {
+ str_value.set("", 0, &my_charset_bin);
+ return;
+ }
+ str_value.set(ptr,max_length,&my_charset_bin);
+ char *end=ptr+max_length;
+ if (max_length*2 != str_length)
+ *ptr++=char_val(*str++); // Not even, assume 0 prefix
+ while (ptr != end)
+ {
+ *ptr++= (char) (char_val(str[0])*16+char_val(str[1]));
+ str+=2;
+ }
+ *ptr=0; // Keep purify happy
+ collation.set(&my_charset_bin, DERIVATION_COERCIBLE);
+ unsigned_flag= 1;
+}
+
+
+void Item_hex_hybrid::print(String *str, enum_query_type query_type)
+{
+ uint32 len= MY_MIN(str_value.length(), sizeof(longlong));
+ const char *ptr= str_value.ptr() + str_value.length() - len;
+ str->append("0x");
+ str->append_hex(ptr, len);
+}
+
+
+uint Item_hex_hybrid::decimal_precision() const
+{
+ switch (max_length) {// HEX DEC
+ case 0: // ---- ---
+ case 1: return 3; // 0xFF 255
+ case 2: return 5; // 0xFFFF 65535
+ case 3: return 8; // 0xFFFFFF 16777215
+ case 4: return 10; // 0xFFFFFFFF 4294967295
+ case 5: return 13; // 0xFFFFFFFFFF 1099511627775
+ case 6: return 15; // 0xFFFFFFFFFFFF 281474976710655
+ case 7: return 17; // 0xFFFFFFFFFFFFFF 72057594037927935
+ }
+ return 20; // 0xFFFFFFFFFFFFFFFF 18446744073709551615
+}
+
+
+void Item_hex_string::print(String *str, enum_query_type query_type)
+{
+ str->append("X'");
+ str->append_hex(str_value.ptr(), str_value.length());
+ str->append("'");
+}
+
+
+/*
+ bin item.
+ In string context this is a binary string.
+ In number context this is a longlong value.
+*/
+
+Item_bin_string::Item_bin_string(THD *thd, const char *str, size_t str_length):
+ Item_hex_hybrid(thd)
+{
+ const char *end= str + str_length - 1;
+ char *ptr;
+ uchar bits= 0;
+ uint power= 1;
+
+ max_length= (uint)((str_length + 7) >> 3);
+ if (!(ptr= (char*) thd->alloc(max_length + 1)))
+ return;
+ str_value.set(ptr, max_length, &my_charset_bin);
+
+ if (max_length > 0)
+ {
+ ptr+= max_length - 1;
+ ptr[1]= 0; // Set end null for string
+ for (; end >= str; end--)
+ {
+ if (power == 256)
+ {
+ power= 1;
+ *ptr--= bits;
+ bits= 0;
+ }
+ if (*end == '1')
+ bits|= power;
+ power<<= 1;
+ }
+ *ptr= (char) bits;
+ }
+ else
+ ptr[0]= 0;
+
+ collation.set(&my_charset_bin, DERIVATION_COERCIBLE);
+}
+
+
+void Item_date_literal::print(String *str, enum_query_type query_type)
+{
+ str->append("DATE'");
+ char buf[MAX_DATE_STRING_REP_LENGTH];
+ my_date_to_str(cached_time.get_mysql_time(), buf);
+ str->append(buf);
+ str->append('\'');
+}
+
+
+Item *Item_date_literal::clone_item(THD *thd)
+{
+ return new (thd->mem_root) Item_date_literal(thd, &cached_time);
+}
+
+
+bool Item_date_literal::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+{
+ fuzzydate |= sql_mode_for_dates(thd);
+ cached_time.copy_to_mysql_time(ltime);
+ return (null_value= check_date_with_warn(thd, ltime, fuzzydate,
+ MYSQL_TIMESTAMP_ERROR));
+}
+
+
+void Item_datetime_literal::print(String *str, enum_query_type query_type)
+{
+ str->append("TIMESTAMP'");
+ char buf[MAX_DATE_STRING_REP_LENGTH];
+ my_datetime_to_str(cached_time.get_mysql_time(), buf, decimals);
+ str->append(buf);
+ str->append('\'');
+}
+
+
+Item *Item_datetime_literal::clone_item(THD *thd)
+{
+ return new (thd->mem_root) Item_datetime_literal(thd, &cached_time, decimals);
+}
+
+
+bool Item_datetime_literal::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+{
+ fuzzydate |= sql_mode_for_dates(thd);
+ cached_time.copy_to_mysql_time(ltime);
+ return (null_value= check_date_with_warn(thd, ltime, fuzzydate,
+ MYSQL_TIMESTAMP_ERROR));
+}
+
+
+void Item_time_literal::print(String *str, enum_query_type query_type)
+{
+ str->append("TIME'");
+ char buf[MAX_DATE_STRING_REP_LENGTH];
+ my_time_to_str(cached_time.get_mysql_time(), buf, decimals);
+ str->append(buf);
+ str->append('\'');
+}
+
+
+Item *Item_time_literal::clone_item(THD *thd)
+{
+ return new (thd->mem_root) Item_time_literal(thd, &cached_time, decimals);
+}
+
+
+bool Item_time_literal::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+{
+ cached_time.copy_to_mysql_time(ltime);
+ if (fuzzydate & TIME_TIME_ONLY)
+ return (null_value= false);
+ return (null_value= check_date_with_warn(thd, ltime, fuzzydate,
+ MYSQL_TIMESTAMP_ERROR));
+}
+
+
+
+/**
+ Pack data in buffer for sending.
+*/
+
+bool Item_null::send(Protocol *protocol, st_value *buffer)
+{
+ return protocol->store_null();
+}
+
+
+/**
+ Check if an item is a constant one and can be cached.
+
+ @param arg [out] TRUE <=> Cache this item.
+
+ @return TRUE Go deeper in item tree.
+ @return FALSE Don't go deeper in item tree.
+*/
+
+bool Item::cache_const_expr_analyzer(uchar **arg)
+{
+ bool *cache_flag= (bool*)*arg;
+ if (!*cache_flag)
+ {
+ Item *item= real_item();
+ /*
+ Cache constant items unless it's a basic constant, constant field or
+ a subselect (they use their own cache).
+ */
+ if (const_item() &&
+ !(basic_const_item() || item->basic_const_item() ||
+ item->type() == Item::NULL_ITEM || /* Item_name_const hack */
+ item->type() == Item::FIELD_ITEM ||
+ item->type() == SUBSELECT_ITEM ||
+ item->type() == CACHE_ITEM ||
+ /*
+ Do not cache GET_USER_VAR() function as its const_item() may
+ return TRUE for the current thread but it still may change
+ during the execution.
+ */
+ (item->type() == Item::FUNC_ITEM &&
+ ((Item_func*)item)->functype() == Item_func::GUSERVAR_FUNC)))
+ *cache_flag= TRUE;
+ return TRUE;
+ }
+ return FALSE;
+}
+
+
+/**
+ Cache item if needed.
+
+ @param arg TRUE <=> Cache this item.
+
+ @return cache if cache needed.
+ @return this otherwise.
+*/
+
+Item* Item::cache_const_expr_transformer(THD *thd, uchar *arg)
+{
+ if (*(bool*)arg)
+ {
+ *((bool*)arg)= FALSE;
+ Item_cache *cache= get_cache(thd);
+ if (!cache)
+ return NULL;
+ cache->setup(thd, this);
+ cache->store(this);
+ return cache;
+ }
+ return this;
+}
+
+/**
+ Find Item by reference in the expression
+*/
+bool Item::find_item_processor(void *arg)
+{
+ return (this == ((Item *) arg));
+}
+
+bool Item_field::send(Protocol *protocol, st_value *buffer)
+{
+ return protocol->store(result_field);
+}
+
+
+Item* Item::propagate_equal_fields_and_change_item_tree(THD *thd,
+ const Context &ctx,
+ COND_EQUAL *cond,
+ Item **place)
+{
+ Item *item= propagate_equal_fields(thd, ctx, cond);
+ if (item && item != this)
+ thd->change_item_tree(place, item);
+ return item;
+}
+
+
+void Item_field::update_null_value()
+{
+ /*
+ need to set no_errors to prevent warnings about type conversion
+ popping up.
+ */
+ THD *thd= field->table->in_use;
+ int no_errors;
+
+ no_errors= thd->no_errors;
+ thd->no_errors= 1;
+ type_handler()->Item_update_null_value(this);
+ thd->no_errors= no_errors;
+}
+
+
+/*
+ Add the field to the select list and substitute it for the reference to
+ the field.
+
+ SYNOPSIS
+ Item_field::update_value_transformer()
+ select_arg current select
+
+ DESCRIPTION
+ If the field doesn't belong to the table being inserted into then it is
+ added to the select list, pointer to it is stored in the ref_pointer_array
+ of the select and the field itself is substituted for the Item_ref object.
+ This is done in order to get correct values from update fields that
+ belongs to the SELECT part in the INSERT .. SELECT .. ON DUPLICATE KEY
+ UPDATE statement.
+
+ RETURN
+ 0 if error occurred
+ ref if all conditions are met
+ this field otherwise
+*/
+
+Item *Item_field::update_value_transformer(THD *thd, uchar *select_arg)
+{
+ SELECT_LEX *select= (SELECT_LEX*)select_arg;
+ DBUG_ASSERT(fixed);
+
+ if (field->table != select->context.table_list->table &&
+ type() != Item::TRIGGER_FIELD_ITEM)
+ {
+ List<Item> *all_fields= &select->join->all_fields;
+ Ref_ptr_array &ref_pointer_array= select->ref_pointer_array;
+ int el= all_fields->elements;
+ Item_ref *ref;
+
+ ref_pointer_array[el]= (Item*)this;
+ all_fields->push_front((Item*)this, thd->mem_root);
+ ref= new (thd->mem_root)
+ Item_ref(thd, &select->context, &ref_pointer_array[el],
+ table_name, field_name);
+ return ref;
+ }
+ return this;
+}
+
+
+/**
+ @brief
+ Prepare AND/OR formula for extraction of a pushable condition
+
+ @param checker the checker callback function to be applied to the nodes
+ of the tree of the object
+ @param arg parameter to be passed to the checker
+
+ @details
+ This method recursively traverses this AND/OR condition and for each
+ subformula of the condition it checks whether it can be usable for the
+ extraction of a pushable condition. The criteria of pushability of
+ a subformula is checked by the callback function 'checker' with one
+ parameter arg. The subformulas that are not usable are marked with
+ the flag NO_EXTRACTION_FL.
+ @note
+ This method is called before any call of build_pushable_cond.
+ The flag NO_EXTRACTION_FL set in a subformula allows to avoid building
+ clones for the subformulas that are not used in the pushable condition.
+ @note
+ This method is called for pushdown conditions into materialized
+ derived tables/views optimization.
+ Item::pushable_cond_checker_for_derived() is passed as the actual callback
+ function.
+ Also it is called for pushdown conditions in materialized IN subqueries.
+ Item::pushable_cond_checker_for_subquery is passed as the actual
+ callback function.
+*/
+
+void Item::check_pushable_cond(Pushdown_checker checker, uchar *arg)
+{
+ clear_extraction_flag();
+ if (type() == Item::COND_ITEM)
+ {
+ bool and_cond= ((Item_cond*) this)->functype() == Item_func::COND_AND_FUNC;
+ List_iterator<Item> li(*((Item_cond*) this)->argument_list());
+ uint count= 0;
+ Item *item;
+ while ((item=li++))
+ {
+ item->check_pushable_cond(checker, arg);
+ if (item->get_extraction_flag() != NO_EXTRACTION_FL)
+ count++;
+ else if (!and_cond)
+ break;
+ }
+ if ((and_cond && count == 0) || item)
+ {
+ set_extraction_flag(NO_EXTRACTION_FL);
+ if (and_cond)
+ li.rewind();
+ while ((item= li++))
+ item->clear_extraction_flag();
+ }
+ }
+ else if (!((this->*checker) (arg)))
+ set_extraction_flag(NO_EXTRACTION_FL);
+}
+
+
+/**
+ @brief
+ Build condition extractable from this condition for pushdown
+
+ @param thd the thread handle
+ @param checker the checker callback function to be applied to the nodes
+ of the tree of the object to check if multiple equality
+ elements can be used to create equalities
+ @param arg parameter to be passed to the checker
+
+ @details
+ This method finds out what condition that can be pushed down can be
+ extracted from this condition. If such condition C exists the
+ method builds the item for it. The method uses the flag NO_EXTRACTION_FL
+ set by the preliminary call of the method check_pushable_cond() to figure
+ out whether a subformula is pushable or not.
+ In the case when this item is a multiple equality a checker method is
+ called to find the equal fields to build a new equality that can be
+ pushed down.
+ @note
+ The built condition C is always implied by the condition cond
+ (cond => C). The method tries to build the most restrictive such
+ condition (i.e. for any other condition C' such that cond => C'
+ we have C => C').
+ @note
+ The build item is not ready for usage: substitution for the field items
+ has to be done and it has to be re-fixed.
+ @note
+ This method is called for pushdown conditions into materialized
+ derived tables/views optimization.
+ Item::pushable_equality_checker_for_derived() is passed as the actual
+ callback function.
+ Also it is called for pushdown conditions into materialized IN subqueries.
+ Item::pushable_equality_checker_for_subquery() is passed as the actual
+ callback function.
+
+ @retval
+ the built condition pushable into if such a condition exists
+ NULL if there is no such a condition
+*/
+
+Item *Item::build_pushable_cond(THD *thd,
+ Pushdown_checker checker,
+ uchar *arg)
+{
+ bool is_multiple_equality= type() == Item::FUNC_ITEM &&
+ ((Item_func*) this)->functype() == Item_func::MULT_EQUAL_FUNC;
+
+ if (get_extraction_flag() == NO_EXTRACTION_FL)
+ return 0;
+
+ if (type() == Item::COND_ITEM)
+ {
+ bool cond_and= false;
+ Item_cond *new_cond;
+ if (((Item_cond*) this)->functype() == Item_func::COND_AND_FUNC)
+ {
+ cond_and= true;
+ new_cond= new (thd->mem_root) Item_cond_and(thd);
+ }
+ else
+ new_cond= new (thd->mem_root) Item_cond_or(thd);
+ if (!new_cond)
+ return 0;
+ List_iterator<Item> li(*((Item_cond*) this)->argument_list());
+ Item *item;
+ bool is_fix_needed= false;
+
+ while ((item=li++))
+ {
+ if (item->get_extraction_flag() == NO_EXTRACTION_FL)
+ {
+ if (!cond_and)
+ return 0;
+ continue;
+ }
+ Item *fix= item->build_pushable_cond(thd, checker, arg);
+ if (!fix && !cond_and)
+ return 0;
+ if (!fix)
+ continue;
+
+ if (fix->type() == Item::COND_ITEM &&
+ ((Item_cond*) fix)->functype() == Item_func::COND_AND_FUNC)
+ is_fix_needed= true;
+
+ if (new_cond->argument_list()->push_back(fix, thd->mem_root))
+ return 0;
+ }
+ if (is_fix_needed && new_cond->fix_fields(thd, 0))
+ return 0;
+
+ switch (new_cond->argument_list()->elements)
+ {
+ case 0:
+ return 0;
+ case 1:
+ return new_cond->argument_list()->head();
+ default:
+ return new_cond;
+ }
+ }
+ else if (is_multiple_equality)
+ {
+ List<Item> equalities;
+ Item *new_cond= NULL;
+ if (((Item_equal *)this)->create_pushable_equalities(thd, &equalities,
+ checker, arg, true) ||
+ (equalities.elements == 0))
+ return 0;
+
+ switch (equalities.elements)
+ {
+ case 0:
+ return 0;
+ case 1:
+ new_cond= equalities.head();
+ break;
+ default:
+ new_cond= new (thd->mem_root) Item_cond_and(thd, equalities);
+ break;
+ }
+ if (new_cond && new_cond->fix_fields(thd, &new_cond))
+ return 0;
+ return new_cond;
+ }
+ else if (get_extraction_flag() != NO_EXTRACTION_FL)
+ return build_clone(thd);
+ return 0;
+}
+
+
+static
+Item *get_field_item_for_having(THD *thd, Item *item, st_select_lex *sel)
+{
+ DBUG_ASSERT(item->type() == Item::FIELD_ITEM ||
+ (item->type() == Item::REF_ITEM &&
+ ((Item_ref *) item)->ref_type() == Item_ref::VIEW_REF));
+ Item_field *field_item= NULL;
+ table_map map= sel->master_unit()->derived->table->map;
+ Item_equal *item_equal= item->get_item_equal();
+ if (!item_equal)
+ field_item= (Item_field *)(item->real_item());
+ else
+ {
+ Item_equal_fields_iterator li(*item_equal);
+ Item *equal_item;
+ while ((equal_item= li++))
+ {
+ if (equal_item->used_tables() == map)
+ {
+ field_item= (Item_field *)(equal_item->real_item());
+ break;
+ }
+ }
+ }
+ if (field_item)
+ {
+ Item_ref *ref= new (thd->mem_root) Item_ref(thd, &sel->context,
+ field_item->field_name);
+ return ref;
+ }
+ DBUG_ASSERT(0);
+ return NULL;
+}
+
+
+Item *Item_field::derived_field_transformer_for_having(THD *thd, uchar *arg)
+{
+ st_select_lex *sel= (st_select_lex *)arg;
+ table_map tab_map= sel->master_unit()->derived->table->map;
+ if (item_equal && !(item_equal->used_tables() & tab_map))
+ return this;
+ if (!item_equal && used_tables() != tab_map)
+ return this;
+ Item *item= get_field_item_for_having(thd, this, sel);
+ if (item)
+ item->marker|= SUBSTITUTION_FL;
+ return item;
+}
+
+
+Item *Item_direct_view_ref::derived_field_transformer_for_having(THD *thd,
+ uchar *arg)
+{
+ if ((*ref)->marker & SUBSTITUTION_FL)
+ {
+ this->marker|= SUBSTITUTION_FL;
+ return this;
+ }
+ st_select_lex *sel= (st_select_lex *)arg;
+ table_map tab_map= sel->master_unit()->derived->table->map;
+ if ((item_equal && !(item_equal->used_tables() & tab_map)) ||
+ !item_equal)
+ return this;
+ return get_field_item_for_having(thd, this, sel);
+}
+
+
+static
+Item *find_producing_item(Item *item, st_select_lex *sel)
+{
+ DBUG_ASSERT(item->type() == Item::FIELD_ITEM ||
+ (item->type() == Item::REF_ITEM &&
+ ((Item_ref *) item)->ref_type() == Item_ref::VIEW_REF));
+ Item_field *field_item= NULL;
+ Item_equal *item_equal= item->get_item_equal();
+ table_map tab_map= sel->master_unit()->derived->table->map;
+ if (item->used_tables() == tab_map)
+ field_item= (Item_field *) (item->real_item());
+ if (!field_item && item_equal)
+ {
+ Item_equal_fields_iterator it(*item_equal);
+ Item *equal_item;
+ while ((equal_item= it++))
+ {
+ if (equal_item->used_tables() == tab_map)
+ {
+ field_item= (Item_field *) (equal_item->real_item());
+ break;
+ }
+ }
+ }
+ List_iterator_fast<Item> li(sel->item_list);
+ if (field_item)
+ {
+ Item *producing_item= NULL;
+ uint field_no= field_item->field->field_index;
+ for (uint i= 0; i <= field_no; i++)
+ producing_item= li++;
+ return producing_item;
+ }
+ return NULL;
+}
+
+Item *Item_field::derived_field_transformer_for_where(THD *thd, uchar *arg)
+{
+ st_select_lex *sel= (st_select_lex *)arg;
+ Item *producing_item= find_producing_item(this, sel);
+ if (producing_item)
+ {
+ Item *producing_clone= producing_item->build_clone(thd);
+ if (producing_clone)
+ producing_clone->marker|= SUBSTITUTION_FL;
+ return producing_clone;
+ }
+ return this;
+}
+
+Item *Item_direct_view_ref::derived_field_transformer_for_where(THD *thd,
+ uchar *arg)
+{
+ if ((*ref)->marker & SUBSTITUTION_FL)
+ return (*ref);
+ if (item_equal)
+ {
+ st_select_lex *sel= (st_select_lex *)arg;
+ Item *producing_item= find_producing_item(this, sel);
+ DBUG_ASSERT (producing_item != NULL);
+ return producing_item->build_clone(thd);
+ }
+ return (*ref);
+}
+
+
+Item *Item_field::grouping_field_transformer_for_where(THD *thd, uchar *arg)
+{
+ st_select_lex *sel= (st_select_lex *)arg;
+ Field_pair *gr_field= find_matching_field_pair(this, sel->grouping_tmp_fields);
+ if (gr_field)
+ {
+ Item *producing_clone=
+ gr_field->corresponding_item->build_clone(thd);
+ if (producing_clone)
+ producing_clone->marker|= SUBSTITUTION_FL;
+ return producing_clone;
+ }
+ return this;
+}
+
+
+Item *
+Item_direct_view_ref::grouping_field_transformer_for_where(THD *thd,
+ uchar *arg)
+{
+ if ((*ref)->marker & SUBSTITUTION_FL)
+ {
+ this->marker|= SUBSTITUTION_FL;
+ return this;
+ }
+ if (!item_equal)
+ return this;
+ st_select_lex *sel= (st_select_lex *)arg;
+ Field_pair *gr_field= find_matching_field_pair(this,
+ sel->grouping_tmp_fields);
+ return gr_field->corresponding_item->build_clone(thd);
+}
+
+void Item_field::print(String *str, enum_query_type query_type)
+{
+ if (field && field->table->const_table &&
+ !(query_type & (QT_NO_DATA_EXPANSION | QT_VIEW_INTERNAL)))
+ {
+ print_value(str);
+ return;
+ }
+ Item_ident::print(str, query_type);
+}
+
+
+void Item_temptable_field::print(String *str, enum_query_type query_type)
+{
+ /*
+ Item_ident doesn't have references to the underlying Field/TABLE objects,
+ so it's ok to use the following:
+ */
+ Item_ident::print(str, query_type);
+}
+
+
+Item_ref::Item_ref(THD *thd, Name_resolution_context *context_arg,
+ Item **item, const LEX_CSTRING &table_name_arg,
+ const LEX_CSTRING &field_name_arg,
+ bool alias_name_used_arg):
+ Item_ident(thd, context_arg, null_clex_str, table_name_arg, field_name_arg),
+ ref(item), reference_trough_name(0)
+{
+ alias_name_used= alias_name_used_arg;
+ /*
+ This constructor used to create some internals references over fixed items
+ */
+ if ((set_properties_only= (ref && *ref && (*ref)->is_fixed())))
+ set_properties();
+}
+
+/*
+ A Field_enumerator-compatible class that invokes mark_as_dependent() for
+ each field that is a reference to some ancestor of current_select.
+*/
+class Dependency_marker: public Field_enumerator
+{
+public:
+ THD *thd;
+ st_select_lex *current_select;
+ virtual void visit_field(Item_field *item)
+ {
+ // Find which select the field is in. This is achieved by walking up
+ // the select tree and looking for the table of interest.
+ st_select_lex *sel;
+ for (sel= current_select;
+ sel ;
+ sel= (sel->context.outer_context ?
+ sel->context.outer_context->select_lex:
+ NULL))
+ {
+ List_iterator<TABLE_LIST> li(sel->leaf_tables);
+ TABLE_LIST *tbl;
+ while ((tbl= li++))
+ {
+ if (tbl->table == item->field->table)
+ {
+ if (sel != current_select)
+ mark_as_dependent(thd, sel, current_select, item, item, false);
+ return;
+ }
+ }
+ }
+ }
+};
+
+Item_ref::Item_ref(THD *thd, TABLE_LIST *view_arg, Item **item,
+ const LEX_CSTRING &field_name_arg,
+ bool alias_name_used_arg):
+ Item_ident(thd, view_arg, field_name_arg),
+ ref(item), reference_trough_name(0)
+{
+ alias_name_used= alias_name_used_arg;
+ /*
+ This constructor is used to create some internal references over fixed items
+ */
+ if ((set_properties_only= (ref && *ref && (*ref)->is_fixed())))
+ set_properties();
+}
+
+
+/**
+ Resolve the name of a reference to a column reference.
+
+ The method resolves the column reference represented by 'this' as a column
+ present in one of: GROUP BY clause, SELECT clause, outer queries. It is
+ used typically for columns in the HAVING clause which are not under
+ aggregate functions.
+
+ POSTCONDITION @n
+ Item_ref::ref is 0 or points to a valid item.
+
+ @note
+ The name resolution algorithm used is (where [T_j] is an optional table
+ name that qualifies the column name):
+
+ @code
+ resolve_extended([T_j].col_ref_i)
+ {
+ Search for a column or derived column named col_ref_i [in table T_j]
+ in the SELECT and GROUP clauses of Q.
+
+ if such a column is NOT found AND // Lookup in outer queries.
+ there are outer queries
+ {
+ for each outer query Q_k beginning from the inner-most one
+ {
+ Search for a column or derived column named col_ref_i
+ [in table T_j] in the SELECT and GROUP clauses of Q_k.
+
+ if such a column is not found AND
+ - Q_k is not a group query AND
+ - Q_k is not inside an aggregate function
+ OR
+ - Q_(k-1) is not in a HAVING or SELECT clause of Q_k
+ {
+ search for a column or derived column named col_ref_i
+ [in table T_j] in the FROM clause of Q_k;
+ }
+ }
+ }
+ }
+ @endcode
+ @n
+ This procedure treats GROUP BY and SELECT clauses as one namespace for
+ column references in HAVING. Notice that compared to
+ Item_field::fix_fields, here we first search the SELECT and GROUP BY
+ clauses, and then we search the FROM clause.
+
+ @param[in] thd current thread
+ @param[in,out] reference view column if this item was resolved to a
+ view column
+
+ @todo
+ Here we could first find the field anyway, and then test this
+ condition, so that we can give a better error message -
+ ER_WRONG_FIELD_WITH_GROUP, instead of the less informative
+ ER_BAD_FIELD_ERROR which we produce now.
+
+ @retval
+ TRUE if error
+ @retval
+ FALSE on success
+*/
+
+bool Item_ref::fix_fields(THD *thd, Item **reference)
+{
+ enum_parsing_place place= NO_MATTER;
+ DBUG_ASSERT(fixed == 0);
+ SELECT_LEX *current_sel= thd->lex->current_select;
+
+ if (set_properties_only)
+ {
+ /* do nothing */
+ }
+ else if (!ref || ref == not_found_item)
+ {
+ DBUG_ASSERT(reference_trough_name != 0);
+ if (!(ref= resolve_ref_in_select_and_group(thd, this,
+ context->select_lex)))
+ goto error; /* Some error occurred (e.g. ambiguous names). */
+
+ if (ref == not_found_item) /* This reference was not resolved. */
+ {
+ Name_resolution_context *last_checked_context= context;
+ Name_resolution_context *outer_context= context->outer_context;
+ Field *from_field;
+ ref= 0;
+
+ if (unlikely(!outer_context))
+ {
+ /* The current reference cannot be resolved in this query. */
+ my_error(ER_BAD_FIELD_ERROR,MYF(0),
+ this->full_name(), thd->where);
+ goto error;
+ }
+
+ /*
+ If there is an outer context (select), and it is not a derived table
+ (which do not support the use of outer fields for now), try to
+ resolve this reference in the outer select(s).
+
+ We treat each subselect as a separate namespace, so that different
+ subselects may contain columns with the same names. The subselects are
+ searched starting from the innermost.
+ */
+ from_field= (Field*) not_found_field;
+
+ do
+ {
+ SELECT_LEX *select= outer_context->select_lex;
+ Item_subselect *prev_subselect_item=
+ last_checked_context->select_lex->master_unit()->item;
+ last_checked_context= outer_context;
+
+ /* Search in the SELECT and GROUP lists of the outer select. */
+ if (outer_context->resolve_in_select_list)
+ {
+ if (!(ref= resolve_ref_in_select_and_group(thd, this, select)))
+ goto error; /* Some error occurred (e.g. ambiguous names). */
+ if (ref != not_found_item)
+ {
+ DBUG_ASSERT(*ref && (*ref)->is_fixed());
+ prev_subselect_item->used_tables_and_const_cache_join(*ref);
+ break;
+ }
+ /*
+ Set ref to 0 to ensure that we get an error in case we replaced
+ this item with another item and still use this item in some
+ other place of the parse tree.
+ */
+ ref= 0;
+ }
+
+ place= prev_subselect_item->parsing_place;
+ /*
+ Check table fields only if the subquery is used somewhere out of
+ HAVING or the outer SELECT does not use grouping (i.e. tables are
+ accessible).
+ TODO:
+ Here we could first find the field anyway, and then test this
+ condition, so that we can give a better error message -
+ ER_WRONG_FIELD_WITH_GROUP, instead of the less informative
+ ER_BAD_FIELD_ERROR which we produce now.
+ */
+ if ((place != IN_HAVING ||
+ (!select->with_sum_func &&
+ select->group_list.elements == 0)))
+ {
+ /*
+ In case of view, find_field_in_tables() write pointer to view
+ field expression to 'reference', i.e. it substitute that
+ expression instead of this Item_ref
+ */
+ from_field= find_field_in_tables(thd, this,
+ outer_context->
+ first_name_resolution_table,
+ outer_context->
+ last_name_resolution_table,
+ reference,
+ IGNORE_EXCEPT_NON_UNIQUE,
+ TRUE, TRUE);
+ if (! from_field)
+ goto error;
+ if (from_field == view_ref_found)
+ {
+ Item::Type refer_type= (*reference)->type();
+ prev_subselect_item->used_tables_and_const_cache_join(*reference);
+ DBUG_ASSERT((*reference)->type() == REF_ITEM);
+ mark_as_dependent(thd, last_checked_context->select_lex,
+ context->select_lex, this,
+ ((refer_type == REF_ITEM ||
+ refer_type == FIELD_ITEM) ?
+ (Item_ident*) (*reference) :
+ 0), false);
+ /*
+ view reference found, we substituted it instead of this
+ Item, so can quit
+ */
+ return FALSE;
+ }
+ if (from_field != not_found_field)
+ {
+ if (cached_table && cached_table->select_lex &&
+ outer_context->select_lex &&
+ cached_table->select_lex != outer_context->select_lex)
+ {
+ /*
+ Due to cache, find_field_in_tables() can return field which
+ doesn't belong to provided outer_context. In this case we have
+ to find proper field context in order to fix field correctly.
+ */
+ do
+ {
+ outer_context= outer_context->outer_context;
+ select= outer_context->select_lex;
+ prev_subselect_item=
+ last_checked_context->select_lex->master_unit()->item;
+ last_checked_context= outer_context;
+ } while (outer_context && outer_context->select_lex &&
+ cached_table->select_lex != outer_context->select_lex);
+ }
+ prev_subselect_item->used_tables_cache|= from_field->table->map;
+ prev_subselect_item->const_item_cache= 0;
+ break;
+ }
+ }
+ DBUG_ASSERT(from_field == not_found_field);
+
+ /* Reference is not found => depend on outer (or just error). */
+ prev_subselect_item->used_tables_cache|= OUTER_REF_TABLE_BIT;
+ prev_subselect_item->const_item_cache= 0;
+
+ outer_context= outer_context->outer_context;
+ } while (outer_context);
+
+ DBUG_ASSERT(from_field != 0 && from_field != view_ref_found);
+ if (from_field != not_found_field)
+ {
+ Item_field* fld;
+ if (!(fld= new (thd->mem_root) Item_field(thd, from_field)))
+ goto error;
+ thd->change_item_tree(reference, fld);
+ mark_as_dependent(thd, last_checked_context->select_lex,
+ current_sel, fld, fld, false);
+ /*
+ A reference is resolved to a nest level that's outer or the same as
+ the nest level of the enclosing set function : adjust the value of
+ max_arg_level for the function if it's needed.
+ */
+ if (thd->lex->in_sum_func &&
+ thd->lex->in_sum_func->nest_level >=
+ last_checked_context->select_lex->nest_level)
+ set_if_bigger(thd->lex->in_sum_func->max_arg_level,
+ last_checked_context->select_lex->nest_level);
+ return FALSE;
+ }
+ if (unlikely(ref == 0))
+ {
+ /* The item was not a table field and not a reference */
+ my_error(ER_BAD_FIELD_ERROR, MYF(0),
+ this->full_name(), thd->where);
+ goto error;
+ }
+ /* Should be checked in resolve_ref_in_select_and_group(). */
+ DBUG_ASSERT(*ref && (*ref)->is_fixed());
+ mark_as_dependent(thd, last_checked_context->select_lex,
+ context->select_lex, this, this, false);
+ /*
+ A reference is resolved to a nest level that's outer or the same as
+ the nest level of the enclosing set function : adjust the value of
+ max_arg_level for the function if it's needed.
+ */
+ if (thd->lex->in_sum_func &&
+ thd->lex->in_sum_func->nest_level >=
+ last_checked_context->select_lex->nest_level)
+ set_if_bigger(thd->lex->in_sum_func->max_arg_level,
+ last_checked_context->select_lex->nest_level);
+ }
+ }
+
+ DBUG_ASSERT(*ref);
+ /*
+ Check if this is an incorrect reference in a group function or forward
+ reference. Do not issue an error if this is:
+ 1. outer reference (will be fixed later by the fix_inner_refs function);
+ 2. an unnamed reference inside an aggregate function.
+ */
+ if (!((*ref)->type() == REF_ITEM &&
+ ((Item_ref *)(*ref))->ref_type() == OUTER_REF) &&
+ (((*ref)->with_sum_func() && name.str &&
+ !(current_sel->get_linkage() != GLOBAL_OPTIONS_TYPE &&
+ current_sel->having_fix_field)) ||
+ !(*ref)->is_fixed()))
+ {
+ my_error(ER_ILLEGAL_REFERENCE, MYF(0),
+ name.str, ((*ref)->with_sum_func() ?
+ "reference to group function":
+ "forward reference in item list"));
+ goto error;
+ }
+
+ set_properties();
+
+ if ((*ref)->check_cols(1))
+ goto error;
+ return FALSE;
+
+error:
+ context->process_error(thd);
+ return TRUE;
+}
+
+
+void Item_ref::set_properties()
+{
+ Type_std_attributes::set(*ref);
+ maybe_null= (*ref)->maybe_null;
+ /*
+ We have to remember if we refer to a sum function, to ensure that
+ split_sum_func() doesn't try to change the reference.
+ */
+ copy_with_sum_func(*ref);
+ with_param= (*ref)->with_param;
+ with_window_func= (*ref)->with_window_func;
+ with_field= (*ref)->with_field;
+ fixed= 1;
+ if (alias_name_used)
+ return;
+ if ((*ref)->type() == FIELD_ITEM)
+ alias_name_used= ((Item_ident *) (*ref))->alias_name_used;
+ else
+ alias_name_used= TRUE; // it is not field, so it is was resolved by alias
+}
+
+
+void Item_ref::cleanup()
+{
+ DBUG_ENTER("Item_ref::cleanup");
+ Item_ident::cleanup();
+ if (reference_trough_name)
+ {
+ /* We have to reset the reference as it may been freed */
+ ref= 0;
+ }
+ DBUG_VOID_RETURN;
+}
+
+
+/**
+ Transform an Item_ref object with a transformer callback function.
+
+ The function first applies the transform method to the item
+ referenced by this Item_ref object. If this returns a new item the
+ old item is substituted for a new one. After this the transformer
+ is applied to the Item_ref object.
+
+ @param transformer the transformer callback function to be applied to
+ the nodes of the tree of the object
+ @param argument parameter to be passed to the transformer
+
+ @return Item returned as the result of transformation of the Item_ref object
+ @retval !NULL The transformation was successful
+ @retval NULL Out of memory error
+*/
+
+Item* Item_ref::transform(THD *thd, Item_transformer transformer, uchar *arg)
+{
+ DBUG_ASSERT(!thd->stmt_arena->is_stmt_prepare());
+ DBUG_ASSERT((*ref) != NULL);
+
+ /* Transform the object we are referencing. */
+ Item *new_item= (*ref)->transform(thd, transformer, arg);
+ if (!new_item)
+ return NULL;
+
+ /*
+ THD::change_item_tree() should be called only if the tree was
+ really transformed, i.e. when a new item has been created.
+ Otherwise we'll be allocating a lot of unnecessary memory for
+ change records at each execution.
+ */
+ if (*ref != new_item)
+ thd->change_item_tree(ref, new_item);
+
+ /* Transform the item ref object. */
+ return (this->*transformer)(thd, arg);
+}
+
+
+/**
+ Compile an Item_ref object with a processor and a transformer
+ callback functions.
+
+ First the function applies the analyzer to the Item_ref object. Then
+ if the analyzer succeeds we first apply the compile method to the
+ object the Item_ref object is referencing. If this returns a new
+ item the old item is substituted for a new one. After this the
+ transformer is applied to the Item_ref object itself.
+ The compile function is not called if the analyzer returns NULL
+ in the parameter arg_p.
+
+ @param analyzer the analyzer callback function to be applied to the
+ nodes of the tree of the object
+ @param[in,out] arg_p parameter to be passed to the processor
+ @param transformer the transformer callback function to be applied to the
+ nodes of the tree of the object
+ @param arg_t parameter to be passed to the transformer
+
+ @return Item returned as the result of transformation of the Item_ref object
+*/
+
+Item* Item_ref::compile(THD *thd, Item_analyzer analyzer, uchar **arg_p,
+ Item_transformer transformer, uchar *arg_t)
+{
+ /* Analyze this Item object. */
+ if (!(this->*analyzer)(arg_p))
+ return NULL;
+
+ /* Compile the Item we are referencing. */
+ DBUG_ASSERT((*ref) != NULL);
+ if (*arg_p)
+ {
+ uchar *arg_v= *arg_p;
+ Item *new_item= (*ref)->compile(thd, analyzer, &arg_v, transformer, arg_t);
+ if (new_item && *ref != new_item)
+ thd->change_item_tree(ref, new_item);
+ }
+
+ /* Transform this Item object. */
+ return (this->*transformer)(thd, arg_t);
+}
+
+
+void Item_ref::print(String *str, enum_query_type query_type)
+{
+ if (ref)
+ {
+ if ((*ref)->type() != Item::CACHE_ITEM &&
+ (*ref)->type() != Item::WINDOW_FUNC_ITEM &&
+ ref_type() != VIEW_REF &&
+ !table_name.str && name.str && alias_name_used)
+ {
+ THD *thd= current_thd;
+ append_identifier(thd, str, &(*ref)->real_item()->name);
+ }
+ else
+ (*ref)->print(str, query_type);
+ }
+ else
+ Item_ident::print(str, query_type);
+}
+
+
+bool Item_ref::send(Protocol *prot, st_value *buffer)
+{
+ if (result_field)
+ return prot->store(result_field);
+ return (*ref)->send(prot, buffer);
+}
+
+
+double Item_ref::val_result()
+{
+ if (result_field)
+ {
+ if ((null_value= result_field->is_null()))
+ return 0.0;
+ return result_field->val_real();
+ }
+ return val_real();
+}
+
+
+bool Item_ref::is_null_result()
+{
+ if (result_field)
+ return (null_value=result_field->is_null());
+
+ return is_null();
+}
+
+
+longlong Item_ref::val_int_result()
+{
+ if (result_field)
+ {
+ if ((null_value= result_field->is_null()))
+ return 0;
+ return result_field->val_int();
+ }
+ return val_int();
+}
+
+
+String *Item_ref::str_result(String* str)
+{
+ if (result_field)
+ {
+ if ((null_value= result_field->is_null()))
+ return 0;
+ str->set_charset(str_value.charset());
+ return result_field->val_str(str, &str_value);
+ }
+ return val_str(str);
+}
+
+
+bool Item_ref::val_native_result(THD *thd, Native *to)
+{
+ return result_field ?
+ val_native_from_field(result_field, to) :
+ val_native(thd, to);
+}
+
+
+my_decimal *Item_ref::val_decimal_result(my_decimal *decimal_value)
+{
+ if (result_field)
+ {
+ if ((null_value= result_field->is_null()))
+ return 0;
+ return result_field->val_decimal(decimal_value);
+ }
+ return val_decimal(decimal_value);
+}
+
+
+bool Item_ref::val_bool_result()
+{
+ if (result_field)
+ {
+ if ((null_value= result_field->is_null()))
+ return false;
+ return result_field->val_bool();
+ }
+ return val_bool();
+}
+
+
+void Item_ref::save_result(Field *to)
+{
+ if (result_field)
+ {
+ save_field_in_field(result_field, &null_value, to, TRUE);
+ return;
+ }
+ (*ref)->save_result(to);
+ null_value= (*ref)->null_value;
+}
+
+
+void Item_ref::save_val(Field *to)
+{
+ (*ref)->save_result(to);
+ null_value= (*ref)->null_value;
+}
+
+
+double Item_ref::val_real()
+{
+ DBUG_ASSERT(fixed);
+ double tmp=(*ref)->val_result();
+ null_value=(*ref)->null_value;
+ return tmp;
+}
+
+
+longlong Item_ref::val_int()
+{
+ DBUG_ASSERT(fixed);
+ longlong tmp=(*ref)->val_int_result();
+ null_value=(*ref)->null_value;
+ return tmp;
+}
+
+
+bool Item_ref::val_bool()
+{
+ DBUG_ASSERT(fixed);
+ bool tmp= (*ref)->val_bool_result();
+ null_value= (*ref)->null_value;
+ return tmp;
+}
+
+
+String *Item_ref::val_str(String* tmp)
+{
+ DBUG_ASSERT(fixed);
+ tmp=(*ref)->str_result(tmp);
+ null_value=(*ref)->null_value;
+ return tmp;
+}
+
+
+bool Item_ref::is_null()
+{
+ DBUG_ASSERT(fixed);
+ bool tmp=(*ref)->is_null_result();
+ null_value=(*ref)->null_value;
+ return tmp;
+}
+
+
+bool Item_ref::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+{
+ return (null_value=(*ref)->get_date_result(thd, ltime, fuzzydate));
+}
+
+
+bool Item_ref::val_native(THD *thd, Native *to)
+{
+ return val_native_from_item(thd, *ref, to);
+}
+
+
+longlong Item_ref::val_datetime_packed(THD *thd)
+{
+ DBUG_ASSERT(fixed);
+ longlong tmp= (*ref)->val_datetime_packed_result(thd);
+ null_value= (*ref)->null_value;
+ return tmp;
+}
+
+
+longlong Item_ref::val_time_packed(THD *thd)
+{
+ DBUG_ASSERT(fixed);
+ longlong tmp= (*ref)->val_time_packed_result(thd);
+ null_value= (*ref)->null_value;
+ return tmp;
+}
+
+
+my_decimal *Item_ref::val_decimal(my_decimal *decimal_value)
+{
+ my_decimal *val= (*ref)->val_decimal_result(decimal_value);
+ null_value= (*ref)->null_value;
+ return val;
+}
+
+int Item_ref::save_in_field(Field *to, bool no_conversions)
+{
+ int res;
+ if (result_field)
+ {
+ if (result_field->is_null())
+ {
+ null_value= 1;
+ res= set_field_to_null_with_conversions(to, no_conversions);
+ return res;
+ }
+ to->set_notnull();
+ res= field_conv(to, result_field);
+ null_value= 0;
+ return res;
+ }
+ res= (*ref)->save_in_field(to, no_conversions);
+ null_value= (*ref)->null_value;
+ return res;
+}
+
+
+void Item_ref::save_org_in_field(Field *field, fast_field_copier optimizer_data)
+{
+ (*ref)->save_org_in_field(field, optimizer_data);
+}
+
+
+void Item_ref::make_send_field(THD *thd, Send_field *field)
+{
+ (*ref)->make_send_field(thd, field);
+ /* Non-zero in case of a view */
+ if (name.str)
+ field->col_name= name;
+ if (table_name.str)
+ field->table_name= table_name;
+ if (db_name.str)
+ field->db_name= db_name;
+ if (orig_field_name.str)
+ field->org_col_name= orig_field_name;
+ if (orig_table_name.str)
+ field->org_table_name= orig_table_name;
+}
+
+
+Item *Item_ref::get_tmp_table_item(THD *thd)
+{
+ if (!result_field)
+ return (*ref)->get_tmp_table_item(thd);
+
+ Item_field *item= new (thd->mem_root) Item_field(thd, result_field);
+ if (item)
+ {
+ item->table_name= table_name;
+ item->db_name= db_name;
+ }
+ return item;
+}
+
+
+void Item_ref_null_helper::print(String *str, enum_query_type query_type)
+{
+ str->append(STRING_WITH_LEN("<ref_null_helper>("));
+ if (ref)
+ (*ref)->print(str, query_type);
+ else
+ str->append('?');
+ str->append(')');
+}
+
+
+void Item_direct_ref::save_val(Field *to)
+{
+ (*ref)->save_val(to);
+ null_value=(*ref)->null_value;
+}
+
+
+double Item_direct_ref::val_real()
+{
+ double tmp=(*ref)->val_real();
+ null_value=(*ref)->null_value;
+ return tmp;
+}
+
+
+longlong Item_direct_ref::val_int()
+{
+ longlong tmp=(*ref)->val_int();
+ null_value=(*ref)->null_value;
+ return tmp;
+}
+
+
+String *Item_direct_ref::val_str(String* tmp)
+{
+ tmp=(*ref)->val_str(tmp);
+ null_value=(*ref)->null_value;
+ return tmp;
+}
+
+
+my_decimal *Item_direct_ref::val_decimal(my_decimal *decimal_value)
+{
+ my_decimal *tmp= (*ref)->val_decimal(decimal_value);
+ null_value=(*ref)->null_value;
+ return tmp;
+}
+
+
+bool Item_direct_ref::val_bool()
+{
+ bool tmp= (*ref)->val_bool();
+ null_value=(*ref)->null_value;
+ return tmp;
+}
+
+
+bool Item_direct_ref::is_null()
+{
+ return (*ref)->is_null();
+}
+
+
+bool Item_direct_ref::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+{
+ return (null_value=(*ref)->get_date(thd, ltime, fuzzydate));
+}
+
+
+bool Item_direct_ref::val_native(THD *thd, Native *to)
+{
+ return val_native_from_item(thd, *ref, to);
+}
+
+
+longlong Item_direct_ref::val_time_packed(THD *thd)
+{
+ longlong tmp = (*ref)->val_time_packed(thd);
+ null_value= (*ref)->null_value;
+ return tmp;
+}
+
+
+longlong Item_direct_ref::val_datetime_packed(THD *thd)
+{
+ longlong tmp = (*ref)->val_datetime_packed(thd);
+ null_value= (*ref)->null_value;
+ return tmp;
+}
+
+
+Item_cache_wrapper::~Item_cache_wrapper()
+{
+ DBUG_ASSERT(expr_cache == 0);
+}
+
+Item_cache_wrapper::Item_cache_wrapper(THD *thd, Item *item_arg):
+ Item_result_field(thd), orig_item(item_arg), expr_cache(NULL), expr_value(NULL)
+{
+ DBUG_ASSERT(orig_item->is_fixed());
+ Type_std_attributes::set(orig_item);
+ maybe_null= orig_item->maybe_null;
+ copy_with_sum_func(orig_item);
+ with_param= orig_item->with_param;
+ with_field= orig_item->with_field;
+ name= item_arg->name;
+ m_with_subquery= orig_item->with_subquery();
+ with_window_func= orig_item->with_window_func;
+
+ if ((expr_value= orig_item->get_cache(thd)))
+ expr_value->setup(thd, orig_item);
+
+ fixed= 1;
+}
+
+
+/**
+ Initialize the cache if it is needed
+*/
+
+void Item_cache_wrapper::init_on_demand()
+{
+ if (!expr_cache->is_inited())
+ {
+ orig_item->get_cache_parameters(parameters);
+ expr_cache->init();
+ }
+}
+
+
+void Item_cache_wrapper::print(String *str, enum_query_type query_type)
+{
+ if (query_type & QT_ITEM_CACHE_WRAPPER_SKIP_DETAILS)
+ {
+ /* Don't print the cache in EXPLAIN EXTENDED */
+ orig_item->print(str, query_type);
+ return;
+ }
+
+ str->append("<expr_cache>");
+ if (expr_cache)
+ {
+ init_on_demand();
+ expr_cache->print(str, query_type);
+ }
+ else
+ str->append(STRING_WITH_LEN("<<DISABLED>>"));
+ str->append('(');
+ orig_item->print(str, query_type);
+ str->append(')');
+}
+
+
+/**
+ Prepare the expression cache wrapper (do nothing)
+
+ @retval FALSE OK
+*/
+
+bool Item_cache_wrapper::fix_fields(THD *thd __attribute__((unused)),
+ Item **it __attribute__((unused)))
+{
+ DBUG_ASSERT(orig_item->is_fixed());
+ DBUG_ASSERT(fixed);
+ return FALSE;
+}
+
+bool Item_cache_wrapper::send(Protocol *protocol, st_value *buffer)
+{
+ if (result_field)
+ return protocol->store(result_field);
+ return Item::send(protocol, buffer);
+}
+
+/**
+ Clean the expression cache wrapper up before reusing it.
+*/
+
+void Item_cache_wrapper::cleanup()
+{
+ DBUG_ENTER("Item_cache_wrapper::cleanup");
+ Item_result_field::cleanup();
+ delete expr_cache;
+ expr_cache= 0;
+ /* expr_value is Item so it will be destroyed from list of Items */
+ expr_value= 0;
+ parameters.empty();
+ DBUG_VOID_RETURN;
+}
+
+
+/**
+ Create an expression cache that uses a temporary table
+
+ @param thd Thread handle
+ @param depends_on Parameters of the expression to create cache for
+
+ @details
+ The function takes 'depends_on' as the list of all parameters for
+ the expression wrapped into this object and creates an expression
+ cache in a temporary table containing the field for the parameters
+ and the result of the expression.
+
+ @retval FALSE OK
+ @retval TRUE Error
+*/
+
+bool Item_cache_wrapper::set_cache(THD *thd)
+{
+ DBUG_ENTER("Item_cache_wrapper::set_cache");
+ DBUG_ASSERT(expr_cache == 0);
+ expr_cache= new Expression_cache_tmptable(thd, parameters, expr_value);
+ DBUG_RETURN(expr_cache == NULL);
+}
+
+Expression_cache_tracker* Item_cache_wrapper::init_tracker(MEM_ROOT *mem_root)
+{
+ if (expr_cache)
+ {
+ Expression_cache_tracker* tracker=
+ new(mem_root) Expression_cache_tracker(expr_cache);
+ if (tracker)
+ ((Expression_cache_tmptable *)expr_cache)->set_tracker(tracker);
+ return tracker;
+ }
+ return NULL;
+}
+
+
+/**
+ Check if the current values of the parameters are in the expression cache
+
+ @details
+ The function checks whether the current set of the parameters of the
+ referenced item can be found in the expression cache. If so the function
+ returns the item by which the result of the expression can be easily
+ extracted from the cache with the corresponding val_* method.
+
+ @retval NULL - parameters are not in the cache
+ @retval <item*> - item providing the result of the expression found in cache
+*/
+
+Item *Item_cache_wrapper::check_cache()
+{
+ DBUG_ENTER("Item_cache_wrapper::check_cache");
+ if (expr_cache)
+ {
+ Expression_cache_tmptable::result res;
+ Item *cached_value;
+ init_on_demand();
+ res= expr_cache->check_value(&cached_value);
+ if (res == Expression_cache_tmptable::HIT)
+ DBUG_RETURN(cached_value);
+ }
+ DBUG_RETURN(NULL);
+}
+
+
+/**
+ Get the value of the cached expression and put it in the cache
+*/
+
+inline void Item_cache_wrapper::cache()
+{
+ expr_value->store(orig_item);
+ expr_value->cache_value();
+ expr_cache->put_value(expr_value); // put in expr_cache
+}
+
+
+/**
+ Get the value of the possibly cached item into the field.
+*/
+
+void Item_cache_wrapper::save_val(Field *to)
+{
+ Item *cached_value;
+ DBUG_ENTER("Item_cache_wrapper::val_int");
+ if (!expr_cache)
+ {
+ orig_item->save_val(to);
+ null_value= orig_item->null_value;
+ DBUG_VOID_RETURN;
+ }
+
+ if ((cached_value= check_cache()))
+ {
+ cached_value->save_val(to);
+ null_value= cached_value->null_value;
+ DBUG_VOID_RETURN;
+ }
+ cache();
+ null_value= expr_value->null_value;
+ expr_value->save_val(to);
+ DBUG_VOID_RETURN;
+}
+
+
+/**
+ Get the integer value of the possibly cached item.
+*/
+
+longlong Item_cache_wrapper::val_int()
+{
+ Item *cached_value;
+ DBUG_ENTER("Item_cache_wrapper::val_int");
+ if (!expr_cache)
+ {
+ longlong tmp= orig_item->val_int();
+ null_value= orig_item->null_value;
+ DBUG_RETURN(tmp);
+ }
+
+ if ((cached_value= check_cache()))
+ {
+ longlong tmp= cached_value->val_int();
+ null_value= cached_value->null_value;
+ DBUG_RETURN(tmp);
+ }
+ cache();
+ null_value= expr_value->null_value;
+ DBUG_RETURN(expr_value->val_int());
+}
+
+
+/**
+ Get the real value of the possibly cached item
+*/
+
+double Item_cache_wrapper::val_real()
+{
+ Item *cached_value;
+ DBUG_ENTER("Item_cache_wrapper::val_real");
+ if (!expr_cache)
+ {
+ double tmp= orig_item->val_real();
+ null_value= orig_item->null_value;
+ DBUG_RETURN(tmp);
+ }
+
+ if ((cached_value= check_cache()))
+ {
+ double tmp= cached_value->val_real();
+ null_value= cached_value->null_value;
+ DBUG_RETURN(tmp);
+ }
+ cache();
+ null_value= expr_value->null_value;
+ DBUG_RETURN(expr_value->val_real());
+}
+
+
+/**
+ Get the string value of the possibly cached item
+*/
+
+String *Item_cache_wrapper::val_str(String* str)
+{
+ Item *cached_value;
+ DBUG_ENTER("Item_cache_wrapper::val_str");
+ if (!expr_cache)
+ {
+ String *tmp= orig_item->val_str(str);
+ null_value= orig_item->null_value;
+ DBUG_RETURN(tmp);
+ }
+
+ if ((cached_value= check_cache()))
+ {
+ String *tmp= cached_value->val_str(str);
+ null_value= cached_value->null_value;
+ DBUG_RETURN(tmp);
+ }
+ cache();
+ if ((null_value= expr_value->null_value))
+ DBUG_RETURN(NULL);
+ DBUG_RETURN(expr_value->val_str(str));
+}
+
+
+/**
+ Get the native value of the possibly cached item
+*/
+
+bool Item_cache_wrapper::val_native(THD *thd, Native* to)
+{
+ Item *cached_value;
+ DBUG_ENTER("Item_cache_wrapper::val_native");
+ if (!expr_cache)
+ DBUG_RETURN(val_native_from_item(thd, orig_item, to));
+
+ if ((cached_value= check_cache()))
+ DBUG_RETURN(val_native_from_item(thd, cached_value, to));
+
+ cache();
+ if ((null_value= expr_value->null_value))
+ DBUG_RETURN(true);
+ DBUG_RETURN(expr_value->val_native(thd, to));
+}
+
+
+
+/**
+ Get the decimal value of the possibly cached item
+*/
+
+my_decimal *Item_cache_wrapper::val_decimal(my_decimal* decimal_value)
+{
+ Item *cached_value;
+ DBUG_ENTER("Item_cache_wrapper::val_decimal");
+ if (!expr_cache)
+ {
+ my_decimal *tmp= orig_item->val_decimal(decimal_value);
+ null_value= orig_item->null_value;
+ DBUG_RETURN(tmp);
+ }
+
+ if ((cached_value= check_cache()))
+ {
+ my_decimal *tmp= cached_value->val_decimal(decimal_value);
+ null_value= cached_value->null_value;
+ DBUG_RETURN(tmp);
+ }
+ cache();
+ if ((null_value= expr_value->null_value))
+ DBUG_RETURN(NULL);
+ DBUG_RETURN(expr_value->val_decimal(decimal_value));
+}
+
+
+/**
+ Get the boolean value of the possibly cached item
+*/
+
+bool Item_cache_wrapper::val_bool()
+{
+ Item *cached_value;
+ DBUG_ENTER("Item_cache_wrapper::val_bool");
+ if (!expr_cache)
+ {
+ bool tmp= orig_item->val_bool();
+ null_value= orig_item->null_value;
+ DBUG_RETURN(tmp);
+ }
+
+ if ((cached_value= check_cache()))
+ {
+ bool tmp= cached_value->val_bool();
+ null_value= cached_value->null_value;
+ DBUG_RETURN(tmp);
+ }
+ cache();
+ null_value= expr_value->null_value;
+ DBUG_RETURN(expr_value->val_bool());
+}
+
+
+/**
+ Check for NULL the value of the possibly cached item
+*/
+
+bool Item_cache_wrapper::is_null()
+{
+ Item *cached_value;
+ DBUG_ENTER("Item_cache_wrapper::is_null");
+ if (!expr_cache)
+ {
+ bool tmp= orig_item->is_null();
+ null_value= orig_item->null_value;
+ DBUG_RETURN(tmp);
+ }
+
+ if ((cached_value= check_cache()))
+ {
+ bool tmp= cached_value->is_null();
+ null_value= cached_value->null_value;
+ DBUG_RETURN(tmp);
+ }
+ cache();
+ DBUG_RETURN((null_value= expr_value->null_value));
+}
+
+
+/**
+ Get the date value of the possibly cached item
+*/
+
+bool Item_cache_wrapper::get_date(THD *thd, MYSQL_TIME *ltime,
+ date_mode_t fuzzydate)
+{
+ Item *cached_value;
+ DBUG_ENTER("Item_cache_wrapper::get_date");
+ if (!expr_cache)
+ DBUG_RETURN((null_value= orig_item->get_date(thd, ltime, fuzzydate)));
+
+ if ((cached_value= check_cache()))
+ DBUG_RETURN((null_value= cached_value->get_date(thd, ltime, fuzzydate)));
+
+ cache();
+ DBUG_RETURN((null_value= expr_value->get_date(thd, ltime, fuzzydate)));
+}
+
+
+int Item_cache_wrapper::save_in_field(Field *to, bool no_conversions)
+{
+ int res;
+ DBUG_ASSERT(!result_field);
+ res= orig_item->save_in_field(to, no_conversions);
+ null_value= orig_item->null_value;
+ return res;
+}
+
+
+Item* Item_cache_wrapper::get_tmp_table_item(THD *thd)
+{
+ if (!orig_item->with_sum_func() && !orig_item->const_item())
+ return new (thd->mem_root) Item_temptable_field(thd, result_field);
+ return copy_or_same(thd);
+}
+
+
+bool Item_direct_view_ref::send(Protocol *protocol, st_value *buffer)
+{
+ if (check_null_ref())
+ return protocol->store_null();
+ return Item_direct_ref::send(protocol, buffer);
+}
+
+/**
+ Prepare referenced field then call usual Item_direct_ref::fix_fields .
+
+ @param thd thread handler
+ @param reference reference on reference where this item stored
+
+ @retval
+ FALSE OK
+ @retval
+ TRUE Error
+*/
+
+bool Item_direct_view_ref::fix_fields(THD *thd, Item **reference)
+{
+ /* view fild reference must be defined */
+ DBUG_ASSERT(*ref);
+ /* (*ref)->check_cols() will be made in Item_direct_ref::fix_fields */
+ if ((*ref)->is_fixed())
+ {
+ Item *ref_item= (*ref)->real_item();
+ if (ref_item->type() == Item::FIELD_ITEM)
+ {
+ /*
+ In some cases we need to update table read set(see bug#47150).
+ If ref item is FIELD_ITEM and fixed then field and table
+ have proper values. So we can use them for update.
+ */
+ Field *fld= ((Item_field*) ref_item)->field;
+ DBUG_ASSERT(fld && fld->table);
+ if (thd->column_usage == MARK_COLUMNS_READ)
+ bitmap_set_bit(fld->table->read_set, fld->field_index);
+ }
+ }
+ else if ((*ref)->fix_fields_if_needed(thd, ref))
+ return TRUE;
+
+ if (Item_direct_ref::fix_fields(thd, reference))
+ return TRUE;
+ if (view->table && view->table->maybe_null)
+ maybe_null= TRUE;
+ set_null_ref_table();
+ return FALSE;
+}
+
+/*
+ Prepare referenced outer field then call usual Item_direct_ref::fix_fields
+
+ SYNOPSIS
+ Item_outer_ref::fix_fields()
+ thd thread handler
+ reference reference on reference where this item stored
+
+ RETURN
+ FALSE OK
+ TRUE Error
+*/
+
+bool Item_outer_ref::fix_fields(THD *thd, Item **reference)
+{
+ bool err;
+ /* outer_ref->check_cols() will be made in Item_direct_ref::fix_fields */
+ if ((*ref) && (*ref)->fix_fields_if_needed(thd, reference))
+ return TRUE;
+ err= Item_direct_ref::fix_fields(thd, reference);
+ if (!outer_ref)
+ outer_ref= *ref;
+ if ((*ref)->type() == Item::FIELD_ITEM)
+ table_name= ((Item_field*)outer_ref)->table_name;
+ return err;
+}
+
+
+void Item_outer_ref::fix_after_pullout(st_select_lex *new_parent,
+ Item **ref_arg, bool merge)
+{
+ if (get_depended_from() == new_parent)
+ {
+ *ref_arg= outer_ref;
+ (*ref_arg)->fix_after_pullout(new_parent, ref_arg, merge);
+ }
+}
+
+void Item_ref::fix_after_pullout(st_select_lex *new_parent, Item **refptr,
+ bool merge)
+{
+ (*ref)->fix_after_pullout(new_parent, ref, merge);
+ if (get_depended_from() == new_parent)
+ depended_from= NULL;
+}
+
+
+/**
+ Mark references from inner selects used in group by clause
+
+ The method is used by the walk method when called for the expressions
+ from the group by clause. The callsare occurred in the function
+ fix_inner_refs invoked by JOIN::prepare.
+ The parameter passed to Item_outer_ref::check_inner_refs_processor
+ is the iterator over the list of inner references from the subselects
+ of the select to be prepared. The function marks those references
+ from this list whose occurrences are encountered in the group by
+ expressions passed to the walk method.
+
+ @param arg pointer to the iterator over a list of inner references
+
+ @return
+ FALSE always
+*/
+
+bool Item_outer_ref::check_inner_refs_processor(void *arg)
+{
+ List_iterator_fast<Item_outer_ref> *it=
+ ((List_iterator_fast<Item_outer_ref> *) arg);
+ Item_outer_ref *tmp_ref;
+ while ((tmp_ref= (*it)++))
+ {
+ if (tmp_ref == this)
+ {
+ tmp_ref->found_in_group_by= 1;
+ break;
+ }
+ }
+ (*it).rewind();
+ return FALSE;
+}
+
+
+/**
+ Compare two view column references for equality.
+
+ A view column reference is considered equal to another column
+ reference if the second one is a view column and if both column
+ references resolve to the same item. It is assumed that both
+ items are of the same type.
+
+ @param item item to compare with
+ @param binary_cmp make binary comparison
+
+ @retval
+ TRUE Referenced item is equal to given item
+ @retval
+ FALSE otherwise
+*/
+
+bool Item_direct_view_ref::eq(const Item *item, bool binary_cmp) const
+{
+ if (item->type() == REF_ITEM)
+ {
+ Item_ref *item_ref= (Item_ref*) item;
+ if (item_ref->ref_type() == VIEW_REF)
+ {
+ Item *item_ref_ref= *(item_ref->ref);
+ return ((*ref)->real_item() == item_ref_ref->real_item());
+ }
+ }
+ return FALSE;
+}
+
+
+Item_equal *Item_direct_view_ref::find_item_equal(COND_EQUAL *cond_equal)
+{
+ Item* field_item= real_item();
+ if (field_item->type() != FIELD_ITEM)
+ return NULL;
+ return ((Item_field *) field_item)->find_item_equal(cond_equal);
+}
+
+
+/**
+ Set a pointer to the multiple equality the view field reference belongs to
+ (if any).
+
+ @details
+ The function looks for a multiple equality containing this item of the type
+ Item_direct_view_ref among those referenced by arg.
+ In the case such equality exists the function does the following.
+ If the found multiple equality contains a constant, then the item
+ is substituted for this constant, otherwise the function sets a pointer
+ to the multiple equality in the item.
+
+ @param arg reference to list of multiple equalities where
+ the item (this object) is to be looked for
+
+ @note
+ This function is supposed to be called as a callback parameter in calls
+ of the compile method.
+
+ @note
+ The function calls Item_field::propagate_equal_fields() for the field item
+ this->real_item() to do the job. Then it takes the pointer to equal_item
+ from this field item and assigns it to this->item_equal.
+
+ @return
+ - pointer to the replacing constant item, if the field item was substituted
+ - pointer to the field item, otherwise.
+*/
+
+Item *Item_direct_view_ref::propagate_equal_fields(THD *thd,
+ const Context &ctx,
+ COND_EQUAL *cond)
+{
+ Item *field_item= real_item();
+ if (field_item->type() != FIELD_ITEM)
+ return this;
+ Item *item= field_item->propagate_equal_fields(thd, ctx, cond);
+ set_item_equal(field_item->get_item_equal());
+ field_item->set_item_equal(NULL);
+ if (item != field_item)
+ return item;
+ return this;
+}
+
+
+Item *Item_ref::propagate_equal_fields(THD *thd, const Context &ctx,
+ COND_EQUAL *cond)
+{
+ Item *field_item= real_item();
+ if (field_item->type() != FIELD_ITEM)
+ return this;
+ Item *item= field_item->propagate_equal_fields(thd, ctx, cond);
+ if (item != field_item)
+ return item;
+ return this;
+}
+
+
+/**
+ Replace an Item_direct_view_ref for an equal Item_field evaluated earlier
+ (if any).
+
+ @details
+ If this->item_equal points to some item and coincides with arg then
+ the function returns a pointer to a field item that is referred to by the
+ first element of the item_equal list which the Item_direct_view_ref
+ object belongs to unless item_equal contains a constant item. In this
+ case the function returns this constant item (if the substitution does
+ not require conversion).
+ If the Item_direct_view_ref object does not refer any Item_equal object
+ 'this' is returned .
+
+ @param arg NULL or points to so some item of the Item_equal type
+
+ @note
+ This function is supposed to be called as a callback parameter in calls
+ of the transformer method.
+
+ @note
+ The function calls Item_field::replace_equal_field for the field item
+ this->real_item() to do the job.
+
+ @return
+ - pointer to a replacement Item_field if there is a better equal item or
+ a pointer to a constant equal item;
+ - this - otherwise.
+*/
+
+Item *Item_direct_view_ref::replace_equal_field(THD *thd, uchar *arg)
+{
+ Item *field_item= real_item();
+ if (field_item->type() != FIELD_ITEM)
+ return this;
+ field_item->set_item_equal(item_equal);
+ Item *item= field_item->replace_equal_field(thd, arg);
+ field_item->set_item_equal(0);
+ return item != field_item ? item : this;
+}
+
+
+bool Item_field::excl_dep_on_table(table_map tab_map)
+{
+ return used_tables() == tab_map ||
+ (item_equal && (item_equal->used_tables() & tab_map));
+}
+
+
+bool
+Item_field::excl_dep_on_grouping_fields(st_select_lex *sel)
+{
+ return find_matching_field_pair(this, sel->grouping_tmp_fields) != NULL;
+}
+
+
+bool Item_direct_view_ref::excl_dep_on_table(table_map tab_map)
+{
+ table_map used= used_tables();
+ if (used & OUTER_REF_TABLE_BIT)
+ return false;
+ if (!(used & ~tab_map))
+ return true;
+ if (item_equal)
+ {
+ DBUG_ASSERT(real_item()->type() == Item::FIELD_ITEM);
+ return item_equal->used_tables() & tab_map;
+ }
+ return (*ref)->excl_dep_on_table(tab_map);
+}
+
+
+bool Item_direct_view_ref::excl_dep_on_grouping_fields(st_select_lex *sel)
+{
+ if (item_equal)
+ {
+ DBUG_ASSERT(real_item()->type() == Item::FIELD_ITEM);
+ return (find_matching_field_pair(this, sel->grouping_tmp_fields) != NULL);
+ }
+ return (*ref)->excl_dep_on_grouping_fields(sel);
+}
+
+
+bool Item_args::excl_dep_on_grouping_fields(st_select_lex *sel)
+{
+ for (uint i= 0; i < arg_count; i++)
+ {
+ if (args[i]->type() == Item::FUNC_ITEM &&
+ ((Item_func *)args[i])->functype() == Item_func::UDF_FUNC)
+ return false;
+ if (args[i]->const_item())
+ continue;
+ if (!args[i]->excl_dep_on_grouping_fields(sel))
+ return false;
+ }
+ return true;
+}
+
+
+double Item_direct_view_ref::val_result()
+{
+ double tmp=(*ref)->val_result();
+ null_value=(*ref)->null_value;
+ return tmp;
+}
+
+
+longlong Item_direct_view_ref::val_int_result()
+{
+ longlong tmp=(*ref)->val_int_result();
+ null_value=(*ref)->null_value;
+ return tmp;
+}
+
+
+String *Item_direct_view_ref::str_result(String* tmp)
+{
+ tmp=(*ref)->str_result(tmp);
+ null_value=(*ref)->null_value;
+ return tmp;
+}
+
+
+my_decimal *Item_direct_view_ref::val_decimal_result(my_decimal *val)
+{
+ my_decimal *tmp= (*ref)->val_decimal_result(val);
+ null_value=(*ref)->null_value;
+ return tmp;
+}
+
+
+bool Item_direct_view_ref::val_bool_result()
+{
+ bool tmp= (*ref)->val_bool_result();
+ null_value=(*ref)->null_value;
+ return tmp;
+}
+
+
+bool Item_default_value::eq(const Item *item, bool binary_cmp) const
+{
+ return item->type() == DEFAULT_VALUE_ITEM &&
+ ((Item_default_value *)item)->arg->eq(arg, binary_cmp);
+}
+
+
+bool Item_default_value::fix_fields(THD *thd, Item **items)
+{
+ Item *real_arg;
+ Item_field *field_arg;
+ Field *def_field;
+ DBUG_ASSERT(fixed == 0);
+ DBUG_ASSERT(arg);
+
+ /*
+ DEFAULT() do not need table field so should not ask handler to bring
+ field value (mark column for read)
+ */
+ enum_column_usage save_column_usage= thd->column_usage;
+ /*
+ Fields which has defult value could be read, so it is better hide system
+ invisible columns.
+ */
+ thd->column_usage= COLUMNS_WRITE;
+ if (arg->fix_fields_if_needed(thd, &arg))
+ {
+ thd->column_usage= save_column_usage;
+ goto error;
+ }
+ thd->column_usage= save_column_usage;
+
+ real_arg= arg->real_item();
+ if (real_arg->type() != FIELD_ITEM)
+ {
+ my_error(ER_NO_DEFAULT_FOR_FIELD, MYF(0), arg->name.str);
+ goto error;
+ }
+
+ field_arg= (Item_field *)real_arg;
+ if ((field_arg->field->flags & NO_DEFAULT_VALUE_FLAG))
+ {
+ my_error(ER_NO_DEFAULT_FOR_FIELD, MYF(0),
+ field_arg->field->field_name.str);
+ goto error;
+ }
+ if (!(def_field= (Field*) thd->alloc(field_arg->field->size_of())))
+ goto error;
+ cached_field= def_field;
+ memcpy((void *)def_field, (void *)field_arg->field,
+ field_arg->field->size_of());
+ def_field->reset_fields();
+ // If non-constant default value expression or a blob
+ if (def_field->default_value &&
+ (def_field->default_value->flags || (def_field->flags & BLOB_FLAG)))
+ {
+ uchar *newptr= (uchar*) thd->alloc(1+def_field->pack_length());
+ if (!newptr)
+ goto error;
+ /*
+ Even if DEFAULT() do not read tables fields, the default value
+ expression can do it.
+ */
+ fix_session_vcol_expr_for_read(thd, def_field, def_field->default_value);
+ if (should_mark_column(thd->column_usage))
+ def_field->default_value->expr->update_used_tables();
+ def_field->move_field(newptr+1, def_field->maybe_null() ? newptr : 0, 1);
+ }
+ else
+ def_field->move_field_offset((my_ptrdiff_t)
+ (def_field->table->s->default_values -
+ def_field->table->record[0]));
+ set_field(def_field);
+ return FALSE;
+
+error:
+ context->process_error(thd);
+ return TRUE;
+}
+
+void Item_default_value::cleanup()
+{
+ delete cached_field; // Free cached blob data
+ cached_field= 0;
+ Item_field::cleanup();
+}
+
+void Item_default_value::print(String *str, enum_query_type query_type)
+{
+ DBUG_ASSERT(arg);
+ str->append(STRING_WITH_LEN("default("));
+ /*
+ We take DEFAULT from a field so do not need it value in case of const
+ tables but its name so we set QT_NO_DATA_EXPANSION (as we print for
+ table definition, also we do not need table and database name)
+ */
+ query_type= (enum_query_type) (query_type | QT_NO_DATA_EXPANSION);
+ arg->print(str, query_type);
+ str->append(')');
+}
+
+void Item_default_value::calculate()
+{
+ DBUG_ASSERT(arg);
+ if (field->default_value)
+ field->set_default();
+ DEBUG_SYNC(field->table->in_use, "after_Item_default_value_calculate");
+}
+
+bool Item_default_value::val_native(THD *thd, Native *to)
+{
+ calculate();
+ return Item_field::val_native(thd, to);
+}
+
+String *Item_default_value::val_str(String *str)
+{
+ calculate();
+ return Item_field::val_str(str);
+}
+
+double Item_default_value::val_real()
+{
+ calculate();
+ return Item_field::val_real();
+}
+
+longlong Item_default_value::val_int()
+{
+ calculate();
+ return Item_field::val_int();
+}
+
+my_decimal *Item_default_value::val_decimal(my_decimal *decimal_value)
+{
+ calculate();
+ return Item_field::val_decimal(decimal_value);
+}
+
+bool Item_default_value::get_date(THD *thd, MYSQL_TIME *ltime,
+ date_mode_t fuzzydate)
+{
+ calculate();
+ return Item_field::get_date(thd, ltime, fuzzydate);
+}
+
+bool Item_default_value::send(Protocol *protocol, st_value *buffer)
+{
+ calculate();
+ return Item_field::send(protocol, buffer);
+}
+
+int Item_default_value::save_in_field(Field *field_arg, bool no_conversions)
+{
+ calculate();
+ return Item_field::save_in_field(field_arg, no_conversions);
+}
+
+double Item_default_value::val_result()
+{
+ calculate();
+ return Item_field::val_result();
+}
+
+longlong Item_default_value::val_int_result()
+{
+ calculate();
+ return Item_field::val_int_result();
+}
+
+String *Item_default_value::str_result(String* tmp)
+{
+ calculate();
+ return Item_field::str_result(tmp);
+}
+
+bool Item_default_value::val_bool_result()
+{
+ calculate();
+ return Item_field::val_bool_result();
+}
+
+bool Item_default_value::is_null_result()
+{
+ calculate();
+ return Item_field::is_null_result();
+}
+
+my_decimal *Item_default_value::val_decimal_result(my_decimal *decimal_value)
+{
+ calculate();
+ return Item_field::val_decimal_result(decimal_value);
+}
+
+bool Item_default_value::get_date_result(THD *thd, MYSQL_TIME *ltime,
+ date_mode_t fuzzydate)
+{
+ calculate();
+ return Item_field::get_date_result(thd, ltime, fuzzydate);
+}
+
+bool Item_default_value::val_native_result(THD *thd, Native *to)
+{
+ calculate();
+ return Item_field::val_native_result(thd, to);
+}
+
+table_map Item_default_value::used_tables() const
+{
+ if (!field || !field->default_value)
+ return static_cast<table_map>(0);
+ if (!field->default_value->expr) // not fully parsed field
+ return static_cast<table_map>(RAND_TABLE_BIT);
+ return field->default_value->expr->used_tables();
+}
+
+/**
+ This method like the walk method traverses the item tree, but at the
+ same time it can replace some nodes in the tree.
+*/
+
+Item *Item_default_value::transform(THD *thd, Item_transformer transformer,
+ uchar *args)
+{
+ DBUG_ASSERT(!thd->stmt_arena->is_stmt_prepare());
+ DBUG_ASSERT(arg);
+
+ Item *new_item= arg->transform(thd, transformer, args);
+ if (!new_item)
+ return 0;
+
+ /*
+ THD::change_item_tree() should be called only if the tree was
+ really transformed, i.e. when a new item has been created.
+ Otherwise we'll be allocating a lot of unnecessary memory for
+ change records at each execution.
+ */
+ if (arg != new_item)
+ thd->change_item_tree(&arg, new_item);
+ return (this->*transformer)(thd, args);
+}
+
+
+bool Item_insert_value::eq(const Item *item, bool binary_cmp) const
+{
+ return item->type() == INSERT_VALUE_ITEM &&
+ ((Item_insert_value *)item)->arg->eq(arg, binary_cmp);
+}
+
+
+bool Item_insert_value::fix_fields(THD *thd, Item **items)
+{
+ DBUG_ASSERT(fixed == 0);
+ /* We should only check that arg is in first table */
+ if (!arg->is_fixed())
+ {
+ bool res;
+ TABLE_LIST *orig_next_table= context->last_name_resolution_table;
+ context->last_name_resolution_table= context->first_name_resolution_table;
+ res= arg->fix_fields(thd, &arg);
+ context->last_name_resolution_table= orig_next_table;
+ if (res)
+ return TRUE;
+ }
+
+ if (arg->type() == REF_ITEM)
+ arg= static_cast<Item_ref *>(arg)->ref[0];
+ if (unlikely(arg->type() != FIELD_ITEM))
+ {
+ my_error(ER_BAD_FIELD_ERROR, MYF(0), "", "VALUES() function");
+ return TRUE;
+ }
+
+ Item_field *field_arg= (Item_field *)arg;
+
+ if (field_arg->field->table->insert_values)
+ {
+ Field *def_field= (Field*) thd->alloc(field_arg->field->size_of());
+ if (!def_field)
+ return TRUE;
+ memcpy((void *)def_field, (void *)field_arg->field,
+ field_arg->field->size_of());
+ def_field->move_field_offset((my_ptrdiff_t)
+ (def_field->table->insert_values -
+ def_field->table->record[0]));
+ set_field(def_field);
+ }
+ else
+ {
+ static uchar null_bit=1;
+ /* charset doesn't matter here */
+ Field *tmp_field= new Field_string(0, 0, &null_bit, 1, Field::NONE,
+ &field_arg->field->field_name, &my_charset_bin);
+ if (tmp_field)
+ {
+ tmp_field->init(field_arg->field->table);
+ set_field(tmp_field);
+ // the index is important when read bits set
+ tmp_field->field_index= field_arg->field->field_index;
+ }
+ }
+ return FALSE;
+}
+
+void Item_insert_value::print(String *str, enum_query_type query_type)
+{
+ str->append(STRING_WITH_LEN("value("));
+ arg->print(str, query_type);
+ str->append(')');
+}
+
+
+/**
+ Find index of Field object which will be appropriate for item
+ representing field of row being changed in trigger.
+
+ @param thd current thread context
+ @param table table of trigger (and where we looking for fields)
+ @param table_grant_info GRANT_INFO of the subject table
+
+ @note
+ This function does almost the same as fix_fields() for Item_field
+ but is invoked right after trigger definition parsing. Since at
+ this stage we can't say exactly what Field object (corresponding
+ to TABLE::record[0] or TABLE::record[1]) should be bound to this
+ Item, we only find out index of the Field and then select concrete
+ Field object in fix_fields() (by that time Table_triggers_list::old_field/
+ new_field should point to proper array of Fields).
+ It also binds Item_trigger_field to Table_triggers_list object for
+ table of trigger which uses this item.
+*/
+
+void Item_trigger_field::setup_field(THD *thd, TABLE *table,
+ GRANT_INFO *table_grant_info)
+{
+ /*
+ It is too early to mark fields used here, because before execution
+ of statement that will invoke trigger other statements may use same
+ TABLE object, so all such mark-up will be wiped out.
+ So instead we do it in Table_triggers_list::mark_fields_used()
+ method which is called during execution of these statements.
+ */
+ enum_column_usage saved_column_usage= thd->column_usage;
+ thd->column_usage= want_privilege == SELECT_ACL ? COLUMNS_READ
+ : COLUMNS_WRITE;
+ /*
+ Try to find field by its name and if it will be found
+ set field_idx properly.
+ */
+ (void)find_field_in_table(thd, table, field_name.str, field_name.length,
+ 0, &field_idx);
+ thd->column_usage= saved_column_usage;
+ triggers= table->triggers;
+ table_grants= table_grant_info;
+}
+
+
+bool Item_trigger_field::eq(const Item *item, bool binary_cmp) const
+{
+ return item->type() == TRIGGER_FIELD_ITEM &&
+ row_version == ((Item_trigger_field *)item)->row_version &&
+ !lex_string_cmp(system_charset_info, &field_name,
+ &((Item_trigger_field *)item)->field_name);
+}
+
+
+void Item_trigger_field::set_required_privilege(bool rw)
+{
+ /*
+ Require SELECT and UPDATE privilege if this field will be read and
+ set, and only UPDATE privilege for setting the field.
+ */
+ want_privilege= (rw ? SELECT_ACL | UPDATE_ACL : UPDATE_ACL);
+}
+
+
+bool Item_trigger_field::set_value(THD *thd, sp_rcontext * /*ctx*/, Item **it)
+{
+ Item *item= thd->sp_prepare_func_item(it);
+
+ if (!item || fix_fields_if_needed(thd, NULL))
+ return true;
+
+ // NOTE: field->table->copy_blobs should be false here, but let's
+ // remember the value at runtime to avoid subtle bugs.
+ bool copy_blobs_saved= field->table->copy_blobs;
+
+ field->table->copy_blobs= true;
+
+ int err_code= item->save_in_field(field, 0);
+
+ field->table->copy_blobs= copy_blobs_saved;
+ field->set_has_explicit_value();
+
+ return err_code < 0;
+}
+
+
+bool Item_trigger_field::fix_fields(THD *thd, Item **items)
+{
+ /*
+ Since trigger is object tightly associated with TABLE object most
+ of its set up can be performed during trigger loading i.e. trigger
+ parsing! So we have little to do in fix_fields. :)
+ */
+
+ DBUG_ASSERT(fixed == 0);
+
+ /* Set field. */
+
+ if (likely(field_idx != (uint)-1))
+ {
+#ifndef NO_EMBEDDED_ACCESS_CHECKS
+ /*
+ Check access privileges for the subject table. We check privileges only
+ in runtime.
+ */
+
+ if (table_grants)
+ {
+ table_grants->want_privilege= want_privilege;
+
+ if (check_grant_column(thd, table_grants,
+ triggers->trigger_table->s->db.str,
+ triggers->trigger_table->s->table_name.str,
+ field_name.str, field_name.length,
+ thd->security_ctx))
+ return TRUE;
+ }
+#endif // NO_EMBEDDED_ACCESS_CHECKS
+
+ field= (row_version == OLD_ROW) ? triggers->old_field[field_idx] :
+ triggers->new_field[field_idx];
+ set_field(field);
+ fixed= 1;
+ return FALSE;
+ }
+
+ my_error(ER_BAD_FIELD_ERROR, MYF(0), field_name.str,
+ (row_version == NEW_ROW) ? "NEW" : "OLD");
+ return TRUE;
+}
+
+
+void Item_trigger_field::print(String *str, enum_query_type query_type)
+{
+ str->append((row_version == NEW_ROW) ? "NEW" : "OLD", 3);
+ str->append('.');
+ str->append(&field_name);
+}
+
+
+bool Item_trigger_field::check_vcol_func_processor(void *arg)
+{
+ const char *ver= row_version == NEW_ROW ? "NEW." : "OLD.";
+ return mark_unsupported_function(ver, field_name.str, arg, VCOL_IMPOSSIBLE);
+}
+
+
+void Item_trigger_field::cleanup()
+{
+ want_privilege= original_privilege;
+ /*
+ Since special nature of Item_trigger_field we should not do most of
+ things from Item_field::cleanup() or Item_ident::cleanup() here.
+ */
+ Item_fixed_hybrid::cleanup();
+}
+
+
+Item_result item_cmp_type(Item_result a,Item_result b)
+{
+ if (a == b)
+ return a;
+ if (a == ROW_RESULT || b == ROW_RESULT)
+ return ROW_RESULT;
+ if (a == TIME_RESULT || b == TIME_RESULT)
+ return TIME_RESULT;
+ if ((a == INT_RESULT || a == DECIMAL_RESULT) &&
+ (b == INT_RESULT || b == DECIMAL_RESULT))
+ return DECIMAL_RESULT;
+ return REAL_RESULT;
+}
+
+
+void resolve_const_item(THD *thd, Item **ref, Item *comp_item)
+{
+ Item *item= *ref;
+ if (item->basic_const_item())
+ return; // Can't be better
+ Type_handler_hybrid_field_type cmp(comp_item->type_handler_for_comparison());
+ if (!cmp.aggregate_for_comparison(item->type_handler_for_comparison()))
+ {
+ Item *new_item= cmp.type_handler()->
+ make_const_item_for_comparison(thd, item, comp_item);
+ if (new_item)
+ thd->change_item_tree(ref, new_item);
+ }
+}
+
+/**
+ Compare the value stored in field with the expression from the query.
+
+ @param field Field which the Item is stored in after conversion
+ @param item Original expression from query
+
+ @return Returns an integer greater than, equal to, or less than 0 if
+ the value stored in the field is greater than, equal to,
+ or less than the original Item. A 0 may also be returned if
+ out of memory.
+
+ @note We use this in the range optimizer/partition pruning,
+ because in some cases we can't store the value in the field
+ without some precision/character loss.
+
+ We similarly use it to verify that expressions like
+ BIGINT_FIELD <cmp> <literal value>
+ is done correctly (as int/decimal/float according to literal type).
+
+ @todo rewrite it to use Arg_comparator (currently it's a simplified and
+ incomplete version of it)
+*/
+
+int stored_field_cmp_to_item(THD *thd, Field *field, Item *item)
+{
+ Type_handler_hybrid_field_type cmp(field->type_handler_for_comparison());
+ if (cmp.aggregate_for_comparison(item->type_handler_for_comparison()))
+ {
+ // At fix_fields() time we checked that "field" and "item" are comparable
+ DBUG_ASSERT(0);
+ return 0;
+ }
+ return cmp.type_handler()->stored_field_cmp_to_item(thd, field, item);
+}
+
+
+void Item_cache::store(Item *item)
+{
+ example= item;
+ if (!item)
+ null_value= TRUE;
+ value_cached= FALSE;
+}
+
+void Item_cache::print(String *str, enum_query_type query_type)
+{
+ if (example && // There is a cached item
+ (query_type & QT_NO_DATA_EXPANSION)) // Caller is show-create-table
+ {
+ // Instead of "cache" or the cached value, print the cached item name
+ example->print(str, query_type);
+ return;
+ }
+
+ if (value_cached)
+ {
+ print_value(str);
+ return;
+ }
+ str->append(STRING_WITH_LEN("<cache>("));
+ if (example)
+ example->print(str, query_type);
+ else
+ Item::print(str, query_type);
+ str->append(')');
+}
+
+/**
+ Assign to this cache NULL value if it is possible
+*/
+
+void Item_cache::set_null()
+{
+ if (maybe_null)
+ {
+ null_value= TRUE;
+ value_cached= TRUE;
+ }
+}
+
+
+bool Item_cache_int::cache_value()
+{
+ if (!example)
+ return FALSE;
+ value_cached= TRUE;
+ value= example->val_int_result();
+ null_value_inside= null_value= example->null_value;
+ unsigned_flag= example->unsigned_flag;
+ return TRUE;
+}
+
+
+String *Item_cache_int::val_str(String *str)
+{
+ if (!has_value())
+ return NULL;
+ str->set_int(value, unsigned_flag, default_charset());
+ return str;
+}
+
+
+my_decimal *Item_cache_int::val_decimal(my_decimal *decimal_val)
+{
+ if (!has_value())
+ return NULL;
+ int2my_decimal(E_DEC_FATAL_ERROR, value, unsigned_flag, decimal_val);
+ return decimal_val;
+}
+
+double Item_cache_int::val_real()
+{
+ if (!has_value())
+ return 0.0;
+ return (double) value;
+}
+
+longlong Item_cache_int::val_int()
+{
+ if (!has_value())
+ return 0;
+ return value;
+}
+
+int Item_cache_int::save_in_field(Field *field, bool no_conversions)
+{
+ int error;
+ if (!has_value())
+ return set_field_to_null_with_conversions(field, no_conversions);
+
+ field->set_notnull();
+ error= field->store(value, unsigned_flag);
+
+ return error ? error : field->table->in_use->is_error() ? 1 : 0;
+}
+
+
+Item *Item_cache_int::convert_to_basic_const_item(THD *thd)
+{
+ Item *new_item;
+ DBUG_ASSERT(value_cached || example != 0);
+ if (!value_cached)
+ cache_value();
+ new_item= null_value ?
+ (Item*) new (thd->mem_root) Item_null(thd) :
+ (Item*) new (thd->mem_root) Item_int(thd, val_int(), max_length);
+ return new_item;
+}
+
+
+Item_cache_temporal::Item_cache_temporal(THD *thd, const Type_handler *handler)
+ :Item_cache_int(thd, handler)
+{
+ if (mysql_timestamp_type() == MYSQL_TIMESTAMP_ERROR)
+ set_handler(&type_handler_datetime2);
+}
+
+
+bool Item_cache_temporal::cache_value()
+{
+ if (!example)
+ return false;
+ value_cached= true;
+ value= example->val_datetime_packed_result(current_thd);
+ null_value_inside= null_value= example->null_value;
+ return true;
+}
+
+
+bool Item_cache_time::cache_value()
+{
+ if (!example)
+ return false;
+ value_cached= true;
+ value= example->val_time_packed_result(current_thd);
+ null_value_inside= null_value= example->null_value;
+ return true;
+}
+
+
+bool Item_cache_temporal::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+{
+ if (!has_value())
+ {
+ bzero((char*) ltime,sizeof(*ltime));
+ return (null_value= true);
+ }
+
+ unpack_time(value, ltime, mysql_timestamp_type());
+ return 0;
+}
+
+
+int Item_cache_temporal::save_in_field(Field *field, bool no_conversions)
+{
+ MYSQL_TIME ltime;
+ // This is a temporal type. No nanoseconds, so round mode is not important.
+ if (get_date(field->get_thd(), &ltime, TIME_CONV_NONE | TIME_FRAC_NONE))
+ return set_field_to_null_with_conversions(field, no_conversions);
+ field->set_notnull();
+ int error= field->store_time_dec(&ltime, decimals);
+ return error ? error : field->table->in_use->is_error() ? 1 : 0;
+}
+
+
+void Item_cache_temporal::store_packed(longlong val_arg, Item *example_arg)
+{
+ /* An explicit value is given, save it. */
+ store(example_arg);
+ value_cached= true;
+ value= val_arg;
+ null_value= false;
+}
+
+
+Item *Item_cache_temporal::clone_item(THD *thd)
+{
+ Item_cache *tmp= type_handler()->Item_get_cache(thd, this);
+ Item_cache_temporal *item= static_cast<Item_cache_temporal*>(tmp);
+ item->store_packed(value, example);
+ return item;
+}
+
+
+Item *Item_cache_temporal::convert_to_basic_const_item(THD *thd)
+{
+ DBUG_ASSERT(value_cached || example != 0);
+ if (!value_cached)
+ cache_value();
+ if (null_value)
+ return new (thd->mem_root) Item_null(thd);
+ return make_literal(thd);
+}
+
+Item *Item_cache_datetime::make_literal(THD *thd)
+{
+ Datetime dt(thd, this, TIME_CONV_NONE | TIME_FRAC_NONE);
+ return new (thd->mem_root) Item_datetime_literal(thd, &dt, decimals);
+}
+
+Item *Item_cache_date::make_literal(THD *thd)
+{
+ Date d(thd, this, TIME_CONV_NONE | TIME_FRAC_NONE);
+ return new (thd->mem_root) Item_date_literal(thd, &d);
+}
+
+Item *Item_cache_time::make_literal(THD *thd)
+{
+ Time t(thd, this);
+ return new (thd->mem_root) Item_time_literal(thd, &t, decimals);
+}
+
+
+int Item_cache_timestamp::save_in_field(Field *field, bool no_conversions)
+{
+ if (!has_value())
+ return set_field_to_null_with_conversions(field, no_conversions);
+ return m_native.save_in_field(field, decimals);
+}
+
+
+bool Item_cache_timestamp::val_native(THD *thd, Native *to)
+{
+ if (!has_value())
+ {
+ null_value= true;
+ return true;
+ }
+ return null_value= to->copy(m_native);
+}
+
+
+Datetime Item_cache_timestamp::to_datetime(THD *thd)
+{
+ DBUG_ASSERT(is_fixed() == 1);
+ if (!has_value())
+ {
+ null_value= true;
+ return Datetime();
+ }
+ return m_native.to_datetime(thd);
+}
+
+
+bool Item_cache_timestamp::get_date(THD *thd, MYSQL_TIME *ltime,
+ date_mode_t fuzzydate)
+{
+ if (!has_value())
+ {
+ set_zero_time(ltime, MYSQL_TIMESTAMP_DATETIME);
+ return true;
+ }
+ Timestamp_or_zero_datetime tm(m_native);
+ return (null_value= tm.to_TIME(thd, ltime, fuzzydate));
+}
+
+
+bool Item_cache_timestamp::cache_value()
+{
+ if (!example)
+ return false;
+ value_cached= true;
+ null_value= example->val_native_with_conversion_result(current_thd, &m_native,
+ type_handler());
+ return true;
+}
+
+
+bool Item_cache_real::cache_value()
+{
+ if (!example)
+ return FALSE;
+ value_cached= TRUE;
+ value= example->val_result();
+ null_value_inside= null_value= example->null_value;
+ return TRUE;
+}
+
+
+double Item_cache_real::val_real()
+{
+ if (!has_value())
+ return 0.0;
+ return value;
+}
+
+longlong Item_cache_real::val_int()
+{
+ if (!has_value())
+ return 0;
+ return Converter_double_to_longlong(value, unsigned_flag).result();
+}
+
+
+String* Item_cache_double::val_str(String *str)
+{
+ if (!has_value())
+ return NULL;
+ str->set_real(value, decimals, default_charset());
+ return str;
+}
+
+
+String* Item_cache_float::val_str(String *str)
+{
+ if (!has_value())
+ return NULL;
+ Float(value).to_string(str, decimals);
+ return str;
+}
+
+
+my_decimal *Item_cache_real::val_decimal(my_decimal *decimal_val)
+{
+ if (!has_value())
+ return NULL;
+ double2my_decimal(E_DEC_FATAL_ERROR, value, decimal_val);
+ return decimal_val;
+}
+
+
+Item *Item_cache_real::convert_to_basic_const_item(THD *thd)
+{
+ Item *new_item;
+ DBUG_ASSERT(value_cached || example != 0);
+ if (!value_cached)
+ cache_value();
+ new_item= null_value ?
+ (Item*) new (thd->mem_root) Item_null(thd) :
+ (Item*) new (thd->mem_root) Item_float(thd, val_real(),
+ decimals);
+ return new_item;
+}
+
+
+bool Item_cache_decimal::cache_value()
+{
+ if (!example)
+ return FALSE;
+ value_cached= TRUE;
+ my_decimal *val= example->val_decimal_result(&decimal_value);
+ if (!(null_value_inside= null_value= example->null_value) &&
+ val != &decimal_value)
+ my_decimal2decimal(val, &decimal_value);
+ return TRUE;
+}
+
+double Item_cache_decimal::val_real()
+{
+ return !has_value() ? 0.0 : decimal_value.to_double();
+}
+
+longlong Item_cache_decimal::val_int()
+{
+ return !has_value() ? 0 : decimal_value.to_longlong(unsigned_flag);
+}
+
+String* Item_cache_decimal::val_str(String *str)
+{
+ return !has_value() ? NULL :
+ decimal_value.to_string_round(str, decimals, &decimal_value);
+}
+
+my_decimal *Item_cache_decimal::val_decimal(my_decimal *val)
+{
+ if (!has_value())
+ return NULL;
+ return &decimal_value;
+}
+
+
+Item *Item_cache_decimal::convert_to_basic_const_item(THD *thd)
+{
+ Item *new_item;
+ DBUG_ASSERT(value_cached || example != 0);
+ if (!value_cached)
+ cache_value();
+ if (null_value)
+ new_item= (Item*) new (thd->mem_root) Item_null(thd);
+ else
+ {
+ VDec tmp(this);
+ new_item= (Item*) new (thd->mem_root) Item_decimal(thd, tmp.ptr());
+ }
+ return new_item;
+}
+
+
+bool Item_cache_str::cache_value()
+{
+ if (!example)
+ {
+ DBUG_ASSERT(value_cached == FALSE);
+ return FALSE;
+ }
+ value_cached= TRUE;
+ value_buff.set(buffer, sizeof(buffer), example->collation.collation);
+ value= example->str_result(&value_buff);
+ if ((null_value= null_value_inside= example->null_value))
+ value= 0;
+ else if (value != &value_buff)
+ {
+ /*
+ We copy string value to avoid changing value if 'item' is table field
+ in queries like following (where t1.c is varchar):
+ select a,
+ (select a,b,c from t1 where t1.a=t2.a) = ROW(a,2,'a'),
+ (select c from t1 where a=t2.a)
+ from t2;
+ */
+ value_buff.copy(*value);
+ value= &value_buff;
+ }
+ else
+ value_buff.copy();
+ return TRUE;
+}
+
+double Item_cache_str::val_real()
+{
+ if (!has_value())
+ return 0.0;
+ return value ? double_from_string_with_check(value) : 0.0;
+}
+
+
+longlong Item_cache_str::val_int()
+{
+ if (!has_value())
+ return 0;
+ return value ? longlong_from_string_with_check(value) : 0;
+}
+
+
+String* Item_cache_str::val_str(String *str)
+{
+ if (!has_value())
+ return 0;
+ return value;
+}
+
+
+my_decimal *Item_cache_str::val_decimal(my_decimal *decimal_val)
+{
+ if (!has_value())
+ return NULL;
+ return value ? decimal_from_string_with_check(decimal_val, value) : 0;
+}
+
+
+int Item_cache_str::save_in_field(Field *field, bool no_conversions)
+{
+ if (!has_value())
+ return set_field_to_null_with_conversions(field, no_conversions);
+ int res= Item_cache::save_in_field(field, no_conversions);
+ return (is_varbinary && field->type() == MYSQL_TYPE_STRING &&
+ value->length() < field->field_length) ? 1 : res;
+}
+
+
+bool Item_cache_row::allocate(THD *thd, uint num)
+{
+ item_count= num;
+ return (!(values=
+ (Item_cache **) thd->calloc(sizeof(Item_cache *)*item_count)));
+}
+
+
+Item *Item_cache_str::convert_to_basic_const_item(THD *thd)
+{
+ Item *new_item;
+ DBUG_ASSERT(value_cached || example != 0);
+ if (!value_cached)
+ cache_value();
+ if (null_value)
+ new_item= (Item*) new (thd->mem_root) Item_null(thd);
+ else
+ {
+ char buff[MAX_FIELD_WIDTH];
+ String tmp(buff, sizeof(buff), value->charset());
+ String *result= val_str(&tmp);
+ uint length= result->length();
+ char *tmp_str= thd->strmake(result->ptr(), length);
+ new_item= new (thd->mem_root) Item_string(thd, tmp_str, length,
+ result->charset());
+ }
+ return new_item;
+}
+
+
+bool Item_cache_row::setup(THD *thd, Item *item)
+{
+ example= item;
+ null_value= true;
+
+ if (!values && allocate(thd, item->cols()))
+ return 1;
+ for (uint i= 0; i < item_count; i++)
+ {
+ Item_cache *tmp;
+ Item *el= item->element_index(i);
+ if (!(tmp= values[i]= el->get_cache(thd)))
+ return 1;
+ tmp->setup(thd, el);
+ }
+ return 0;
+}
+
+
+void Item_cache_row::store(Item * item)
+{
+ example= item;
+ if (!item)
+ {
+ null_value= TRUE;
+ return;
+ }
+ for (uint i= 0; i < item_count; i++)
+ values[i]->store(item->element_index(i));
+}
+
+
+bool Item_cache_row::cache_value()
+{
+ if (!example)
+ return FALSE;
+ value_cached= TRUE;
+ null_value= TRUE;
+ null_value_inside= false;
+ example->bring_value();
+
+ /*
+ For Item_cache_row null_value is set to TRUE only when ALL the values
+ inside the cache are NULL
+ */
+ for (uint i= 0; i < item_count; i++)
+ {
+ values[i]->cache_value();
+ null_value&= values[i]->null_value;
+ null_value_inside|= values[i]->null_value;
+ }
+ return TRUE;
+}
+
+
+void Item_cache_row::illegal_method_call(const char *method)
+{
+ DBUG_ENTER("Item_cache_row::illegal_method_call");
+ DBUG_PRINT("error", ("!!! %s method was called for row item", method));
+ DBUG_ASSERT(0);
+ my_error(ER_OPERAND_COLUMNS, MYF(0), 1);
+ DBUG_VOID_RETURN;
+}
+
+
+bool Item_cache_row::check_cols(uint c)
+{
+ if (c != item_count)
+ {
+ my_error(ER_OPERAND_COLUMNS, MYF(0), c);
+ return 1;
+ }
+ return 0;
+}
+
+
+bool Item_cache_row::null_inside()
+{
+ for (uint i= 0; i < item_count; i++)
+ {
+ if (values[i]->cols() > 1)
+ {
+ if (values[i]->null_inside())
+ return 1;
+ }
+ else
+ {
+ values[i]->update_null_value();
+ if (values[i]->null_value)
+ return 1;
+ }
+ }
+ return 0;
+}
+
+
+void Item_cache_row::bring_value()
+{
+ if (!example)
+ return;
+ example->bring_value();
+ null_value= example->null_value;
+ for (uint i= 0; i < item_count; i++)
+ values[i]->bring_value();
+}
+
+
+/**
+ Assign to this cache NULL value if it is possible
+*/
+
+void Item_cache_row::set_null()
+{
+ Item_cache::set_null();
+ if (!values)
+ return;
+ for (uint i= 0; i < item_count; i++)
+ values[i]->set_null();
+};
+
+
+double Item_type_holder::val_real()
+{
+ DBUG_ASSERT(0); // should never be called
+ return 0.0;
+}
+
+
+longlong Item_type_holder::val_int()
+{
+ DBUG_ASSERT(0); // should never be called
+ return 0;
+}
+
+my_decimal *Item_type_holder::val_decimal(my_decimal *)
+{
+ DBUG_ASSERT(0); // should never be called
+ return 0;
+}
+
+String *Item_type_holder::val_str(String*)
+{
+ DBUG_ASSERT(0); // should never be called
+ return 0;
+}
+
+bool Item_type_holder::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+{
+ DBUG_ASSERT(0); // should never be called
+ return true;
+}
+
+void Item_result_field::cleanup()
+{
+ DBUG_ENTER("Item_result_field::cleanup()");
+ Item_fixed_hybrid::cleanup();
+ result_field= 0;
+ DBUG_VOID_RETURN;
+}
+
+/**
+ Dummy error processor used by default by Name_resolution_context.
+
+ @note
+ do nothing
+*/
+
+void dummy_error_processor(THD *thd, void *data)
+{}
+
+/**
+ Wrapper of hide_view_error call for Name_resolution_context error
+ processor.
+
+ @note
+ hide view underlying tables details in error messages
+*/
+
+void view_error_processor(THD *thd, void *data)
+{
+ ((TABLE_LIST *)data)->hide_view_error(thd);
+}
+
+
+st_select_lex *Item_ident::get_depended_from() const
+{
+ st_select_lex *dep;
+ if ((dep= depended_from))
+ for ( ; dep->merged_into; dep= dep->merged_into) ;
+ return dep;
+}
+
+
+table_map Item_ref::used_tables() const
+{
+ return get_depended_from() ? OUTER_REF_TABLE_BIT : (*ref)->used_tables();
+}
+
+
+void Item_ref::update_used_tables()
+{
+ if (!get_depended_from())
+ (*ref)->update_used_tables();
+}
+
+void Item_direct_view_ref::update_used_tables()
+{
+ set_null_ref_table();
+ Item_direct_ref::update_used_tables();
+}
+
+
+table_map Item_direct_view_ref::used_tables() const
+{
+ DBUG_ASSERT(fixed);
+
+ if (get_depended_from())
+ return OUTER_REF_TABLE_BIT;
+
+ if (view->is_merged_derived() || view->merged || !view->table)
+ {
+ table_map used= (*ref)->used_tables();
+ return (used ?
+ used :
+ ((null_ref_table != NO_NULL_TABLE) ?
+ null_ref_table->map :
+ (table_map)0 ));
+ }
+ return view->table->map;
+}
+
+table_map Item_direct_view_ref::not_null_tables() const
+{
+ if (get_depended_from())
+ return 0;
+ if (!( view->merged || !view->table))
+ return view->table->map;
+ TABLE *tab= get_null_ref_table();
+ if (tab == NO_NULL_TABLE || (*ref)->used_tables())
+ return (*ref)->not_null_tables();
+ return get_null_ref_table()->map;
+}
+
+/*
+ we add RAND_TABLE_BIT to prevent moving this item from HAVING to WHERE
+*/
+table_map Item_ref_null_helper::used_tables() const
+{
+ return (get_depended_from() ?
+ OUTER_REF_TABLE_BIT :
+ (*ref)->used_tables() | RAND_TABLE_BIT);
+}
+
+
+#ifndef DBUG_OFF
+
+/* Debugger help function */
+static char dbug_item_print_buf[2048];
+
+const char *dbug_print_item(Item *item)
+{
+ char *buf= dbug_item_print_buf;
+ String str(buf, sizeof(dbug_item_print_buf), &my_charset_bin);
+ str.length(0);
+ if (!item)
+ return "(Item*)NULL";
+
+ THD *thd= current_thd;
+ ulonglong save_option_bits= thd->variables.option_bits;
+ thd->variables.option_bits &= ~OPTION_QUOTE_SHOW_CREATE;
+
+ item->print(&str, QT_EXPLAIN);
+
+ thd->variables.option_bits= save_option_bits;
+
+ if (str.c_ptr_safe() == buf)
+ return buf;
+ else
+ return "Couldn't fit into buffer";
+}
+
+const char *dbug_print_select(SELECT_LEX *sl)
+{
+ char *buf= dbug_item_print_buf;
+ String str(buf, sizeof(dbug_item_print_buf), &my_charset_bin);
+ str.length(0);
+ if (!sl)
+ return "(SELECT_LEX*)NULL";
+
+ THD *thd= current_thd;
+ ulonglong save_option_bits= thd->variables.option_bits;
+ thd->variables.option_bits &= ~OPTION_QUOTE_SHOW_CREATE;
+
+ sl->print(thd, &str, QT_EXPLAIN);
+
+ thd->variables.option_bits= save_option_bits;
+
+ if (str.c_ptr() == buf)
+ return buf;
+ else
+ return "Couldn't fit into buffer";
+}
+
+const char *dbug_print_unit(SELECT_LEX_UNIT *un)
+{
+ char *buf= dbug_item_print_buf;
+ String str(buf, sizeof(dbug_item_print_buf), &my_charset_bin);
+ str.length(0);
+ if (!un)
+ return "(SELECT_LEX_UNIT*)NULL";
+
+ THD *thd= current_thd;
+ ulonglong save_option_bits= thd->variables.option_bits;
+ thd->variables.option_bits &= ~OPTION_QUOTE_SHOW_CREATE;
+
+ un->print(&str, QT_EXPLAIN);
+
+ thd->variables.option_bits= save_option_bits;
+
+ if (str.c_ptr() == buf)
+ return buf;
+ else
+ return "Couldn't fit into buffer";
+}
+
+const char *dbug_print(Item *x) { return dbug_print_item(x); }
+const char *dbug_print(SELECT_LEX *x) { return dbug_print_select(x); }
+const char *dbug_print(SELECT_LEX_UNIT *x) { return dbug_print_unit(x); }
+
+#endif /*DBUG_OFF*/
+
+
+
+void Item::register_in(THD *thd)
+{
+ next= thd->free_list;
+ thd->free_list= this;
+}
+
+
+bool Item::cleanup_excluding_immutables_processor (void *arg)
+{
+ if (!(get_extraction_flag() == IMMUTABLE_FL))
+ return cleanup_processor(arg);
+ else
+ {
+ clear_extraction_flag();
+ return false;
+ }
+}