Skip navigation links

Recommended Servers for MySQL

The world's most popular open source database

Contact a MySQL Representative

Login | Register

• MySQL.com
• Downloads
• Developer Zone
• Partners & Solutions
• Customer Login

• DevZone
• Documentation
• Librarian
• Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs

 

 

 

The world's most popular open source database

mysql/src/5.1-dbg/sql/item.cc File Reference

#include "mysql_priv.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 dependency graph for item.cc:

Go to the source code of this file.

Functions
static void	mark_as_dependent (THD *thd, SELECT_LEX *last, SELECT_LEX *current, Item_ident *item)
void	item_init (void)
static void	my_coll_agg_error (DTCollation &c1, DTCollation &c2, const char *fname)
static void	my_coll_agg_error (DTCollation &c1, DTCollation &c2, DTCollation &c3, const char *fname)
static void	my_coll_agg_error (Item **args, uint count, const char *fname, int item_sep)
bool	agg_item_collations (DTCollation &c, const char *fname, Item **av, uint count, uint flags, int item_sep)
bool	agg_item_collations_for_comparison (DTCollation &c, const char *fname, Item **av, uint count, uint flags)
bool	agg_item_charsets (DTCollation &coll, const char *fname, Item **args, uint nargs, uint flags, int item_sep)
bool	check_if_only_end_space (CHARSET_INFO *cs, char *str, char *end)
static void	default_set_param_func (Item_param *param, uchar **pos __attribute__((unused)), ulong len __attribute__((unused)))
static void	mark_as_dependent (THD *thd, SELECT_LEX *last, SELECT_LEX *current, Item_ident *resolved_item, Item_ident *mark_item)
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)
static Item **	find_field_in_group_list (Item *find_item, ORDER *group_list)
static Item **	resolve_ref_in_select_and_group (THD *thd, Item_ident *ref, SELECT_LEX *select)
static uint	nr_of_decimals (const char *str, const char *end)
uint	char_val (char X)
Item_result	item_cmp_type (Item_result a, Item_result b)
void	resolve_const_item (THD *thd, Item **ref, Item *comp_item)
bool	field_is_equal_to_item (Field *field, Item *item)
void	dummy_error_processor (THD *thd, void *data)
void	view_error_processor (THD *thd, void *data)
Variables
const String	my_null_string ("NULL", 4, default_charset_info)
static const Hybrid_type_traits	real_traits_instance
static const Hybrid_type_traits_decimal	decimal_traits_instance
static const Hybrid_type_traits_integer	integer_traits_instance

---

Function Documentation

bool agg_item_charsets	(	DTCollation &	coll,
		const char *	fname,
		Item **	args,
		uint	nargs,
		uint	flags,
		int	item_sep
	)

Definition at line 1427 of file item.cc.

References agg_item_collations(), args, backup, DTCollation::collation, current_thd, FALSE, Item::FIELD_ITEM, Item_field::fix_fields(), LINT_INIT, my_coll_agg_error(), String::needs_conversion(), NULL, and TRUE.

Referenced by Item_func::agg_arg_charsets(), and Item_func_group_concat::fix_fields().

{
  Item **arg, **last, *safe_args[2];

  LINT_INIT(safe_args[0]);
  LINT_INIT(safe_args[1]);

  if (agg_item_collations(coll, fname, args, nargs, flags, item_sep))
    return TRUE;

  /*
    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];
  }

  THD *thd= current_thd;
  Query_arena *arena, backup;
  bool res= FALSE;
  uint i;
  /*
    In case we're in statement prepare, create conversion item
    in its memory: it will be reused on each execute.
  */
  arena= thd->is_stmt_prepare() ? thd->activate_stmt_arena_if_needed(&backup)
                                : NULL;

  for (i= 0, arg= args; i < nargs; i++, arg+= item_sep)
  {
    Item* conv;
    uint32 dummy_offset;
    if (!String::needs_conversion(0, coll.collation,
                                  (*arg)->collation.collation,
                                  &dummy_offset))
      continue;

    if (!(conv= (*arg)->safe_charset_converter(coll.collation)))
    {
      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".
    }
    if ((*arg)->type() == Item::FIELD_ITEM)
      ((Item_field *)(*arg))->no_const_subst= 1;
    /*
      If in statement prepare, then we create a converter for two
      constant items, do it once and then reuse it.
      If we're in execution of a prepared statement, arena is NULL,
      and the conv was created in runtime memory. This can be
      the case only if the argument is a parameter marker ('?'),
      because for all true constants the charset converter has already
      been created in prepare. In this case register the change for
      rollback.
    */
    if (arena)
      *arg= conv;
    else
      thd->change_item_tree(arg, conv);
    /*
      We do not check conv->fixed, because Item_func_conv_charset which can
      be return by safe_charset_converter can't be fixed at creation
    */
    conv->fix_fields(thd, arg);
  }
  if (arena)
    thd->restore_active_arena(arena, &backup);
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool agg_item_collations	(	DTCollation &	c,
		const char *	fname,
		Item **	av,
		uint	count,
		uint	flags,
		int	item_sep
	)

Definition at line 1365 of file item.cc.

References DTCollation::aggregate(), DTCollation::derivation, DERIVATION_NONE, FALSE, my_coll_agg_error(), MY_COLL_DISALLOW_NONE, DTCollation::set(), and TRUE.

Referenced by Item_func::agg_arg_collations(), agg_item_charsets(), and agg_item_collations_for_comparison().

{
  uint i;
  Item **arg;
  c.set(av[0]->collation);
  for (i= 1, arg= &av[item_sep]; i < count; i++, arg++)
  {
    if (c.aggregate((*arg)->collation, flags))
    {
      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;
  }
  return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool agg_item_collations_for_comparison	(	DTCollation &	c,
		const char *	fname,
		Item **	av,
		uint	count,
		uint	flags
	)

Definition at line 1389 of file item.cc.

References agg_item_collations(), and MY_COLL_DISALLOW_NONE.

Referenced by Item_func::agg_arg_collations_for_comparison().

{
  return (agg_item_collations(c, fname, av, count,
                              flags | MY_COLL_DISALLOW_NONE, 1));
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint char_val

(

char

X

)

[inline]

Definition at line 4394 of file item.cc.

{
  return (uint) (X >= '0' && X <= '9' ? X-'0' :
                 X >= 'A' && X <= 'Z' ? X-'A'+10 :
                 X-'a'+10);
}

bool check_if_only_end_space	(	CHARSET_INFO *	cs,
		char *	str,
		char *	end
	)			[inline]

Definition at line 2096 of file item.cc.

References charset_info_st::cset, MY_SEQ_SPACES, and my_charset_handler_st::scan.

Referenced by Item_string::val_int(), and Item_string::val_real().

{
  return str+ cs->cset->scan(cs, str, end, MY_SEQ_SPACES) == end;
}

Here is the caller graph for this function:

static void default_set_param_func	(	Item_param *	param,
		uchar **pos	__attribute__((unused)),
		ulong len	__attribute__((unused))
	)			[static]

Definition at line 2207 of file item.cc.

References Item_param::set_null().

{
  param->set_null();
}

Here is the call graph for this function:

void dummy_error_processor	(	THD *	thd,
		void *	data
	)

Definition at line 6395 of file item.cc.

Referenced by Name_resolution_context::init().

{}

Here is the caller graph for this function:

bool field_is_equal_to_item	(	Field *	field,
		Item *	item
	)

Definition at line 5707 of file item.cc.

References DECIMAL_RESULT, INT_RESULT, item_cmp_type(), MAX_FIELD_WIDTH, my_charset_bin, my_decimal_cmp(), Item::null_value, Field::result_type(), Item::result_type(), STRING_RESULT, stringcmp(), Item::val_decimal(), Field::val_decimal(), Item::val_real(), Field::val_real(), Item::val_str(), and Field::val_str().

Referenced by get_mm_leaf().

{

  Item_result res_type=item_cmp_type(field->result_type(),
                                     item->result_type());
  if (res_type == STRING_RESULT)
  {
    char item_buff[MAX_FIELD_WIDTH];
    char field_buff[MAX_FIELD_WIDTH];
    String item_tmp(item_buff,sizeof(item_buff),&my_charset_bin),*item_result;
    String field_tmp(field_buff,sizeof(field_buff),&my_charset_bin);
    item_result=item->val_str(&item_tmp);
    if (item->null_value)
      return 1;                                 // This must be true
    field->val_str(&field_tmp);
    return !stringcmp(&field_tmp,item_result);
  }
  if (res_type == INT_RESULT)
    return 1;                                   // Both where of type int
  if (res_type == DECIMAL_RESULT)
  {
    my_decimal item_buf, *item_val,
               field_buf, *field_val;
    item_val= item->val_decimal(&item_buf);
    if (item->null_value)
      return 1;                                 // This must be true
    field_val= field->val_decimal(&field_buf);
    return !my_decimal_cmp(item_val, field_val);
  }
  double result= item->val_real();
  if (item->null_value)
    return 1;
  return result == field->val_real();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static Item** find_field_in_group_list	(	Item *	find_item,
		ORDER *	group_list
	)			[static]

Definition at line 3107 of file item.cc.

References current_thd, Item_ident::db_name, DBUG_ASSERT, ER_NON_UNIQ_ERROR, Item::FIELD_ITEM, Item_ident::field_name, files_charset_info, Item::full_name(), st_order::item, lower_case_table_names, my_casedn_str, my_error(), my_strcasecmp, MYF, NAME_LEN, st_order::next, NULL, Item::REF_ITEM, strcmp(), strmake(), system_charset_info, Item_ident::table_name, and Item::type().

Referenced by resolve_ref_in_select_and_group().

{
  const char *db_name;
  const char *table_name;
  const char *field_name;
  ORDER      *found_group= NULL;
  int         found_match_degree= 0;
  Item_ident *cur_field;
  int         cur_match_degree= 0;
  char        name_buff[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 && lower_case_table_names)
  {
    /* Convert database to lower case for comparison */
    strmake(name_buff, db_name, sizeof(name_buff)-1);
    my_casedn_str(files_charset_info, name_buff);
    db_name= name_buff;
  }

  DBUG_ASSERT(field_name != 0);

  for (ORDER *cur_group= group_list ; cur_group ; cur_group= cur_group->next)
  {
    if ((*(cur_group->item))->real_item()->type() == Item::FIELD_ITEM)
    {
      cur_field= (Item_ident*) *cur_group->item;
      cur_match_degree= 0;
      
      DBUG_ASSERT(cur_field->field_name != 0);

      if (!my_strcasecmp(system_charset_info,
                         cur_field->field_name, field_name))
        ++cur_match_degree;
      else
        continue;

      if (cur_field->table_name && table_name)
      {
        /* If field_name is qualified by a table name. */
        if (strcmp(cur_field->table_name, table_name))
          /* Same field names, different tables. */
          return NULL;

        ++cur_match_degree;
        if (cur_field->db_name && db_name)
        {
          /* If field_name is also qualified by a database name. */
          if (strcmp(cur_field->db_name, db_name))
            /* Same field names, different databases. */
            return NULL;
          ++cur_match_degree;
        }
      }

      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_field, 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Item_result item_cmp_type	(	Item_result	a,
		Item_result	b
	)

Definition at line 5595 of file item.cc.

References DECIMAL_RESULT, INT_RESULT, REAL_RESULT, ROW_RESULT, and STRING_RESULT.

Referenced by agg_cmp_type(), field_is_equal_to_item(), Item_func_field::fix_length_and_dec(), Item_func_min_max::fix_length_and_dec(), resolve_const_item(), Arg_comparator::set_cmp_func(), and Arg_comparator::set_compare_func().

{
  if (a == STRING_RESULT && b == STRING_RESULT)
    return STRING_RESULT;
  if (a == INT_RESULT && b == INT_RESULT)
    return INT_RESULT;
  else if (a == ROW_RESULT || b == ROW_RESULT)
    return ROW_RESULT;
  if ((a == INT_RESULT || a == DECIMAL_RESULT) &&
      (b == INT_RESULT || b == DECIMAL_RESULT))
    return DECIMAL_RESULT;
  return REAL_RESULT;
}

Here is the caller graph for this function:

void item_init

(

void

)

Definition at line 166 of file item.cc.

References item_user_lock_init().

Referenced by init_common_variables().

{
  item_user_lock_init();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void mark_as_dependent	(	THD *	thd,
		SELECT_LEX *	last,
		SELECT_LEX *	current,
		Item_ident *	resolved_item,
		Item_ident *	mark_item
	)			[static]

Definition at line 2997 of file item.cc.

References Item_ident::db_name, Item_ident::depended_from, DESCRIBE_EXTENDED, ER, ER_WARN_FIELD_RESOLVED, Item_ident::field_name, MYSQL_ERRMSG_SIZE, push_warning(), Item_ident::table_name, and MYSQL_ERROR::WARN_LEVEL_NOTE.

{
  const char *db_name= (resolved_item->db_name ?
                        resolved_item->db_name : "");
  const char *table_name= (resolved_item->table_name ?
                           resolved_item->table_name : "");
  /* store pointer on SELECT_LEX from which item is dependent */
  if (mark_item)
    mark_item->depended_from= last;
  current->mark_as_dependent(last);
  if (thd->lex->describe & DESCRIBE_EXTENDED)
  {
    char warn_buff[MYSQL_ERRMSG_SIZE];
    sprintf(warn_buff, ER(ER_WARN_FIELD_RESOLVED),
            db_name, (db_name[0] ? "." : ""),
            table_name, (table_name [0] ? "." : ""),
            resolved_item->field_name,
            current->select_number, last->select_number);
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
                 ER_WARN_FIELD_RESOLVED, warn_buff);
  }
}

Here is the call graph for this function:

static void mark_as_dependent	(	THD *	thd,
		SELECT_LEX *	last,
		SELECT_LEX *	current,
		Item_ident *	item
	)			[static]

Referenced by Item_ref::fix_fields(), Item_field::fix_outer_field(), and mark_select_range_as_dependent().

Here is the caller graph for this function:

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
	)

Definition at line 3045 of file item.cc.

References Item_subselect::const_item_cache, Item::FIELD_ITEM, st_table::map, mark_as_dependent(), OUTER_REF_TABLE_BIT, Item::REF_ITEM, Field::table, Item::type(), Item::used_tables(), Item_subselect::used_tables_cache, and view_ref_found.

Referenced by find_field_in_tables().

{
  /*
    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->outer_select() != last_select;
       previous_select= previous_select->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);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void my_coll_agg_error	(	Item **	args,
		uint	count,
		const char *	fname,
		int	item_sep
	)			[static]

Definition at line 1352 of file item.cc.

References args, ER_CANT_AGGREGATE_NCOLLATIONS, my_coll_agg_error(), my_error(), and MYF.

{
  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);
}

Here is the call graph for this function:

static void my_coll_agg_error	(	DTCollation &	c1,
		DTCollation &	c2,
		DTCollation &	c3,
		const char *	fname
	)			[static]

Definition at line 1340 of file item.cc.

References DTCollation::collation, DTCollation::derivation_name(), ER_CANT_AGGREGATE_3COLLATIONS, my_error(), MYF, and charset_info_st::name.

{
  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);
}

Here is the call graph for this function:

static void my_coll_agg_error	(	DTCollation &	c1,
		DTCollation &	c2,
		const char *	fname
	)			[static]

Definition at line 1330 of file item.cc.

References DTCollation::collation, DTCollation::derivation_name(), ER_CANT_AGGREGATE_2COLLATIONS, my_error(), MYF, and charset_info_st::name.

Referenced by agg_item_charsets(), agg_item_collations(), my_coll_agg_error(), and Arg_comparator::set_compare_func().

{
  my_error(ER_CANT_AGGREGATE_2COLLATIONS,MYF(0),
           c1.collation->name,c1.derivation_name(),
           c2.collation->name,c2.derivation_name(),
           fname);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static uint nr_of_decimals	(	const char *	str,
		const char *	end
	)			[static]

Definition at line 4299 of file item.cc.

References my_isdigit, NOT_FIXED_DEC, and system_charset_info.

Referenced by Item_float::Item_float().

{
  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 (; my_isdigit(system_charset_info, *str) ; str++)
    ;
  if (*str == 'e' || *str == 'E')
    return NOT_FIXED_DEC;
  return (uint) (str - decimal_point);
}

Here is the caller graph for this function:

void resolve_const_item	(	THD *	thd,
		Item **	ref,
		Item *	comp_item
	)

Definition at line 5610 of file item.cc.

References Item::basic_const_item(), String::charset(), Item_row::cols(), DBUG_ASSERT, DECIMAL_RESULT, Item::decimals, Item_row::el(), INT_RESULT, item_cmp_type(), String::length(), MAX_FIELD_WIDTH, Item::max_length, my_charset_bin, name, Item::name, NULL, Item::null_value, String::ptr(), REAL_RESULT, resolve_const_item(), Item::result_type(), Item::ROW_ITEM, ROW_RESULT, sql_strmake(), STRING_RESULT, Item::type(), Item::val_decimal(), Item::val_int(), Item::val_real(), and Item::val_str().

Referenced by propagate_cond_constants(), and resolve_const_item().

{
  Item *item= *ref;
  Item *new_item= NULL;
  if (item->basic_const_item())
    return;                                     // Can't be better
  Item_result res_type=item_cmp_type(comp_item->result_type(),
                                     item->result_type());
  char *name=item->name;                        // Alloced by sql_alloc

  switch (res_type) {
  case STRING_RESULT:
  {
    char buff[MAX_FIELD_WIDTH];
    String tmp(buff,sizeof(buff),&my_charset_bin),*result;
    result=item->val_str(&tmp);
    if (item->null_value)
      new_item= new Item_null(name);
    else
    {
      uint length= result->length();
      char *tmp_str= sql_strmake(result->ptr(), length);
      new_item= new Item_string(name, tmp_str, length, result->charset());
    }
    break;
  }
  case INT_RESULT:
  {
    longlong result=item->val_int();
    uint length=item->max_length;
    bool null_value=item->null_value;
    new_item= (null_value ? (Item*) new Item_null(name) :
               (Item*) new Item_int(name, result, length));
    break;
  }
  case ROW_RESULT:
  if (item->type() == Item::ROW_ITEM && comp_item->type() == Item::ROW_ITEM)
  {
    /*
      Substitute constants only in Item_rows. Don't affect other Items
      with ROW_RESULT (eg Item_singlerow_subselect).

      For such Items more optimal is to detect if it is constant and replace
      it with Item_row. This would optimize queries like this:
      SELECT * FROM t1 WHERE (a,b) = (SELECT a,b FROM t2 LIMIT 1);
    */
    Item_row *item_row= (Item_row*) item;
    Item_row *comp_item_row= (Item_row*) comp_item;
    uint col;
    new_item= 0;
    /*
      If item and comp_item are both Item_rows and have same number of cols
      then process items in Item_row one by one.
      We can't ignore NULL values here as this item may be used with <=>, in
      which case NULL's are significant.
    */
    DBUG_ASSERT(item->result_type() == comp_item->result_type());
    DBUG_ASSERT(item_row->cols() == comp_item_row->cols());
    col= item_row->cols();
    while (col-- > 0)
      resolve_const_item(thd, item_row->addr(col), comp_item_row->el(col));
    break;
  }
  /* Fallthrough */
  case REAL_RESULT:
  {                                             // It must REAL_RESULT
    double result= item->val_real();
    uint length=item->max_length,decimals=item->decimals;
    bool null_value=item->null_value;
    new_item= (null_value ? (Item*) new Item_null(name) : (Item*)
               new Item_float(name, result, decimals, length));
    break;
  }
  case DECIMAL_RESULT:
  {
    my_decimal decimal_value;
    my_decimal *result= item->val_decimal(&decimal_value);
    uint length= item->max_length, decimals= item->decimals;
    bool null_value= item->null_value;
    new_item= (null_value ?
               (Item*) new Item_null(name) :
               (Item*) new Item_decimal(name, result, length, decimals));
    break;
  }
  default:
    DBUG_ASSERT(0);
  }
  if (new_item)
    thd->change_item_tree(ref, new_item);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static Item** resolve_ref_in_select_and_group	(	THD *	thd,
		Item_ident *	ref,
		SELECT_LEX *	select
	)			[static]

Definition at line 3238 of file item.cc.

References counter, current_thd, DBUG_ASSERT, ER, ER_ILLEGAL_REFERENCE, ER_NON_GROUPING_FIELD_USED, ER_NON_UNIQ_ERROR, FALSE, find_field_in_group_list(), find_item_in_list(), Item_ident::full_name(), MODE_ONLY_FULL_GROUP_BY, my_error(), MYF, Item::name, not_found_item, NULL, push_warning_printf(), TRUE, MYSQL_ERROR::WARN_LEVEL_WARN, and Item::with_sum_func.

Referenced by Item_ref::fix_fields(), and Item_field::fix_outer_field().

{
  Item **group_by_ref= NULL;
  Item **select_ref= NULL;
  ORDER *group_list= (ORDER*) select->group_list.first;
  bool ambiguous_fields= FALSE;
  uint counter;
  bool not_used;

  /*
    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,
                                      &not_used)))
    return NULL; /* Some error occurred. */

  /* 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)))
    {
      ambiguous_fields= TRUE;
      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, ER_NON_UNIQ_ERROR,
                          ER(ER_NON_UNIQ_ERROR), ref->full_name(),
                          current_thd->where);

    }
  }

  if (thd->variables.sql_mode & MODE_ONLY_FULL_GROUP_BY &&
      select_ref != not_found_item && !group_by_ref)
  {
    /*
      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, "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, "forward reference in item list");
        return NULL;
      }
      DBUG_ASSERT((*select_ref)->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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void view_error_processor	(	THD *	thd,
		void *	data
	)

Definition at line 6408 of file item.cc.

Referenced by mysql_make_view(), and Item_default_value::save_in_field().

{
  ((TABLE_LIST *)data)->hide_view_error(thd);
}

Here is the caller graph for this function:

---

Variable Documentation

const Hybrid_type_traits_decimal decimal_traits_instance [static]

Definition at line 69 of file item.cc.

Referenced by Hybrid_type_traits_decimal::instance().

const Hybrid_type_traits_integer integer_traits_instance [static]

Definition at line 145 of file item.cc.

Referenced by Hybrid_type_traits_integer::instance().

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

Referenced by insert_params_from_vars_with_log(), and Item_param::query_val_str().

const Hybrid_type_traits real_traits_instance [static]

Definition at line 45 of file item.cc.

Referenced by Hybrid_type_traits::instance().

---

• Products
• MySQL Enterprise
• MySQL Cluster
• MySQL Embedded (OEM/ISV)
• MySQL Data Warehouse
• MySQL Backup & Recovery
• MySQL Workbench
• MySQL Connectors
• Online Shop

• Downloads
• MySQL Community Server
• MySQL Enterprise
• MySQL Proxy
• MySQL Cluster
• MySQL Workbench
• GUI Tools
• Connectors
• Archives
• Snapshots
• Mirrors

• Developer Zone
• Documentation
• Librarian
• Developer Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs
• MySQL Meetups
• Guilds
• Lists

• About
• About MySQL
• Contact Us
• Legal
• Privacy Policy
• Job Opportunities
• Site Map

© 1995-2008 MySQL AB, 2008- Sun Microsystems, Inc.