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/sql_base.cc File Reference

#include "mysql_priv.h"
#include "sql_select.h"
#include "sp_head.h"
#include "sp.h"
#include "sql_trigger.h"
#include <m_ctype.h>
#include <my_dir.h>
#include <hash.h>

Include dependency graph for sql_base.cc:

Go to the source code of this file.

Defines
#define	check_unused()
#define	WRONG_GRANT   (Field*) -1
Functions
static int	open_unireg_entry (THD *thd, TABLE *entry, TABLE_LIST *table_list, const char *alias, char *cache_key, uint cache_key_length, MEM_ROOT *mem_root, uint flags)
static void	free_cache_entry (TABLE *entry)
static void	mysql_rm_tmp_tables (void)
static bool	open_new_frm (THD *thd, TABLE_SHARE *share, const char *alias, uint db_stat, uint prgflag, uint ha_open_flags, TABLE *outparam, TABLE_LIST *table_desc, MEM_ROOT *mem_root)
static void	close_old_data_files (THD *thd, TABLE *table, bool abort_locks, bool send_refresh)
static bool	reopen_table (TABLE *table)
static bool	has_two_write_locked_tables_with_auto_increment (TABLE_LIST *tables)
byte *	table_cache_key (const byte *record, uint *length, my_bool not_used __attribute__((unused)))
bool	table_cache_init (void)
void	table_cache_free (void)
uint	cached_open_tables (void)
uint	create_table_def_key (THD *thd, char *key, TABLE_LIST *table_list, bool tmp_table)
byte *	table_def_key (const byte *record, uint *length, my_bool not_used __attribute__((unused)))
static void	table_def_free_entry (TABLE_SHARE *share)
bool	table_def_init (void)
void	table_def_free (void)
uint	cached_table_definitions (void)
TABLE_SHARE *	get_table_share (THD *thd, TABLE_LIST *table_list, char *key, uint key_length, uint db_flags, int *error)
static TABLE_SHARE *	get_table_share_with_create (THD *thd, TABLE_LIST *table_list, char *key, uint key_length, uint db_flags, int *error)
void	release_table_share (TABLE_SHARE *share, enum release_type type)
TABLE_SHARE *	get_cached_table_share (const char *db, const char *table_name)
static void	close_handle_and_leave_table_as_lock (TABLE *table)
OPEN_TABLE_LIST *	list_open_tables (THD *thd, const char *db, const char *wild)
void	intern_close_table (TABLE *table)
void	free_io_cache (TABLE *table)
bool	close_cached_tables (THD *thd, bool if_wait_for_refresh, TABLE_LIST *tables, bool have_lock)
static void	mark_used_tables_as_free_for_reuse (THD *thd, TABLE *table)
void	close_thread_tables (THD *thd, bool lock_in_use, bool skip_derived)
bool	close_thread_table (THD *thd, TABLE **table_ptr)
static uint	tmpkeyval (THD *thd, TABLE *table)
void	close_temporary_tables (THD *thd)
TABLE_LIST *	find_table_in_list (TABLE_LIST *table, st_table_list *TABLE_LIST::*link, const char *db_name, const char *table_name)
TABLE_LIST *	unique_table (THD *thd, TABLE_LIST *table, TABLE_LIST *table_list)
void	update_non_unique_table_error (TABLE_LIST *update, const char *operation, TABLE_LIST *duplicate)
TABLE *	find_temporary_table (THD *thd, const char *db, const char *table_name)
TABLE *	find_temporary_table (THD *thd, TABLE_LIST *table_list)
bool	close_temporary_table (THD *thd, TABLE_LIST *table_list)
void	close_temporary_table (THD *thd, TABLE *table, bool free_share, bool delete_table)
void	close_temporary (TABLE *table, bool free_share, bool delete_table)
bool	rename_temporary_table (THD *thd, TABLE *table, const char *db, const char *table_name)
static void	relink_unused (TABLE *table)
TABLE *	unlink_open_table (THD *thd, TABLE *list, TABLE *find)
void	wait_for_condition (THD *thd, pthread_mutex_t *mutex, pthread_cond_t *cond)
bool	reopen_name_locked_table (THD *thd, TABLE_LIST *table_list)
TABLE *	open_table (THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root, bool *refresh, uint flags)
TABLE *	find_locked_table (THD *thd, const char *db, const char *table_name)
bool	close_data_tables (THD *thd, const char *db, const char *table_name)
bool	reopen_tables (THD *thd, bool get_locks, bool in_refresh)
bool	table_is_used (TABLE *table, bool wait_for_name_lock)
bool	wait_for_tables (THD *thd)
TABLE *	drop_locked_tables (THD *thd, const char *db, const char *table_name)
void	abort_locked_tables (THD *thd, const char *db, const char *table_name)
void	assign_new_table_id (TABLE_SHARE *share)
int	open_tables (THD *thd, TABLE_LIST **start, uint *counter, uint flags)
static bool	check_lock_and_start_stmt (THD *thd, TABLE *table, thr_lock_type lock_type)
TABLE *	open_ltable (THD *thd, TABLE_LIST *table_list, thr_lock_type lock_type)
int	simple_open_n_lock_tables (THD *thd, TABLE_LIST *tables)
bool	open_and_lock_tables (THD *thd, TABLE_LIST *tables)
bool	open_normal_and_derived_tables (THD *thd, TABLE_LIST *tables, uint flags)
static void	mark_real_tables_as_free_for_reuse (TABLE_LIST *table)
int	lock_tables (THD *thd, TABLE_LIST *tables, uint count, bool *need_reopen)
void	close_tables_for_reopen (THD *thd, TABLE_LIST **tables)
TABLE *	open_temporary_table (THD *thd, const char *path, const char *db, const char *table_name, bool link_in_list)
bool	rm_temporary_table (handlerton *base, char *path)
static void	update_field_dependencies (THD *thd, Field *field, TABLE *table)
static Field *	find_field_in_view (THD *thd, TABLE_LIST *table_list, const char *name, uint length, const char *item_name, Item **ref, bool register_tree_change)
static Field *	find_field_in_natural_join (THD *thd, TABLE_LIST *table_ref, const char *name, uint length, Item **ref, bool register_tree_change, TABLE_LIST **actual_table)
Field *	find_field_in_table (THD *thd, TABLE *table, const char *name, uint length, bool allow_rowid, uint *cached_field_index_ptr)
Field *	find_field_in_table_ref (THD *thd, TABLE_LIST *table_list, const char *name, uint length, const char *item_name, const char *db_name, const char *table_name, Item **ref, bool check_privileges, bool allow_rowid, uint *cached_field_index_ptr, bool register_tree_change, TABLE_LIST **actual_table)
Field *	find_field_in_table_sef (TABLE *table, const char *name)
Field *	find_field_in_tables (THD *thd, Item_ident *item, TABLE_LIST *first_table, TABLE_LIST *last_table, Item **ref, find_item_error_report_type report_error, bool check_privileges, bool register_tree_change)
Item **	find_item_in_list (Item *find, List< Item > &items, uint *counter, find_item_error_report_type report_error, bool *unaliased)
static bool	test_if_string_in_list (const char *find, List< String > *str_list)
static bool	set_new_item_local_context (THD *thd, Item_ident *item, TABLE_LIST *table_ref)
static bool	mark_common_columns (THD *thd, TABLE_LIST *table_ref_1, TABLE_LIST *table_ref_2, List< String > *using_fields, uint *found_using_fields)
static bool	store_natural_using_join_columns (THD *thd, TABLE_LIST *natural_using_join, TABLE_LIST *table_ref_1, TABLE_LIST *table_ref_2, List< String > *using_fields, uint found_using_fields)
static bool	store_top_level_join_columns (THD *thd, TABLE_LIST *table_ref, TABLE_LIST *left_neighbor, TABLE_LIST *right_neighbor)
static bool	setup_natural_join_row_types (THD *thd, List< TABLE_LIST > *from_clause, Name_resolution_context *context)
int	setup_wild (THD *thd, TABLE_LIST *tables, List< Item > &fields, List< Item > *sum_func_list, uint wild_num)
bool	setup_fields (THD *thd, Item **ref_pointer_array, List< Item > &fields, enum_mark_columns mark_used_columns, List< Item > *sum_func_list, bool allow_sum_func)
TABLE_LIST **	make_leaves_list (TABLE_LIST **list, TABLE_LIST *tables)
bool	setup_tables (THD *thd, Name_resolution_context *context, List< TABLE_LIST > *from_clause, TABLE_LIST *tables, TABLE_LIST **leaves, bool select_insert)
bool	setup_tables_and_check_access (THD *thd, Name_resolution_context *context, List< TABLE_LIST > *from_clause, TABLE_LIST *tables, TABLE_LIST **leaves, bool select_insert, ulong want_access)
bool	get_key_map_from_key_list (key_map *map, TABLE *table, List< String > *index_list)
bool	insert_fields (THD *thd, Name_resolution_context *context, const char *db_name, const char *table_name, List_iterator< Item > *it, bool any_privileges)
int	setup_conds (THD *thd, TABLE_LIST *tables, TABLE_LIST *leaves, COND **conds)
static bool	fill_record (THD *thd, List< Item > &fields, List< Item > &values, bool ignore_errors)
bool	fill_record_n_invoke_before_triggers (THD *thd, List< Item > &fields, List< Item > &values, bool ignore_errors, Table_triggers_list *triggers, enum trg_event_type event)
bool	fill_record (THD *thd, Field **ptr, List< Item > &values, bool ignore_errors)
bool	fill_record_n_invoke_before_triggers (THD *thd, Field **ptr, List< Item > &values, bool ignore_errors, Table_triggers_list *triggers, enum trg_event_type event)
void	remove_db_from_cache (const char *db)
void	flush_tables ()
bool	remove_table_from_cache (THD *thd, const char *db, const char *table_name, uint flags)
int	setup_ftfuncs (SELECT_LEX *select_lex)
int	init_ftfuncs (THD *thd, SELECT_LEX *select_lex, bool no_order)
bool	is_equal (const LEX_STRING *a, const LEX_STRING *b)
int	abort_and_upgrade_lock (ALTER_PARTITION_PARAM_TYPE *lpt)
void	close_open_tables_and_downgrade (ALTER_PARTITION_PARAM_TYPE *lpt)
void	mysql_wait_completed_table (ALTER_PARTITION_PARAM_TYPE *lpt, TABLE *my_table)
Variables
TABLE *	unused_tables
HASH	open_cache
static HASH	table_def_cache
static TABLE_SHARE *	oldest_unused_share
static TABLE_SHARE	end_of_unused_share
static pthread_mutex_t	LOCK_table_share
static bool	table_def_inited = 0
Field *	not_found_field = (Field*) 0x1
Field *	view_ref_found = (Field*) 0x2
Item **	not_found_item = (Item**) 0x1

---

Define Documentation

 

#define check_unused

(

)

Definition at line 147 of file sql_base.cc.

Referenced by close_thread_tables(), free_cache_entry(), open_table(), relink_unused(), and reopen_name_locked_table().

#define WRONG_GRANT   (Field*) -1

Definition at line 3588 of file sql_base.cc.

Referenced by find_field_in_table_ref(), and find_field_in_tables().

---

Function Documentation

int abort_and_upgrade_lock

(

ALTER_PARTITION_PARAM_TYPE *

lpt

)

Definition at line 6387 of file sql_base.cc.

References DBUG_ENTER, DBUG_RETURN, flags, LOCK_open, mysql_lock_abort(), pthread_mutex_lock, pthread_mutex_unlock, remove_table_from_cache(), TRUE, and VOID.

{
  uint flags= RTFC_WAIT_OTHER_THREAD_FLAG | RTFC_CHECK_KILLED_FLAG;
  DBUG_ENTER("abort_and_upgrade_locks");

  lpt->old_lock_type= lpt->table->reginfo.lock_type;
  VOID(pthread_mutex_lock(&LOCK_open));
  mysql_lock_abort(lpt->thd, lpt->table, TRUE);
  VOID(remove_table_from_cache(lpt->thd, lpt->db, lpt->table_name, flags));
  VOID(pthread_mutex_unlock(&LOCK_open));
  DBUG_RETURN(0);
}

Here is the call graph for this function:

void abort_locked_tables	(	THD *	thd,
		const char *	db,
		const char *	table_name
	)

Definition at line 2531 of file sql_base.cc.

References st_table_share::db, mysql_lock_abort(), st_table::next, st_table::s, LEX_STRING::str, strcmp(), st_table_share::table_name, and TRUE.

Referenced by mysql_rm_table_part2().

{
  TABLE *table;
  for (table= thd->open_tables; table ; table= table->next)
  {
    if (!strcmp(table->s->table_name.str, table_name) &&
        !strcmp(table->s->db.str, db))
    {
      mysql_lock_abort(thd,table, TRUE);
      break;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void assign_new_table_id

(

TABLE_SHARE *

share

)

Definition at line 2574 of file sql_base.cc.

References DBUG_ASSERT, DBUG_ENTER, DBUG_PRINT, DBUG_VOID_RETURN, LOCK_open, NULL, safe_mutex_assert_owner, st_table_share::table_map_id, and unlikely.

Referenced by get_table_share().

{
  static ulong last_table_id= ~0UL;

  DBUG_ENTER("assign_new_table_id");

  /* Preconditions */
  DBUG_ASSERT(share != NULL);
  safe_mutex_assert_owner(&LOCK_open);

  ulong tid= ++last_table_id;                   /* get next id */
  /*
    There is one reserved number that cannot be used.  Remember to
    change this when 6-byte global table id's are introduced.
  */
  if (unlikely(tid == ~0UL))
    tid= ++last_table_id;
  share->table_map_id= tid;
  DBUG_PRINT("info", ("table_id=%lu", tid));

  /* Post conditions */
  DBUG_ASSERT(share->table_map_id != ~0UL);

  DBUG_VOID_RETURN;
}

Here is the caller graph for this function:

uint cached_open_tables

(

void

)

Definition at line 85 of file sql_base.cc.

References open_cache, and st_hash::records.

Referenced by dispatch_command(), mysql_print_status(), and show_open_tables().

{
  return open_cache.records;
}

Here is the caller graph for this function:

uint cached_table_definitions

(

void

)

Definition at line 247 of file sql_base.cc.

References st_hash::records, and table_def_cache.

Referenced by show_table_definitions().

{
  return table_def_cache.records;
}

Here is the caller graph for this function:

static bool check_lock_and_start_stmt	(	THD *	thd,
		TABLE *	table,
		thr_lock_type	lock_type
	)			[static]

Definition at line 3046 of file sql_base.cc.

References st_table::alias, DBUG_ENTER, DBUG_RETURN, ER_TABLE_NOT_LOCKED_FOR_WRITE, error, st_table::file, st_reginfo::lock_type, my_error(), MYF, handler::print_error(), st_table::reginfo, handler::start_stmt(), and TL_WRITE_ALLOW_READ.

Referenced by lock_tables(), and open_ltable().

{
  int error;
  DBUG_ENTER("check_lock_and_start_stmt");

  if ((int) lock_type >= (int) TL_WRITE_ALLOW_READ &&
      (int) table->reginfo.lock_type < (int) TL_WRITE_ALLOW_READ)
  {
    my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),table->alias);
    DBUG_RETURN(1);
  }
  if ((error=table->file->start_stmt(thd, lock_type)))
  {
    table->file->print_error(error,MYF(0));
    DBUG_RETURN(1);
  }
  DBUG_RETURN(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool close_cached_tables	(	THD *	thd,
		bool	if_wait_for_refresh,
		TABLE_LIST *	tables,
		bool	have_lock
	)

Definition at line 818 of file sql_base.cc.

References close_old_data_files(), COND_refresh, DBUG_ASSERT, DBUG_ENTER, DBUG_PRINT, hash_delete(), hash_element(), kill_delayed_threads(), LOCK_open, st_table_share::mutex, mysql_ha_flush(), st_table_share::next, st_table_list::next_local, oldest_unused_share, open_cache, pthread_mutex_lock, st_hash::records, refresh_version, remove_table_from_cache(), reopen_tables(), table_def_cache, TRUE, unused_tables, and VOID.

Referenced by reload_acl_and_cache(), and table_cache_free().

{
  bool result=0;
  DBUG_ENTER("close_cached_tables");
  DBUG_ASSERT(thd || (!if_wait_for_refresh && !tables));

  if (!have_lock)
    VOID(pthread_mutex_lock(&LOCK_open));
  if (!tables)
  {
    refresh_version++;                          // Force close of open tables
    while (unused_tables)
    {
#ifdef EXTRA_DEBUG
      if (hash_delete(&open_cache,(byte*) unused_tables))
        printf("Warning: Couldn't delete open table from hash\n");
#else
      VOID(hash_delete(&open_cache,(byte*) unused_tables));
#endif
    }
    /* Free table shares */
    while (oldest_unused_share->next)
    {
      pthread_mutex_lock(&oldest_unused_share->mutex);
      VOID(hash_delete(&table_def_cache, (byte*) oldest_unused_share));
    }
  }
  else
  {
    bool found=0;
    for (TABLE_LIST *table= tables; table; table= table->next_local)
    {
      if ((!table->table || !table->table->s->log_table) &&
          remove_table_from_cache(thd, table->db, table->table_name,
                                  RTFC_OWNED_BY_THD_FLAG))
        found=1;
    }
    if (!found)
      if_wait_for_refresh=0;                    // Nothing to wait for
  }
#ifndef EMBEDDED_LIBRARY
  if (!tables)
    kill_delayed_threads();
#endif
  if (if_wait_for_refresh)
  {
    /*
      If there is any table that has a lower refresh_version, wait until
      this is closed (or this thread is killed) before returning
    */
    thd->mysys_var->current_mutex= &LOCK_open;
    thd->mysys_var->current_cond= &COND_refresh;
    thd->proc_info="Flushing tables";

    close_old_data_files(thd,thd->open_tables,1,1);
    mysql_ha_flush(thd, tables, MYSQL_HA_REOPEN_ON_USAGE | MYSQL_HA_FLUSH_ALL,
                   TRUE);
    bool found=1;
    /* Wait until all threads has closed all the tables we had locked */
    DBUG_PRINT("info",
               ("Waiting for other threads to close their open tables"));
    while (found && ! thd->killed)
    {
      found=0;
      for (uint idx=0 ; idx < open_cache.records ; idx++)
      {
        TABLE *table=(TABLE*) hash_element(&open_cache,idx);
        if (!table->s->log_table &&
            ((table->s->version) < refresh_version && table->db_stat))
        {
          found=1;
          DBUG_PRINT("signal", ("Waiting for COND_refresh"));
          pthread_cond_wait(&COND_refresh,&LOCK_open);
          break;
        }
      }
    }
    /*
      No other thread has the locked tables open; reopen them and get the
      old locks. This should always succeed (unless some external process
      has removed the tables)
    */
    thd->in_lock_tables=1;
    result=reopen_tables(thd,1,1);
    thd->in_lock_tables=0;
    /* Set version for table */
    for (TABLE *table=thd->open_tables; table ; table= table->next)
      table->s->version= refresh_version;
  }
  if (!have_lock)
    VOID(pthread_mutex_unlock(&LOCK_open));
  if (if_wait_for_refresh)
  {
    pthread_mutex_lock(&thd->mysys_var->mutex);
    thd->mysys_var->current_mutex= 0;
    thd->mysys_var->current_cond= 0;
    thd->proc_info=0;
    pthread_mutex_unlock(&thd->mysys_var->mutex);
  }
  DBUG_RETURN(result);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool close_data_tables	(	THD *	thd,
		const char *	db,
		const char *	table_name
	)

Definition at line 2234 of file sql_base.cc.

References close_handle_and_leave_table_as_lock(), st_table_share::db, DBUG_ENTER, DBUG_RETURN, mysql_lock_remove(), st_table::next, st_table::s, LEX_STRING::str, strcmp(), and st_table_share::table_name.

{
  TABLE *table;
  DBUG_ENTER("close_data_tables");

  for (table=thd->open_tables; table ; table=table->next)
  {
    if (!strcmp(table->s->table_name.str, table_name) &&
        !strcmp(table->s->db.str, db))
    {
      mysql_lock_remove(thd, thd->locked_tables,table);
      close_handle_and_leave_table_as_lock(table);
    }
  }
  DBUG_RETURN(0);                               // For the future
}

Here is the call graph for this function:

static void close_handle_and_leave_table_as_lock

(

TABLE *

table

)

[static]

Definition at line 634 of file sql_base.cc.

References bzero, handler::close(), st_table::db_stat, DBUG_ENTER, DBUG_VOID_RETURN, st_table::file, INTERNAL_TMP_TABLE, LEX_STRING::length, st_table::mem_root, multi_alloc_root(), NULL, RELEASE_NORMAL, release_table_share(), st_table::s, LEX_STRING::str, and st_table_share::table_cache_key.

Referenced by close_data_tables(), and close_old_data_files().

{
  TABLE_SHARE *share, *old_share= table->s;
  char *key_buff;
  MEM_ROOT *mem_root= &table->mem_root;
  DBUG_ENTER("close_handle_and_leave_table_as_lock");

  /*
    Make a local copy of the table share and free the current one.
    This has to be done to ensure that the table share is removed from
    the table defintion cache as soon as the last instance is removed
  */
  if (multi_alloc_root(mem_root,
                       &share, sizeof(*share),
                       &key_buff, old_share->table_cache_key.length,
                       NULL))
  {
    bzero((char*) share, sizeof(*share));
    share->set_table_cache_key(key_buff, old_share->table_cache_key.str,
                               old_share->table_cache_key.length);
    share->tmp_table= INTERNAL_TMP_TABLE;       // for intern_close_table()
  }

  table->file->close();
  table->db_stat= 0;                            // Mark file closed
  release_table_share(table->s, RELEASE_NORMAL);
  table->s= share;

  DBUG_VOID_RETURN;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void close_old_data_files	(	THD *	thd,
		TABLE *	table,
		bool	abort_locks,
		bool	send_refresh
	)			[static]

Definition at line 2333 of file sql_base.cc.

References close_handle_and_leave_table_as_lock(), st_table::db_stat, DBUG_ENTER, st_table::locked_by_flush, st_table_share::log_table, mysql_lock_abort(), mysql_lock_remove(), st_table::next, refresh_version, st_table::s, TRUE, and st_table_share::version.

Referenced by close_cached_tables(), open_table(), and wait_for_tables().

{
  bool found= send_refresh;
  DBUG_ENTER("close_old_data_files");

  for (; table ; table=table->next)
  {
    /*
      Reopen marked for flush. But close log tables. They are flushed only
      explicitly on FLUSH LOGS
    */
    if (table->s->version != refresh_version && !table->s->log_table)
    {
      found=1;
      if (table->db_stat)
      {
        if (abort_locks)
        {
          mysql_lock_abort(thd,table, TRUE);    // Close waiting threads
          mysql_lock_remove(thd, thd->locked_tables,table);
          table->locked_by_flush=1;             // Will be reopened with locks
        }
        close_handle_and_leave_table_as_lock(table);
      }
    }
  }
  if (found)
    broadcast_refresh();
  DBUG_VOID_RETURN;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void close_open_tables_and_downgrade

(

ALTER_PARTITION_PARAM_TYPE *

lpt

)

Definition at line 6415 of file sql_base.cc.

References LOCK_open, mysql_lock_downgrade_write(), pthread_mutex_lock, pthread_mutex_unlock, remove_table_from_cache(), and VOID.

{
  VOID(pthread_mutex_lock(&LOCK_open));
  remove_table_from_cache(lpt->thd, lpt->db, lpt->table_name,
                          RTFC_WAIT_OTHER_THREAD_FLAG);
  VOID(pthread_mutex_unlock(&LOCK_open));
  mysql_lock_downgrade_write(lpt->thd, lpt->table, lpt->old_lock_type);
}

Here is the call graph for this function:

void close_tables_for_reopen	(	THD *	thd,
		TABLE_LIST **	tables
	)

Definition at line 3452 of file sql_base.cc.

References close_thread_tables(), mark_used_tables_as_free_for_reuse(), st_table_list::next_global, and sp_remove_not_own_routines().

Referenced by get_all_tables(), mysql_test_update(), mysql_update(), open_and_lock_tables(), and simple_open_n_lock_tables().

{
  /*
    If table list consists only from tables from prelocking set, table list
    for new attempt should be empty, so we have to update list's root pointer.
  */
  if (thd->lex->first_not_own_table() == *tables)
    *tables= 0;
  thd->lex->chop_off_not_own_tables();
  sp_remove_not_own_routines(thd->lex);
  for (TABLE_LIST *tmp= *tables; tmp; tmp= tmp->next_global)
    tmp->table= 0;
  mark_used_tables_as_free_for_reuse(thd, thd->temporary_tables);
  close_thread_tables(thd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void close_temporary	(	TABLE *	table,
		bool	free_share,
		bool	delete_table
	)

Definition at line 1571 of file sql_base.cc.

References closefrm(), st_table_share::db_type, DBUG_ENTER, DBUG_VOID_RETURN, free_io_cache(), free_table_share(), my_free, MYF, st_table_share::path, rm_temporary_table(), st_table::s, and LEX_STRING::str.

Referenced by close_temporary_table(), and close_temporary_tables().

{
  handlerton *table_type= table->s->db_type;
  DBUG_ENTER("close_temporary");

  free_io_cache(table);
  closefrm(table, 0);
  if (delete_table)
    rm_temporary_table(table_type, table->s->path.str);
  if (free_share)
  {
    free_table_share(table->s);
    my_free((char*) table,MYF(0));
  }
  DBUG_VOID_RETURN;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void close_temporary_table	(	THD *	thd,
		TABLE *	table,
		bool	free_share,
		bool	delete_table
	)

Definition at line 1531 of file sql_base.cc.

References close_temporary(), DBUG_ASSERT, st_table::next, st_table::prev, and slave_open_temp_tables.

{
  if (table->prev)
  {
    table->prev->next= table->next;
    if (table->prev->next)
      table->next->prev= table->prev;
  }
  else
  {
    /* removing the item from the list */
    DBUG_ASSERT(table == thd->temporary_tables);
    /*
      slave must reset its temporary list pointer to zero to exclude
      passing non-zero value to end_slave via rli->save_temporary_tables
      when no temp tables opened, see an invariant below.
    */
    thd->temporary_tables= table->next;
    if (thd->temporary_tables)
      table->next->prev= 0;
  }
  if (thd->slave_thread)
  {
    /* natural invariant of temporary_tables */
    DBUG_ASSERT(slave_open_temp_tables || !thd->temporary_tables);
    slave_open_temp_tables--;
  }
  close_temporary(table, free_share, delete_table);
}

Here is the call graph for this function:

bool close_temporary_table	(	THD *	thd,
		TABLE_LIST *	table_list
	)

Definition at line 1517 of file sql_base.cc.

References find_temporary_table().

Referenced by mysql_rm_table_part2(), and mysql_truncate().

{
  TABLE *table;

  if (!(table= find_temporary_table(thd, table_list)))
    return 1;
  close_temporary_table(thd, table, 1, 1);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void close_temporary_tables

(

THD *

thd

)

Definition at line 1177 of file sql_base.cc.

References append_identifier(), buf, close_temporary(), FALSE, MYSQL_LOG::is_open(), String::length(), LINT_INIT, memcpy, mysql_bin_log, st_table::next, NULL, OPTION_QUOTE_SHOW_CREATE, String::ptr(), String::q_append(), strlen(), system_charset_info, tmpkeyval(), and MYSQL_BIN_LOG::write().

{
  TABLE *table;
  if (!thd->temporary_tables)
    return;

  if (!mysql_bin_log.is_open() || thd->current_stmt_binlog_row_based)
  {
    TABLE *next;
    for (table= thd->temporary_tables; table; table= next)
    {
      next=table->next;
      close_temporary(table, 1, 1);
    }
    thd->temporary_tables= 0;
    return;
  }

  TABLE *next,
    *prev_table /* TODO: 5.1 maintaines prev link in temporary_tables
                   double-linked list so we could fix it. But it is not necessary
                   at this time when the list is being destroyed */;
  bool was_quote_show= true; /* to assume thd->options has OPTION_QUOTE_SHOW_CREATE */
  // Better add "if exists", in case a RESET MASTER has been done
  const char stub[]= "DROP /*!40005 TEMPORARY */ TABLE IF EXISTS ";
  uint stub_len= sizeof(stub) - 1;
  char buf[256];
  memcpy(buf, stub, stub_len);
  String s_query= String(buf, sizeof(buf), system_charset_info);
  bool found_user_tables= false;
  LINT_INIT(next);

  /*
     insertion sort of temp tables by pseudo_thread_id to build ordered list
     of sublists of equal pseudo_thread_id
  */

  for (prev_table= thd->temporary_tables, table= prev_table->next;
       table;
       prev_table= table, table= table->next)
  {
    TABLE *prev_sorted /* same as for prev_table */, *sorted;
    if (is_user_table(table))
    {
      if (!found_user_tables)
        found_user_tables= true;
      for (prev_sorted= NULL, sorted= thd->temporary_tables; sorted != table;
           prev_sorted= sorted, sorted= sorted->next)
      {
        if (!is_user_table(sorted) ||
            tmpkeyval(thd, sorted) > tmpkeyval(thd, table))
        {
          /* move into the sorted part of the list from the unsorted */
          prev_table->next= table->next;
          table->next= sorted;
          if (prev_sorted)
          {
            prev_sorted->next= table;
          }
          else
          {
            thd->temporary_tables= table;
          }
          table= prev_table;
          break;
        }
      }
    }
  }

  /* We always quote db,table names though it is slight overkill */
  if (found_user_tables &&
      !(was_quote_show= (thd->options & OPTION_QUOTE_SHOW_CREATE)))
  {
    thd->options |= OPTION_QUOTE_SHOW_CREATE;
  }

  /* scan sorted tmps to generate sequence of DROP */
  for (table= thd->temporary_tables; table; table= next)
  {
    if (is_user_table(table))
    {
      /* Set pseudo_thread_id to be that of the processed table */
      thd->variables.pseudo_thread_id= tmpkeyval(thd, table);
      /* Loop forward through all tables within the sublist of
         common pseudo_thread_id to create single DROP query */
      for (s_query.length(stub_len);
           table && is_user_table(table) &&
             tmpkeyval(thd, table) == thd->variables.pseudo_thread_id;
           table= next)
      {
        /*
          We are going to add 4 ` around the db/table names and possible more
          due to special characters in the names
        */
        append_identifier(thd, &s_query, table->s->db.str, strlen(table->s->db.str));
        s_query.q_append('.');
        append_identifier(thd, &s_query, table->s->table_name.str,
                          strlen(table->s->table_name.str));
        s_query.q_append(',');
        next= table->next;
        close_temporary(table, 1, 1);
      }
      thd->clear_error();
      CHARSET_INFO *cs_save= thd->variables.character_set_client;
      thd->variables.character_set_client= system_charset_info;
      Query_log_event qinfo(thd, s_query.ptr(),
                            s_query.length() - 1 /* to remove trailing ',' */,
                            0, FALSE);
      thd->variables.character_set_client= cs_save;
      /*
        Imagine the thread had created a temp table, then was doing a SELECT, and
        the SELECT was killed. Then it's not clever to mark the statement above as
        "killed", because it's not really a statement updating data, and there
        are 99.99% chances it will succeed on slave.
        If a real update (one updating a persistent table) was killed on the
        master, then this real update will be logged with error_code=killed,
        rightfully causing the slave to stop.
      */
      qinfo.error_code= 0;
      mysql_bin_log.write(&qinfo);
    }
    else
    {
      next= table->next;
      close_temporary(table, 1, 1);
    }
  }
  if (!was_quote_show)
    thd->options &= ~OPTION_QUOTE_SHOW_CREATE; /* restore option */
  thd->temporary_tables=0;
}

Here is the call graph for this function:

bool close_thread_table	(	THD *	thd,
		TABLE **	table_ptr
	)

Definition at line 1126 of file sql_base.cc.

References st_table::db_stat, DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, handler::extra(), st_table::file, flush_version, st_table_share::flush_version, HA_EXTRA_FLUSH, handler::ha_reset(), hash_delete(), st_table::in_use, handler::inited, st_table::key_read, st_table::next, handler::NONE, open_cache, st_table::prev, refresh_version, st_table::s, unused_tables, st_table_share::version, and VOID.

Referenced by close_thread_tables(), mysql_ha_close(), and mysql_ha_flush_table().

{
  bool found_old_table= 0;
  TABLE *table= *table_ptr;
  DBUG_ENTER("close_thread_table");
  DBUG_ASSERT(table->key_read == 0);
  DBUG_ASSERT(table->file->inited == handler::NONE);

  *table_ptr=table->next;
  if (table->s->version != refresh_version ||
      thd->version != refresh_version || !table->db_stat)
  {
    VOID(hash_delete(&open_cache,(byte*) table));
    found_old_table=1;
  }
  else
  {
    if (table->s->flush_version != flush_version)
    {
      table->s->flush_version= flush_version;
      table->file->extra(HA_EXTRA_FLUSH);
    }
    // Free memory and reset for next loop
    table->file->ha_reset();
    table->in_use=0;
    if (unused_tables)
    {
      table->next=unused_tables;                /* Link in last */
      table->prev=unused_tables->prev;
      unused_tables->prev=table;
      table->prev->next=table;
    }
    else
      unused_tables=table->next=table->prev=table;
  }
  DBUG_RETURN(found_old_table);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void close_thread_tables	(	THD *	thd,
		bool	lock_in_use,
		bool	skip_derived
	)

Definition at line 982 of file sql_base.cc.

References broadcast_refresh(), bzero, check_unused, close_thread_table(), DBUG_ASSERT, DBUG_ENTER, DBUG_PRINT, DBUG_VOID_RETURN, free_tmp_table(), ha_commit_stmt, hash_delete(), LOCK_open, mark_used_tables_as_free_for_reuse(), mysql_unlock_tables(), st_table::next, open_cache, OPTION_TABLE_LOCK, pthread_mutex_lock, pthread_mutex_unlock, st_hash::records, table_cache_size, TRUE, unused_tables, and VOID.

{
  bool found_old_table;
  prelocked_mode_type prelocked_mode= thd->prelocked_mode;
  DBUG_ENTER("close_thread_tables");

  /*
    We are assuming here that thd->derived_tables contains ONLY derived
    tables for this substatement. i.e. instead of approach which uses
    query_id matching for determining which of the derived tables belong
    to this substatement we rely on the ability of substatements to
    save/restore thd->derived_tables during their execution.

    TODO: Probably even better approach is to simply associate list of
          derived tables with (sub-)statement instead of thread and destroy
          them at the end of its execution.
  */
  if (thd->derived_tables && !skip_derived)
  {
    TABLE *table, *next;
    /*
      Close all derived tables generated in queries like
      SELECT * FROM (SELECT * FROM t1)
    */
    for (table= thd->derived_tables ; table ; table= next)
    {
      next= table->next;
      free_tmp_table(thd, table);
    }
    thd->derived_tables= 0;
  }

  if (prelocked_mode)
  {
    /*
      Mark all temporary tables used by this substatement as free for reuse.
    */
    mark_used_tables_as_free_for_reuse(thd, thd->temporary_tables);
  }

  if (thd->locked_tables || prelocked_mode)
  {
    /*
      Let us commit transaction for statement. Since in 5.0 we only have
      one statement transaction and don't allow several nested statement
      transactions this call will do nothing if we are inside of stored
      function or trigger (i.e. statement transaction is already active and
      does not belong to statement for which we do close_thread_tables()).
      TODO: This should be fixed in later releases.
    */
    ha_commit_stmt(thd);

    /* Ensure we are calling ha_reset() for all used tables */
    mark_used_tables_as_free_for_reuse(thd, thd->open_tables);

    /* We are under simple LOCK TABLES so should not do anything else. */
    if (!prelocked_mode || !thd->lex->requires_prelocking())
      DBUG_VOID_RETURN;

    /*
      We are in prelocked mode, so we have to leave it now with doing
      implicit UNLOCK TABLES if need.
    */
    DBUG_PRINT("info",("thd->prelocked_mode= NON_PRELOCKED"));
    thd->prelocked_mode= NON_PRELOCKED;

    if (prelocked_mode == PRELOCKED_UNDER_LOCK_TABLES)
      DBUG_VOID_RETURN;

    thd->lock= thd->locked_tables;
    thd->locked_tables= 0;
    /* Fallthrough */
  }

  if (thd->lock)
  {
    /*
      For RBR we flush the pending event just before we unlock all the
      tables.  This means that we are at the end of a topmost
      statement, so we ensure that the STMT_END_F flag is set on the
      pending event.  For statements that are *inside* stored
      functions, the pending event will not be flushed: that will be
      handled either before writing a query log event (inside
      binlog_query()) or when preparing a pending event.
     */
#ifdef HAVE_ROW_BASED_REPLICATION
    thd->binlog_flush_pending_rows_event(TRUE);
#endif /*HAVE_ROW_BASED_REPLICATION*/
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;
  }
  /*
    assume handlers auto-commit (if some doesn't - transaction handling
    in MySQL should be redesigned to support it; it's a big change,
    and it's not worth it - better to commit explicitly only writing
    transactions, read-only ones should better take care of themselves.
    saves some work in 2pc too)
    see also sql_parse.cc - dispatch_command()
  */
  if (!(thd->state_flags & Open_tables_state::BACKUPS_AVAIL))
    bzero(&thd->transaction.stmt, sizeof(thd->transaction.stmt));
  if (!thd->active_transaction())
    thd->transaction.xid_state.xid.null();

  /* VOID(pthread_sigmask(SIG_SETMASK,&thd->block_signals,NULL)); */
  if (!lock_in_use)
    VOID(pthread_mutex_lock(&LOCK_open));

  DBUG_PRINT("info", ("thd->open_tables: %p", thd->open_tables));

  found_old_table= 0;
  while (thd->open_tables)
    found_old_table|= close_thread_table(thd, &thd->open_tables);
  thd->some_tables_deleted=0;

  /* Free tables to hold down open files */
  while (open_cache.records > table_cache_size && unused_tables)
    VOID(hash_delete(&open_cache,(byte*) unused_tables)); /* purecov: tested */
  check_unused();
  if (found_old_table)
  {
    /* Tell threads waiting for refresh that something has happened */
    broadcast_refresh();
  }
  if (!lock_in_use)
    VOID(pthread_mutex_unlock(&LOCK_open));
  /*  VOID(pthread_sigmask(SIG_SETMASK,&thd->signals,NULL)); */

  if (prelocked_mode == PRELOCKED)
  {
    /*
      If we are here then we are leaving normal prelocked mode, so it is
      good idea to turn off OPTION_TABLE_LOCK flag.
    */
    DBUG_ASSERT(thd->lex->requires_prelocking());
    thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
  }

  DBUG_VOID_RETURN;
}

Here is the call graph for this function:

uint create_table_def_key	(	THD *	thd,
		char *	key,
		TABLE_LIST *	table_list,
		bool	tmp_table
	)

Definition at line 176 of file sql_base.cc.

References st_table_list::db, int4store, key_length, strmov(), and st_table_list::table_name.

Referenced by find_temporary_table(), get_cached_table_share(), lock_table_name(), open_table(), open_temporary_table(), prepare_for_repair(), and rename_temporary_table().

{
  uint key_length= (uint) (strmov(strmov(key, table_list->db)+1,
                                  table_list->table_name)-key)+1;
  if (tmp_table)
  {
    int4store(key + key_length, thd->server_id);
    int4store(key + key_length + 4, thd->variables.pseudo_thread_id);
    key_length+= TMP_TABLE_KEY_EXTRA;
  }
  return key_length;
}

Here is the call graph for this function:

Here is the caller graph for this function:

TABLE* drop_locked_tables	(	THD *	thd,
		const char *	db,
		const char *	table_name
	)

Definition at line 2478 of file sql_base.cc.

References broadcast_refresh(), handler::close(), st_table_share::db, st_table::db_stat, DBUG_ENTER, DBUG_RETURN, st_table::file, hash_delete(), my_free, MYF, mysql_lock_remove(), st_table::next, open_cache, st_table::s, LEX_STRING::str, strcmp(), st_table_share::table_name, and VOID.

Referenced by mysql_rm_table_part2().

{
  TABLE *table,*next,**prev, *found= 0;
  prev= &thd->open_tables;
  DBUG_ENTER("drop_locked_tables");

  for (table= thd->open_tables; table ; table=next)
  {
    next=table->next;
    if (!strcmp(table->s->table_name.str, table_name) &&
        !strcmp(table->s->db.str, db))
    {
      mysql_lock_remove(thd, thd->locked_tables,table);
      if (!found)
      {
        found= table;
        /* Close engine table, but keep object around as a name lock */
        if (table->db_stat)
        {
          table->db_stat= 0;
          table->file->close();
        }
      }
      else
      {
        /* We already have a name lock, remove copy */
        VOID(hash_delete(&open_cache,(byte*) table));
      }
    }
    else
    {
      *prev=table;
      prev= &table->next;
    }
  }
  *prev=0;
  if (found)
    broadcast_refresh();
  if (thd->locked_tables && thd->locked_tables->table_count == 0)
  {
    my_free((gptr) thd->locked_tables,MYF(0));
    thd->locked_tables=0;
  }
  DBUG_RETURN(found);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool fill_record	(	THD *	thd,
		Field **	ptr,
		List< Item > &	values,
		bool	ignore_errors
	)

Definition at line 5968 of file sql_base.cc.

References st_table::auto_increment_field_not_null, DBUG_ENTER, DBUG_RETURN, st_table::next_number_field, Field::table, TRUE, and value.

{
  List_iterator_fast<Item> v(values);
  Item *value;
  DBUG_ENTER("fill_record");

  Field *field;
  while ((field = *ptr++))
  {
    value=v++;
    TABLE *table= field->table;
    if (field == table->next_number_field)
      table->auto_increment_field_not_null= TRUE;
    if (value->save_in_field(field, 0) == -1)
      DBUG_RETURN(TRUE);
  }
  DBUG_RETURN(thd->net.report_error);
}

static bool fill_record	(	THD *	thd,
		List< Item > &	fields,
		List< Item > &	values,
		bool	ignore_errors
	)			[static]

Definition at line 5887 of file sql_base.cc.

References st_table::auto_increment_field_not_null, DBUG_ENTER, DBUG_RETURN, ER, ER_NONUPDATEABLE_COLUMN, ER_UNKNOWN_ERROR, f, Item_field::field, Item::filed_for_view_update(), my_error(), my_message(), MYF, Item::name, st_table::next_number_field, Field::table, TRUE, and value.

Referenced by fill_record_n_invoke_before_triggers().

{
  List_iterator_fast<Item> f(fields),v(values);
  Item *value, *fld;
  Item_field *field;
  DBUG_ENTER("fill_record");

  while ((fld= f++))
  {
    if (!(field= fld->filed_for_view_update()))
    {
      my_error(ER_NONUPDATEABLE_COLUMN, MYF(0), fld->name);
      DBUG_RETURN(TRUE);
    }
    value=v++;
    Field *rfield= field->field;
    TABLE *table= rfield->table;
    if (rfield == table->next_number_field)
      table->auto_increment_field_not_null= TRUE;
    if ((value->save_in_field(rfield, 0) < 0) && !ignore_errors)
    {
      my_message(ER_UNKNOWN_ERROR, ER(ER_UNKNOWN_ERROR), MYF(0));
      DBUG_RETURN(TRUE);
    }
  }
  DBUG_RETURN(thd->net.report_error);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool fill_record_n_invoke_before_triggers	(	THD *	thd,
		Field **	ptr,
		List< Item > &	values,
		bool	ignore_errors,
		Table_triggers_list *	triggers,
		enum trg_event_type	event
	)

Definition at line 6012 of file sql_base.cc.

References fill_record(), Table_triggers_list::process_triggers(), TRG_ACTION_BEFORE, and TRUE.

{
  return (fill_record(thd, ptr, values, ignore_errors) ||
          triggers && triggers->process_triggers(thd, event,
                                                 TRG_ACTION_BEFORE, TRUE));
}

Here is the call graph for this function:

bool fill_record_n_invoke_before_triggers	(	THD *	thd,
		List< Item > &	fields,
		List< Item > &	values,
		bool	ignore_errors,
		Table_triggers_list *	triggers,
		enum trg_event_type	event
	)

Definition at line 5941 of file sql_base.cc.

References fill_record(), Table_triggers_list::process_triggers(), TRG_ACTION_BEFORE, and TRUE.

Referenced by mysql_insert(), read_fixed_length(), read_sep_field(), and write_record().

{
  return (fill_record(thd, fields, values, ignore_errors) ||
          triggers && triggers->process_triggers(thd, event,
                                                 TRG_ACTION_BEFORE, TRUE));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static Field* find_field_in_natural_join	(	THD *	thd,
		TABLE_LIST *	table_ref,
		const char *	name,
		uint	length,
		Item **	ref,
		bool	register_tree_change,
		TABLE_LIST **	actual_table
	)			[static]

Definition at line 3748 of file sql_base.cc.

References backup, Natural_join_column::create_item(), DBUG_ASSERT, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, st_table_list::is_natural_join, Field_translator::item, st_table_list::join_columns, LINT_INIT, my_strcasecmp, Natural_join_column::name(), NULL, st_table_list::schema_table_reformed, system_charset_info, Field::table, st_table_list::table, Natural_join_column::table_field, Natural_join_column::table_ref, update_field_dependencies(), Natural_join_column::view_field, and view_ref_found.

Referenced by find_field_in_table_ref().

{
  List_iterator_fast<Natural_join_column>
    field_it(*(table_ref->join_columns));
  Natural_join_column *nj_col;
  Field *found_field;
  Query_arena *arena, backup;
  DBUG_ENTER("find_field_in_natural_join");
  DBUG_PRINT("enter", ("field name: '%s', ref 0x%lx",
                       name, (ulong) ref));
  DBUG_ASSERT(table_ref->is_natural_join && table_ref->join_columns);
  DBUG_ASSERT(*actual_table == NULL);

  LINT_INIT(arena);
  LINT_INIT(found_field);

  for (;;)
  {
    if (!(nj_col= field_it++))
      DBUG_RETURN(NULL);

    if (!my_strcasecmp(system_charset_info, nj_col->name(), name))
      break;
  }

  if (nj_col->view_field)
  {
    Item *item;
    if (register_tree_change)
      arena= thd->activate_stmt_arena_if_needed(&backup);
    /*
      create_item() may, or may not create a new Item, depending on the
      column reference. See create_view_field() for details.
    */
    item= nj_col->create_item(thd);
    if (register_tree_change && arena)
      thd->restore_active_arena(arena, &backup);

    if (!item)
      DBUG_RETURN(NULL);
    DBUG_ASSERT(nj_col->table_field == NULL);
    if (nj_col->table_ref->schema_table_reformed)
    {
      /*
        Translation table items are always Item_fields and fixed
        already('mysql_schema_table' function). So we can return
        ->field. It is used only for 'show & where' commands.
      */
      DBUG_RETURN(((Item_field*) (nj_col->view_field->item))->field);
    }
    if (register_tree_change)
      thd->change_item_tree(ref, item);
    else
      *ref= item;
    found_field= (Field*) view_ref_found;
  }
  else
  {
    /* This is a base table. */
    DBUG_ASSERT(nj_col->view_field == NULL);
    DBUG_ASSERT(nj_col->table_ref->table == nj_col->table_field->table);
    found_field= nj_col->table_field;
    update_field_dependencies(thd, found_field, nj_col->table_ref->table);
  }

  *actual_table= nj_col->table_ref;
  
  DBUG_RETURN(found_field);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Field* find_field_in_table	(	THD *	thd,
		TABLE *	table,
		const char *	name,
		uint	length,
		bool	allow_rowid,
		uint *	cached_field_index_ptr
	)

Definition at line 3840 of file sql_base.cc.

References st_table::alias, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, st_table_share::field, st_table::field, Field::field_name, hash_search(), my_strcasecmp, st_table_share::name_hash, st_hash::records, st_table_share::rowid_field_offset, st_table::s, system_charset_info, and update_field_dependencies().

Referenced by find_field_in_table_ref(), find_field_in_tables(), and Item_trigger_field::setup_field().

{
  Field **field_ptr, *field;
  uint cached_field_index= *cached_field_index_ptr;
  DBUG_ENTER("find_field_in_table");
  DBUG_PRINT("enter", ("table: '%s', field name: '%s'", table->alias, name));

  /* We assume here that table->field < NO_CACHED_FIELD_INDEX = UINT_MAX */
  if (cached_field_index < table->s->fields &&
      !my_strcasecmp(system_charset_info,
                     table->field[cached_field_index]->field_name, name))
    field_ptr= table->field + cached_field_index;
  else if (table->s->name_hash.records)
  {
    field_ptr= (Field**) hash_search(&table->s->name_hash, (byte*) name,
                                     length);
    if (field_ptr)
    {
      /*
        field_ptr points to field in TABLE_SHARE. Convert it to the matching
        field in table
      */
      field_ptr= (table->field + (field_ptr - table->s->field));
    }
  }
  else
  {
    if (!(field_ptr= table->field))
      DBUG_RETURN((Field *)0);
    for (; *field_ptr; ++field_ptr)
      if (!my_strcasecmp(system_charset_info, (*field_ptr)->field_name, name))
        break;
  }

  if (field_ptr && *field_ptr)
  {
    *cached_field_index_ptr= field_ptr - table->field;
    field= *field_ptr;
  }
  else
  {
    if (!allow_rowid ||
        my_strcasecmp(system_charset_info, name, "_rowid") ||
        table->s->rowid_field_offset == 0)
      DBUG_RETURN((Field*) 0);
    field= table->field[table->s->rowid_field_offset-1];
  }

  update_field_dependencies(thd, field, table);

  DBUG_RETURN(field);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Field* find_field_in_table_ref	(	THD *	thd,
		TABLE_LIST *	table_list,
		const char *	name,
		uint	length,
		const char *	item_name,
		const char *	db_name,
		const char *	table_name,
		Item **	ref,
		bool	check_privileges,
		bool	allow_rowid,
		uint *	cached_field_index_ptr,
		bool	register_tree_change,
		TABLE_LIST **	actual_table
	)

Definition at line 3938 of file sql_base.cc.

References st_table_list::alias, bitmap_set_bit(), check_column_grant_in_table_ref(), st_table_list::db, DBUG_ASSERT, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, Field::field_index, Item::FIELD_ITEM, st_table_list::field_translation, find_field_in_natural_join(), find_field_in_table(), find_field_in_view(), st_nested_join::join_list, MARK_COLUMNS_NONE, MARK_COLUMNS_READ, my_strcasecmp, st_table_list::nested_join, NULL, st_table::read_set, Item::register_field_in_read_map(), strcmp(), Field::table, st_table_list::table, table_alias_charset, Item::type(), view_ref_found, Item::walk(), st_table::write_set, and WRONG_GRANT.

Referenced by find_field_in_tables(), and mysql_table_grant().

{
  Field *fld;
  DBUG_ENTER("find_field_in_table_ref");
  DBUG_PRINT("enter",
             ("table: '%s'  field name: '%s'  item name: '%s'  ref 0x%lx",
              table_list->alias, name, item_name, (ulong) ref));

  /*
    Check that the table and database that qualify the current field name
    are the same as the table reference we are going to search for the field.

    Exclude from the test below nested joins because the columns in a
    nested join generally originate from different tables. Nested joins
    also have no table name, except when a nested join is a merge view
    or an information schema table.

    We include explicitly table references with a 'field_translation' table,
    because if there are views over natural joins we don't want to search
    inside the view, but we want to search directly in the view columns
    which are represented as a 'field_translation'.

    TODO: Ensure that table_name, db_name and tables->db always points to
          something !
  */
  if (/* Exclude nested joins. */
      (!table_list->nested_join ||
       /* Include merge views and information schema tables. */
       table_list->field_translation) &&
      /*
        Test if the field qualifiers match the table reference we plan
        to search.
      */
      table_name && table_name[0] &&
      (my_strcasecmp(table_alias_charset, table_list->alias, table_name) ||
       (db_name && db_name[0] && table_list->db && table_list->db[0] &&
        strcmp(db_name, table_list->db))))
    DBUG_RETURN(0);

  *actual_table= NULL;

  if (table_list->field_translation)
  {
    /* 'table_list' is a view or an information schema table. */
    if ((fld= find_field_in_view(thd, table_list, name, length, item_name, ref,
                                 register_tree_change)))
      *actual_table= table_list;
  }
  else if (!table_list->nested_join)
  {
    /* 'table_list' is a stored table. */
    DBUG_ASSERT(table_list->table);
    if ((fld= find_field_in_table(thd, table_list->table, name, length,
                                  allow_rowid,
                                  cached_field_index_ptr)))
      *actual_table= table_list;
  }
  else
  {
    /*
      'table_list' is a NATURAL/USING join, or an operand of such join that
      is a nested join itself.

      If the field name we search for is qualified, then search for the field
      in the table references used by NATURAL/USING the join.
    */
    if (table_name && table_name[0])
    {
      List_iterator<TABLE_LIST> it(table_list->nested_join->join_list);
      TABLE_LIST *table;
      while ((table= it++))
      {
        if ((fld= find_field_in_table_ref(thd, table, name, length, item_name,
                                          db_name, table_name, ref,
                                          check_privileges, allow_rowid,
                                          cached_field_index_ptr,
                                          register_tree_change, actual_table)))
          DBUG_RETURN(fld);
      }
      DBUG_RETURN(0);
    }
    /*
      Non-qualified field, search directly in the result columns of the
      natural join. The condition of the outer IF is true for the top-most
      natural join, thus if the field is not qualified, we will search
      directly the top-most NATURAL/USING join.
    */
    fld= find_field_in_natural_join(thd, table_list, name, length, ref,
                                    register_tree_change, actual_table);
  }

  if (fld)
  {
#ifndef NO_EMBEDDED_ACCESS_CHECKS
    /* Check if there are sufficient access rights to the found field. */
    if (check_privileges &&
        check_column_grant_in_table_ref(thd, *actual_table, name, length))
      fld= WRONG_GRANT;
    else
#endif
      if (thd->mark_used_columns != MARK_COLUMNS_NONE)
      {
        /*
          Get rw_set correct for this field so that the handler
          knows that this field is involved in the query and gets
          retrieved/updated
         */
        Field *field_to_set= NULL;
        if (fld == view_ref_found)
        {
          Item *it= (*ref)->real_item();
          if (it->type() == Item::FIELD_ITEM)
            field_to_set= ((Item_field*)it)->field;
          else
          {
            if (thd->mark_used_columns == MARK_COLUMNS_READ)
              it->walk(&Item::register_field_in_read_map, 1, (byte *) 0);
          }
        }
        else
          field_to_set= fld;
        if (field_to_set)
        {
          TABLE *table= field_to_set->table;
          if (thd->mark_used_columns == MARK_COLUMNS_READ)
            bitmap_set_bit(table->read_set, field_to_set->field_index);
          else
            bitmap_set_bit(table->write_set, field_to_set->field_index);
        }
      }
  }
  DBUG_RETURN(fld);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Field* find_field_in_table_sef	(	TABLE *	table,
		const char *	name
	)

Definition at line 4094 of file sql_base.cc.

References st_table_share::field, st_table::field, hash_search(), my_strcasecmp, st_table_share::name_hash, st_hash::records, st_table::s, strlen(), and system_charset_info.

{
  Field **field_ptr;
  if (table->s->name_hash.records)
  {
    field_ptr= (Field**)hash_search(&table->s->name_hash,(byte*) name,
                                    strlen(name));
    if (field_ptr)
    {
      /*
        field_ptr points to field in TABLE_SHARE. Convert it to the matching
        field in table
      */
      field_ptr= (table->field + (field_ptr - table->s->field));
    }
  }
  else
  {
    if (!(field_ptr= table->field))
      return (Field *)0;
    for (; *field_ptr; ++field_ptr)
      if (!my_strcasecmp(system_charset_info, (*field_ptr)->field_name, name))
        break;
  }
  if (field_ptr)
    return *field_ptr;
  else
    return (Field *)0;
}

Here is the call graph for this function:

Field* find_field_in_tables	(	THD *	thd,
		Item_ident *	item,
		TABLE_LIST *	first_table,
		TABLE_LIST *	last_table,
		Item **	ref,
		find_item_error_report_type	report_error,
		bool	check_privileges,
		bool	register_tree_change
	)

Definition at line 4160 of file sql_base.cc.

References st_table_list::cacheable_table, Item_ident::cached_field_index, Item_ident::cached_table, db, Item_ident::db_name, DBUG_ASSERT, ER_BAD_FIELD_ERROR, ER_NON_UNIQ_ERROR, ER_UNKNOWN_TABLE, Item_ident::field_name, files_charset_info, find_field_in_table(), find_field_in_table_ref(), Item_ident::full_name(), lower_case_table_names, mark_select_range_as_dependent(), my_casedn_str, my_error(), MYF, Item::name, name, NAME_LEN, st_table_list::next_local, st_table_list::next_name_resolution_table, not_found_field, NULL, NullS, st_table_list::select_lex, strlen(), strmake(), strxnmov(), st_table_list::table, Item_ident::table_name, TRUE, st_table_list::view, and WRONG_GRANT.

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

{
  Field *found=0;
  const char *db= item->db_name;
  const char *table_name= item->table_name;
  const char *name= item->field_name;
  uint length=(uint) strlen(name);
  char name_buff[NAME_LEN+1];
  TABLE_LIST *cur_table= first_table;
  TABLE_LIST *actual_table;
  bool allow_rowid;

  if (!table_name || !table_name[0])
  {
    table_name= 0;                              // For easier test
    db= 0;
  }

  allow_rowid= table_name || (cur_table && !cur_table->next_local);

  if (item->cached_table)
  {
    /*
      This shortcut is used by prepared statements. We assume that
      TABLE_LIST *first_table is not changed during query execution (which
      is true for all queries except RENAME but luckily RENAME doesn't
      use fields...) so we can rely on reusing pointer to its member.
      With this optimization we also miss case when addition of one more
      field makes some prepared query ambiguous and so erroneous, but we
      accept this trade off.
    */
    TABLE_LIST *table_ref= item->cached_table;
    /*
      The condition (table_ref->view == NULL) ensures that we will call
      find_field_in_table even in the case of information schema tables
      when table_ref->field_translation != NULL.
      */
    if (table_ref->table && !table_ref->view)
      found= find_field_in_table(thd, table_ref->table, name, length,
                                 TRUE, &(item->cached_field_index));
    else
      found= find_field_in_table_ref(thd, table_ref, name, length, item->name,
                                     NULL, NULL, ref, check_privileges,
                                     TRUE, &(item->cached_field_index),
                                     register_tree_change,
                                     &actual_table);
    if (found)
    {
      if (found == WRONG_GRANT)
        return (Field*) 0;
      {
        SELECT_LEX *current_sel= thd->lex->current_select;
        SELECT_LEX *last_select= table_ref->select_lex;
        /*
          If the field was an outer referencee, mark all selects using this
          sub query as dependent on the outer query
        */
        if (current_sel != last_select)
          mark_select_range_as_dependent(thd, last_select, current_sel,
                                         found, *ref, item);
      }
      return found;
    }
  }

  if (db && lower_case_table_names)
  {
    /*
      convert database to lower case for comparison.
      We can't do this in Item_field as this would change the
      'name' of the item which may be used in the select list
    */
    strmake(name_buff, db, sizeof(name_buff)-1);
    my_casedn_str(files_charset_info, name_buff);
    db= name_buff;
  }

  if (last_table)
    last_table= last_table->next_name_resolution_table;

  for (; cur_table != last_table ;
       cur_table= cur_table->next_name_resolution_table)
  {
    Field *cur_field= find_field_in_table_ref(thd, cur_table, name, length,
                                              item->name, db, table_name, ref,
                                              check_privileges, allow_rowid,
                                              &(item->cached_field_index),
                                              register_tree_change,
                                              &actual_table);
    if (cur_field)
    {
      if (cur_field == WRONG_GRANT)
        return (Field*) 0;

      /*
        Store the original table of the field, which may be different from
        cur_table in the case of NATURAL/USING join.
      */
      item->cached_table= (!actual_table->cacheable_table || found) ?
                          0 : actual_table;

      DBUG_ASSERT(thd->where);
      /*
        If we found a fully qualified field we return it directly as it can't
        have duplicates.
       */
      if (db)
        return cur_field;

      if (found)
      {
        if (report_error == REPORT_ALL_ERRORS ||
            report_error == IGNORE_EXCEPT_NON_UNIQUE)
          my_error(ER_NON_UNIQ_ERROR, MYF(0),
                   table_name ? item->full_name() : name, thd->where);
        return (Field*) 0;
      }
      found= cur_field;
    }
  }

  if (found)
    return found;

  /*
    If the field was qualified and there were no tables to search, issue
    an error that an unknown table was given. The situation is detected
    as follows: if there were no tables we wouldn't go through the loop
    and cur_table wouldn't be updated by the loop increment part, so it
    will be equal to the first table.
  */
  if (table_name && (cur_table == first_table) &&
      (report_error == REPORT_ALL_ERRORS ||
       report_error == REPORT_EXCEPT_NON_UNIQUE))
  {
    char buff[NAME_LEN*2+1];
    if (db && db[0])
    {
      strxnmov(buff,sizeof(buff)-1,db,".",table_name,NullS);
      table_name=buff;
    }
    my_error(ER_UNKNOWN_TABLE, MYF(0), table_name, thd->where);
  }
  else
  {
    if (report_error == REPORT_ALL_ERRORS ||
        report_error == REPORT_EXCEPT_NON_UNIQUE)
      my_error(ER_BAD_FIELD_ERROR, MYF(0), item->full_name(), thd->where);
    else
      found= not_found_field;
  }
  return found;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static Field* find_field_in_view	(	THD *	thd,
		TABLE_LIST *	table_list,
		const char *	name,
		uint	length,
		const char *	item_name,
		Item **	ref,
		bool	register_tree_change
	)			[static]

Definition at line 3661 of file sql_base.cc.

References st_table_list::alias, backup, Field_iterator_view::create_item(), DBUG_ASSERT, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, Field_iterator_view::end_of_fields(), LINT_INIT, my_strcasecmp, Field_iterator_view::name(), Field_iterator_view::next(), Item::real_item(), st_table_list::schema_table_reformed, Field_iterator_view::set(), Item::set_name(), system_charset_info, st_table_list::view, and view_ref_found.

Referenced by find_field_in_table_ref().

{
  DBUG_ENTER("find_field_in_view");
  DBUG_PRINT("enter",
             ("view: '%s', field name: '%s', item name: '%s', ref 0x%lx",
              table_list->alias, name, item_name, (ulong) ref));
  Field_iterator_view field_it;
  field_it.set(table_list);
  Query_arena *arena, backup;  
  LINT_INIT(arena);
  
  DBUG_ASSERT(table_list->schema_table_reformed ||
              (ref != 0 && table_list->view != 0));
  for (; !field_it.end_of_fields(); field_it.next())
  {
    if (!my_strcasecmp(system_charset_info, field_it.name(), name))
    {
      // in PS use own arena or data will be freed after prepare
      if (register_tree_change)
        arena= thd->activate_stmt_arena_if_needed(&backup);
      /*
        create_item() may, or may not create a new Item, depending on
        the column reference. See create_view_field() for details.
      */
      Item *item= field_it.create_item(thd);
      if (register_tree_change && arena)
        thd->restore_active_arena(arena, &backup);
      
      if (!item)
        DBUG_RETURN(0);
      /*
       *ref != NULL means that *ref contains the item that we need to
       replace. If the item was aliased by the user, set the alias to
       the replacing item.
       We need to set alias on both ref itself and on ref real item.
      */
      if (*ref && !(*ref)->is_autogenerated_name)
      {
        item->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
        item->real_item()->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
      }
      if (register_tree_change)
        thd->change_item_tree(ref, item);
      else
        *ref= item;
      DBUG_RETURN((Field*) view_ref_found);
    }
  }
  DBUG_RETURN(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Item** find_item_in_list	(	Item *	find,
		List< Item > &	items,
		uint *	counter,
		find_item_error_report_type	report_error,
		bool *	unaliased
	)

Definition at line 4353 of file sql_base.cc.

References current_thd, ER_BAD_FIELD_ERROR, ER_NON_UNIQ_ERROR, FALSE, Item::FIELD_ITEM, find(), LINT_INIT, my_error(), my_strcasecmp, MYF, charset_info_st::name, not_found_item, List_iterator< T >::ref(), Item::REF_ITEM, strcmp(), system_charset_info, and TRUE.

Referenced by find_order_in_list(), Item_field::fix_fields(), resolve_ref_in_select_and_group(), and setup_new_fields().

{
  List_iterator<Item> li(items);
  Item **found=0, **found_unaliased= 0, *item;
  const char *db_name=0;
  const char *field_name=0;
  const char *table_name=0;
  bool found_unaliased_non_uniq= 0;
  uint unaliased_counter;

  LINT_INIT(unaliased_counter);                 // Dependent on found_unaliased

  *unaliased= FALSE;

  if (find->type() == Item::FIELD_ITEM  || find->type() == Item::REF_ITEM)
  {
    field_name= ((Item_ident*) find)->field_name;
    table_name= ((Item_ident*) find)->table_name;
    db_name=    ((Item_ident*) find)->db_name;
  }

  for (uint i= 0; (item=li++); i++)
  {
    if (field_name && item->real_item()->type() == Item::FIELD_ITEM)
    {
      Item_ident *item_field= (Item_ident*) item;

      /*
        In case of group_concat() with ORDER BY condition in the QUERY
        item_field can be field of temporary table without item name 
        (if this field created from expression argument of group_concat()),
        => we have to check presence of name before compare
      */ 
      if (!item_field->name)
        continue;

      if (table_name)
      {
        /*
          If table name is specified we should find field 'field_name' in
          table 'table_name'. According to SQL-standard we should ignore
          aliases in this case.

          Since we should NOT prefer fields from the select list over
          other fields from the tables participating in this select in
          case of ambiguity we have to do extra check outside this function.

          We use strcmp for table names and database names as these may be
          case sensitive. In cases where they are not case sensitive, they
          are always in lower case.

          item_field->field_name and item_field->table_name can be 0x0 if
          item is not fix_field()'ed yet.
        */
        if (item_field->field_name && item_field->table_name &&
            !my_strcasecmp(system_charset_info, item_field->field_name,
                           field_name) &&
            !strcmp(item_field->table_name, table_name) &&
            (!db_name || (item_field->db_name &&
                          !strcmp(item_field->db_name, db_name))))
        {
          if (found_unaliased)
          {
            if ((*found_unaliased)->eq(item, 0))
              continue;
            /*
              Two matching fields in select list.
              We already can bail out because we are searching through
              unaliased names only and will have duplicate error anyway.
            */
            if (report_error != IGNORE_ERRORS)
              my_error(ER_NON_UNIQ_ERROR, MYF(0),
                       find->full_name(), current_thd->where);
            return (Item**) 0;
          }
          found_unaliased= li.ref();
          unaliased_counter= i;
          if (db_name)
            break;                              // Perfect match
        }
      }
      else if (!my_strcasecmp(system_charset_info, item_field->name,
                              field_name))
      {
        /*
          If table name was not given we should scan through aliases
          (or non-aliased fields) first. We are also checking unaliased
          name of the field in then next else-if, to be able to find
          instantly field (hidden by alias) if no suitable alias (or
          non-aliased field) was found.
        */
        if (found)
        {
          if ((*found)->eq(item, 0))
            continue;                           // Same field twice
          if (report_error != IGNORE_ERRORS)
            my_error(ER_NON_UNIQ_ERROR, MYF(0),
                     find->full_name(), current_thd->where);
          return (Item**) 0;
        }
        found= li.ref();
        *counter= i;
      }
      else if (!my_strcasecmp(system_charset_info, item_field->field_name,
                              field_name))
      {
        /*
          We will use un-aliased field or react on such ambiguities only if
          we won't be able to find aliased field.
          Again if we have ambiguity with field outside of select list
          we should prefer fields from select list.
        */
        if (found_unaliased)
        {
          if ((*found_unaliased)->eq(item, 0))
            continue;                           // Same field twice
          found_unaliased_non_uniq= 1;
        }
        else
        {
          found_unaliased= li.ref();
          unaliased_counter= i;
        }
      }
    }
    else if (!table_name && (find->eq(item,0) ||
                             find->name && item->name &&
                             !my_strcasecmp(system_charset_info, 
                                            item->name,find->name)))
    {
      found= li.ref();
      *counter= i;
      break;
    }
  }
  if (!found)
  {
    if (found_unaliased_non_uniq)
    {
      if (report_error != IGNORE_ERRORS)
        my_error(ER_NON_UNIQ_ERROR, MYF(0),
                 find->full_name(), current_thd->where);
      return (Item **) 0;
    }
    if (found_unaliased)
    {
      found= found_unaliased;
      *counter= unaliased_counter;
      *unaliased= TRUE;
    }
  }
  if (found)
    return found;
  if (report_error != REPORT_EXCEPT_NOT_FOUND)
  {
    if (report_error == REPORT_ALL_ERRORS)
      my_error(ER_BAD_FIELD_ERROR, MYF(0),
               find->full_name(), current_thd->where);
    return (Item **) 0;
  }
  else
    return (Item **) not_found_item;
}

Here is the call graph for this function:

Here is the caller graph for this function:

TABLE* find_locked_table	(	THD *	thd,
		const char *	db,
		const char *	table_name
	)

Definition at line 2112 of file sql_base.cc.

References key, key_length, MAX_DBKEY_LENGTH, memcmp(), and strmov().

Referenced by mysql_insert().

{
  char  key[MAX_DBKEY_LENGTH];
  uint key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;

  for (TABLE *table=thd->open_tables; table ; table=table->next)
  {
    if (table->s->table_cache_key.length == key_length &&
        !memcmp(table->s->table_cache_key.str, key, key_length))
      return table;
  }
  return(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TABLE_LIST* find_table_in_list	(	TABLE_LIST *	table,
		st_table_list *TABLE_LIST::*	link,
		const char *	db_name,
		const char *	table_name
	)

Definition at line 1329 of file sql_base.cc.

References st_table_list::db, NO_TMP_TABLE, st_table::s, strcmp(), st_table_list::table, st_table_list::table_name, and st_table_share::tmp_table.

{
  for (; table; table= table->*link )
  {
    if ((table->table == 0 || table->table->s->tmp_table == NO_TMP_TABLE) &&
        strcmp(table->db, db_name) == 0 &&
        strcmp(table->table_name, table_name) == 0)
      break;
  }
  return table;
}

Here is the call graph for this function:

TABLE* find_temporary_table	(	THD *	thd,
		TABLE_LIST *	table_list
	)

Definition at line 1493 of file sql_base.cc.

References create_table_def_key(), st_table_list::db, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, key, key_length, LEX_STRING::length, MAX_DBKEY_LENGTH, memcmp(), st_table::next, st_table::s, LEX_STRING::str, st_table_share::table_cache_key, and st_table_list::table_name.

{
  char  key[MAX_DBKEY_LENGTH];
  uint  key_length;
  TABLE *table;
  DBUG_ENTER("find_temporary_table");
  DBUG_PRINT("enter", ("table: '%s'.'%s'",
                       table_list->db, table_list->table_name));

  key_length= create_table_def_key(thd, key, table_list, 1);
  for (table=thd->temporary_tables ; table ; table= table->next)
  {
    if (table->s->table_cache_key.length == key_length &&
        !memcmp(table->s->table_cache_key.str, key, key_length))
      DBUG_RETURN(table);
  }
  DBUG_RETURN(0);                                       // Not a temporary table
}

Here is the call graph for this function:

TABLE* find_temporary_table	(	THD *	thd,
		const char *	db,
		const char *	table_name
	)

Definition at line 1483 of file sql_base.cc.

References st_table_list::db, and st_table_list::table_name.

Referenced by close_temporary_table(), mysql_alter_table(), mysql_create_like_table(), mysql_create_or_drop_trigger(), mysql_create_table_internal(), mysql_truncate(), and some_non_temp_table_to_be_updated().

{
  TABLE_LIST table_list;

  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
  return find_temporary_table(thd, &table_list);
}

Here is the caller graph for this function:

void flush_tables

(

)

Definition at line 6104 of file sql_base.cc.

References hash_delete(), LOCK_open, open_cache, pthread_mutex_lock, pthread_mutex_unlock, and unused_tables.

Referenced by handle_manager().

{
  (void) pthread_mutex_lock(&LOCK_open);
  while (unused_tables)
    hash_delete(&open_cache,(byte*) unused_tables);
  (void) pthread_mutex_unlock(&LOCK_open);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void free_cache_entry

(

TABLE *

entry

)

[static]

Definition at line 776 of file sql_base.cc.

References check_unused, DBUG_ENTER, DBUG_VOID_RETURN, st_table::in_use, intern_close_table(), my_free, MYF, st_table::next, st_table::prev, and unused_tables.

Referenced by table_cache_init().

{
  DBUG_ENTER("free_cache_entry");

  intern_close_table(table);
  if (!table->in_use)
  {
    table->next->prev=table->prev;              /* remove from used chain */
    table->prev->next=table->next;
    if (table == unused_tables)
    {
      unused_tables=unused_tables->next;
      if (table == unused_tables)
        unused_tables=0;
    }
    check_unused();                             // consisty check
  }
  my_free((gptr) table,MYF(0));
  DBUG_VOID_RETURN;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void free_io_cache

(

TABLE *

table

)

Definition at line 799 of file sql_base.cc.

References close_cached_file(), DBUG_ENTER, DBUG_VOID_RETURN, st_filesort_info::io_cache, my_free, MYF, and st_table::sort.

Referenced by JOIN::cleanup(), close_temporary(), copy_data_between_tables(), free_tmp_table(), get_schema_tables_result(), handler::ha_reset(), intern_close_table(), JOIN::reinit(), and remove_duplicates().

{
  DBUG_ENTER("free_io_cache");
  if (table->sort.io_cache)
  {
    close_cached_file(table->sort.io_cache);
    my_free((gptr) table->sort.io_cache,MYF(0));
    table->sort.io_cache=0;
  }
  DBUG_VOID_RETURN;
}

Here is the call graph for this function:

Here is the caller graph for this function:

TABLE_SHARE* get_cached_table_share	(	const char *	db,
		const char *	table_name
	)

Definition at line 605 of file sql_base.cc.

References create_table_def_key(), st_table_list::db, hash_search(), key, key_length, LOCK_open, NAME_LEN, safe_mutex_assert_owner, table_def_cache, and st_table_list::table_name.

Referenced by mysql_create_table_internal(), mysql_drop_view(), and mysql_rm_table_part2().

{
  char key[NAME_LEN*2+2];
  TABLE_LIST table_list;
  uint key_length;
  safe_mutex_assert_owner(&LOCK_open);

  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
  key_length= create_table_def_key((THD*) 0, key, &table_list, 0);
  return (TABLE_SHARE*) hash_search(&table_def_cache,(byte*) key, key_length);
}  

Here is the call graph for this function:

Here is the caller graph for this function:

bool get_key_map_from_key_list	(	key_map *	map,
		TABLE *	table,
		List< String > *	index_list
	)

Definition at line 5522 of file sql_base.cc.

References st_table_list::alias, ER_KEY_DOES_NOT_EXITS, find_type(), st_table_share::keynames, map, my_error(), MYF, name, pos(), st_table::pos_in_table_list, st_table::s, and st_typelib::type_names.

Referenced by ha_myisam::assign_to_keycache(), ha_myisam::preload_keys(), and setup_tables().

{
  List_iterator_fast<String> it(*index_list);
  String *name;
  uint pos;

  map->clear_all();
  while ((name=it++))
  {
    if (table->s->keynames.type_names == 0 ||
        (pos= find_type(&table->s->keynames, name->ptr(),
                        name->length(), 1)) <=
        0)
    {
      my_error(ER_KEY_DOES_NOT_EXITS, MYF(0), name->c_ptr(),
               table->pos_in_table_list->alias);
      map->set_all();
      return 1;
    }
    map->set_bit(pos-1);
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

TABLE_SHARE* get_table_share	(	THD *	thd,
		TABLE_LIST *	table_list,
		char *	key,
		uint	key_length,
		uint	db_flags,
		int *	error
	)

Definition at line 278 of file sql_base.cc.

References alloc_table_share(), assign_new_table_id(), DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, free_table_share(), hash_delete(), hash_search(), LOCK_open, LOCK_table_share, st_table_share::mutex, my_hash_insert(), st_table_share::next, oldest_unused_share, open_table_def(), open_table_error(), OPEN_VIEW, pthread_mutex_lock, pthread_mutex_unlock, st_hash::records, table_def_cache, table_def_size, and VOID.

Referenced by get_table_share_with_create(), and prepare_for_repair().

{
  TABLE_SHARE *share;
  DBUG_ENTER("get_table_share");

  *error= 0;

  /* Read table definition from cache */
  if ((share= (TABLE_SHARE*) hash_search(&table_def_cache,(byte*) key,
                                         key_length)))
    goto found;

  if (!(share= alloc_table_share(table_list, key, key_length)))
  {
#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
    pthread_mutex_unlock(&LOCK_open);
#endif
    DBUG_RETURN(0);
  }

#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
  // We need a write lock to be able to add a new entry
  pthread_mutex_unlock(&LOCK_open);
  pthread_mutex_lock(&LOCK_open);
  /* Check that another thread didn't insert the same table in between */
  if ((old_share= hash_search(&table_def_cache, (byte*) key, key_length)))
  {
    (void) pthread_mutex_lock(&share->mutex);
    free_table_share(share);
    share= old_share;
    goto found;
  }
#endif

  /*
    Lock mutex to be able to read table definition from file without
    conflicts
  */
  (void) pthread_mutex_lock(&share->mutex);

  /*
    We assign a new table id under the protection of the LOCK_open and
    the share's own mutex.  We do this insted of creating a new mutex
    and using it for the sole purpose of serializing accesses to a
    static variable, we assign the table id here.  We assign it to the
    share before inserting it into the table_def_cache to be really
    sure that it cannot be read from the cache without having a table
    id assigned.

    CAVEAT. This means that the table cannot be used for
    binlogging/replication purposes, unless get_table_share() has been
    called directly or indirectly.
   */
  assign_new_table_id(share);

  if (my_hash_insert(&table_def_cache, (byte*) share))
  {
#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
    pthread_mutex_unlock(&LOCK_open);    
    (void) pthread_mutex_unlock(&share->mutex);
#endif
    free_table_share(share);
    DBUG_RETURN(0);                             // return error
  }
#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
  pthread_mutex_unlock(&LOCK_open);
#endif
  if (open_table_def(thd, share, db_flags))
  {
#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
    /*
      No such table or wrong table definition file
      Lock first the table cache and then the mutex.
      This will ensure that no other thread is using the share
      structure.
    */
    (void) pthread_mutex_unlock(&share->mutex);
    (void) pthread_mutex_lock(&LOCK_open);
    (void) pthread_mutex_lock(&share->mutex);
#endif
    *error= share->error;
    (void) hash_delete(&table_def_cache, (byte*) share);
    DBUG_RETURN(0);
  }
  share->ref_count++;                           // Mark in use
  DBUG_PRINT("exit", ("share: 0x%lx  ref_count: %u",
                      (ulong) share, share->ref_count));
  (void) pthread_mutex_unlock(&share->mutex);
  DBUG_RETURN(share);

found:
  /* 
     We found an existing table definition. Return it if we didn't get
     an error when reading the table definition from file.
  */

  /* We must do a lock to ensure that the structure is initialized */
  (void) pthread_mutex_lock(&share->mutex);
#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
  pthread_mutex_unlock(&LOCK_open);
#endif
  if (share->error)
  {
    /* Table definition contained an error */
    open_table_error(share, share->error, share->open_errno, share->errarg);
    (void) pthread_mutex_unlock(&share->mutex);
    DBUG_RETURN(0);
  }
  if (share->is_view && !(db_flags & OPEN_VIEW))
  {
    open_table_error(share, 1, ENOENT, 0);
    (void) pthread_mutex_unlock(&share->mutex);
    DBUG_RETURN(0);
  }

  if (!share->ref_count++ && share->prev)
  {
    /*
      Share was not used before and it was in the old_unused_share list
      Unlink share from this list
    */
    DBUG_PRINT("info", ("Unlinking from not used list"));
    pthread_mutex_lock(&LOCK_table_share);
    *share->prev= share->next;
    share->next->prev= share->prev;
    share->next= 0;
    share->prev= 0;
    pthread_mutex_unlock(&LOCK_table_share);
  }
  (void) pthread_mutex_unlock(&share->mutex);

   /* Free cache if too big */
  while (table_def_cache.records > table_def_size &&
         oldest_unused_share->next)
  {
    pthread_mutex_lock(&oldest_unused_share->mutex);
    VOID(hash_delete(&table_def_cache, (byte*) oldest_unused_share));
  }

  DBUG_PRINT("exit", ("share: 0x%lx  ref_count: %u",
                      (ulong) share, share->ref_count));
  DBUG_RETURN(share);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static TABLE_SHARE* get_table_share_with_create	(	THD *	thd,
		TABLE_LIST *	table_list,
		char *	key,
		uint	key_length,
		uint	db_flags,
		int *	error
	)			[static]

Definition at line 431 of file sql_base.cc.

References st_table_list::belong_to_view, st_table_list::db, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, ER_NO_SUCH_TABLE, ER_UNKNOWN_ERROR, ER_VIEW_INVALID, get_table_share(), ha_create_table_from_engine(), my_error(), my_printf_error(), MYF, mysql_reset_errors(), LEX_STRING::str, st_table_list::table_name, st_table_list::view_db, and st_table_list::view_name.

Referenced by open_unireg_entry().

{
  TABLE_SHARE *share;
  int tmp;
  DBUG_ENTER("get_table_share_with_create");

  if ((share= get_table_share(thd, table_list, key, key_length, 
                              db_flags, error)) ||
      thd->net.last_errno != ER_NO_SUCH_TABLE)
    DBUG_RETURN(share);

  /* Table didn't exist. Check if some engine can provide it */
  if ((tmp= ha_create_table_from_engine(thd, table_list->db,
                                        table_list->table_name)) < 0)
  {
    /*
      No such table in any engine.
      Hide "Table doesn't exist" errors if table belong to view
    */
    if (table_list->belong_to_view)
    {
      TABLE_LIST *view= table_list->belong_to_view;
      thd->clear_error();
      my_error(ER_VIEW_INVALID, MYF(0),
               view->view_db.str, view->view_name.str);
    }
    DBUG_RETURN(0);
  }
  if (tmp)
  {
    /* Give right error message */
    thd->clear_error();
    DBUG_PRINT("error", ("Discovery of %s/%s failed", table_list->db,
                         table_list->table_name));
    my_printf_error(ER_UNKNOWN_ERROR,
                    "Failed to open '%-.64s', error while "
                    "unpacking from engine",
                    MYF(0), table_list->table_name);
    DBUG_RETURN(0);
  }
  /* Table existed in engine. Let's open it */
  mysql_reset_errors(thd, 1);                   // Clear warnings
  thd->clear_error();                           // Clear error message
  DBUG_RETURN(get_table_share(thd, table_list, key, key_length,
                              db_flags, error));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool has_two_write_locked_tables_with_auto_increment

(

TABLE_LIST *

tables

)

[static]

Definition at line 6530 of file sql_base.cc.

References DBUG_ASSERT, st_table_list::next_global, NULL, strcmp(), and TL_WRITE_ALLOW_WRITE.

Referenced by lock_tables().

{
  char *first_table_name= NULL, *first_db;
  for (TABLE_LIST *table= tables; table; table= table->next_global)
  {
    /* we must do preliminary checks as table->table may be NULL */
    if (!table->placeholder() && !table->schema_table &&
        table->table->found_next_number_field &&
        (table->lock_type >= TL_WRITE_ALLOW_WRITE))
    {
      if (first_table_name == NULL)
      {
        first_table_name= table->table_name;
        first_db= table->db;
        DBUG_ASSERT(first_db);
      }
      else if (strcmp(first_db, table->db) ||
               strcmp(first_table_name, table->table_name))
        return 1;
    }
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int init_ftfuncs	(	THD *	thd,
		SELECT_LEX *	select_lex,
		bool	no_order
	)

Definition at line 6281 of file sql_base.cc.

References DBUG_PRINT, and Item_func_match::init_search().

Referenced by mysql_delete().

{
  if (select_lex->ftfunc_list->elements)
  {
    List_iterator<Item_func_match> li(*(select_lex->ftfunc_list));
    Item_func_match *ifm;
    DBUG_PRINT("info",("Performing FULLTEXT search"));
    thd->proc_info="FULLTEXT initialization";

    while ((ifm=li++))
      ifm->init_search(no_order);
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool insert_fields	(	THD *	thd,
		Name_resolution_context *	context,
		const char *	db_name,
		const char *	table_name,
		List_iterator< Item > *	it,
		bool	any_privileges
	)

Definition at line 5567 of file sql_base.cc.

References List_iterator< T >::after(), bitmap_set_bit(), check_grant_all_columns(), Field_iterator_table_ref::create_item(), Field_iterator_table_ref::db_name(), DBUG_ASSERT, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, Field_iterator_table_ref::end_of_fields(), ER, ER_BAD_TABLE_ERROR, ER_COLUMNACCESS_DENIED_ERROR, ER_NO_TABLES_USED, FALSE, Field_iterator_table_ref::field(), Field::field_index, Item::FIELD_ITEM, st_table_share::fields, files_charset_info, Name_resolution_context::first_name_resolution_table, get_column_grant(), Field_iterator_table_ref::get_natural_column_ref(), Field_iterator_table_ref::grant(), st_table::grant, Bitmap< 64 >::intersect(), lower_case_table_names, st_table::map, Bitmap< 64 >::merge(), st_table::merge_keys, my_casedn_str, my_error(), my_message(), my_strcasecmp, MYF, NAME_LEN, Field_iterator_table_ref::next(), NULL, Field::part_of_key, st_grant_info::privilege, st_table::read_set, List_iterator< T >::replace(), st_table::s, SELECT_ACL, Field_iterator_table_ref::set(), strcmp(), strmake(), st_table_list::table, Field::table, table_alias_charset, Natural_join_column::table_field, Name_resolution_context::table_list, Field_iterator_table_ref::table_name(), Natural_join_column::table_ref, TRUE, st_table::used_fields, st_table::used_keys, and VIEW_ANY_ACL.

Referenced by mysql_ha_read(), and setup_wild().

{
  Field_iterator_table_ref field_iterator;
  bool found;
  char name_buff[NAME_LEN+1];
  DBUG_ENTER("insert_fields");
  DBUG_PRINT("arena", ("stmt arena: 0x%lx", (ulong)thd->stmt_arena));

  if (db_name && lower_case_table_names)
  {
    /*
      convert database to lower case for comparison
      We can't do this in Item_field as this would change the
      'name' of the item which may be used in the select list
    */
    strmake(name_buff, db_name, sizeof(name_buff)-1);
    my_casedn_str(files_charset_info, name_buff);
    db_name= name_buff;
  }

  found= FALSE;

  /*
    If table names are qualified, then loop over all tables used in the query,
    else treat natural joins as leaves and do not iterate over their underlying
    tables.
  */
  for (TABLE_LIST *tables= (table_name ? context->table_list :
                            context->first_name_resolution_table);
       tables;
       tables= (table_name ? tables->next_local :
                tables->next_name_resolution_table)
       )
  {
    Field *field;
    TABLE *table= tables->table;

    DBUG_ASSERT(tables->is_leaf_for_name_resolution());

    if (table_name && my_strcasecmp(table_alias_charset, table_name,
                                    tables->alias) ||
        (db_name && strcmp(tables->db,db_name)))
      continue;

#ifndef NO_EMBEDDED_ACCESS_CHECKS
    /* Ensure that we have access rights to all fields to be inserted. */
    if (!((table && (table->grant.privilege & SELECT_ACL) ||
           tables->view && (tables->grant.privilege & SELECT_ACL))) &&
        !any_privileges)
    {
      field_iterator.set(tables);
      if (check_grant_all_columns(thd, SELECT_ACL, field_iterator.grant(),
                                  field_iterator.db_name(),
                                  field_iterator.table_name(),
                                  &field_iterator))
        DBUG_RETURN(TRUE);
    }
#endif

    /*
      Update the tables used in the query based on the referenced fields. For
      views and natural joins this update is performed inside the loop below.
    */
    if (table)
      thd->used_tables|= table->map;

    /*
      Initialize a generic field iterator for the current table reference.
      Notice that it is guaranteed that this iterator will iterate over the
      fields of a single table reference, because 'tables' is a leaf (for
      name resolution purposes).
    */
    field_iterator.set(tables);

    for (; !field_iterator.end_of_fields(); field_iterator.next())
    {
      Item *item;

      if (!(item= field_iterator.create_item(thd)))
        DBUG_RETURN(TRUE);

      if (!found)
      {
        found= TRUE;
        it->replace(item); /* Replace '*' with the first found item. */
      }
      else
        it->after(item);   /* Add 'item' to the SELECT list. */

#ifndef NO_EMBEDDED_ACCESS_CHECKS
      /*
        Set privilege information for the fields of newly created views.
        We have that (any_priviliges == TRUE) if and only if we are creating
        a view. In the time of view creation we can't use the MERGE algorithm,
        therefore if 'tables' is itself a view, it is represented by a
        temporary table. Thus in this case we can be sure that 'item' is an
        Item_field.
      */
      if (any_privileges)
      {
        DBUG_ASSERT(tables->field_translation == NULL && table ||
                    tables->is_natural_join);
        DBUG_ASSERT(item->type() == Item::FIELD_ITEM);
        Item_field *fld= (Item_field*) item;
        const char *field_table_name= field_iterator.table_name();

        if (!tables->schema_table && 
            !(fld->have_privileges=
              (get_column_grant(thd, field_iterator.grant(),
                                field_iterator.db_name(),
                                field_table_name, fld->field_name) &
               VIEW_ANY_ACL)))
        {
          my_error(ER_COLUMNACCESS_DENIED_ERROR, MYF(0), "ANY",
                   thd->security_ctx->priv_user,
                   thd->security_ctx->host_or_ip,
                   fld->field_name, field_table_name);
          DBUG_RETURN(TRUE);
        }
      }
#endif

      if ((field= field_iterator.field()))
      {
        /* Mark fields as used to allow storage engine to optimze access */
        bitmap_set_bit(field->table->read_set, field->field_index);
        if (table)
        {
          table->used_keys.intersect(field->part_of_key);
          table->merge_keys.merge(field->part_of_key);
        }
        if (tables->is_natural_join)
        {
          TABLE *field_table;
          /*
            In this case we are sure that the column ref will not be created
            because it was already created and stored with the natural join.
          */
          Natural_join_column *nj_col;
          if (!(nj_col= field_iterator.get_natural_column_ref()))
            DBUG_RETURN(TRUE);
          DBUG_ASSERT(nj_col->table_field);
          field_table= nj_col->table_ref->table;
          if (field_table)
          {
            thd->used_tables|= field_table->map;
            field_table->used_keys.intersect(field->part_of_key);
            field_table->merge_keys.merge(field->part_of_key);
            field_table->used_fields++;
          }
        }
      }
      else
        thd->used_tables|= item->used_tables();
    }
    /*
      In case of stored tables, all fields are considered as used,
      while in the case of views, the fields considered as used are the
      ones marked in setup_tables during fix_fields of view columns.
      For NATURAL joins, used_tables is updated in the IF above.
    */
    if (table)
      table->used_fields= table->s->fields;
  }
  if (found)
    DBUG_RETURN(FALSE);

  /*
    TODO: in the case when we skipped all columns because there was a
    qualified '*', and all columns were coalesced, we have to give a more
    meaningful message than ER_BAD_TABLE_ERROR.
  */
  if (!table_name)
    my_message(ER_NO_TABLES_USED, ER(ER_NO_TABLES_USED), MYF(0));
  else
    my_error(ER_BAD_TABLE_ERROR, MYF(0), table_name);

  DBUG_RETURN(TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void intern_close_table

(

TABLE *

table

)

Definition at line 754 of file sql_base.cc.

References closefrm(), DBUG_ENTER, DBUG_VOID_RETURN, st_table::file, free_io_cache(), st_table::triggers, and VOID.

Referenced by free_cache_entry(), and reopen_name_locked_table().

{                                               // Free all structures
  DBUG_ENTER("intern_close_table");

  free_io_cache(table);
  delete table->triggers;
  if (table->file)                              // Not true if name lock
    VOID(closefrm(table, 1));                   // close file
  DBUG_VOID_RETURN;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool is_equal	(	const LEX_STRING *	a,
		const LEX_STRING *	b
	)

Definition at line 6361 of file sql_base.cc.

References LEX_STRING::length, and LEX_STRING::str.

Referenced by add_table_for_trigger(), Table_triggers_list::check_n_load(), mysql_register_view(), mysql_rename_view(), open_new_frm(), and row_sel_sec_rec_is_for_clust_rec().

{
  return a->length == b->length && !strncmp(a->str, b->str, a->length);
}

Here is the caller graph for this function:

OPEN_TABLE_LIST* list_open_tables	(	THD *	thd,
		const char *	db,
		const char *	wild
	)

Definition at line 685 of file sql_base.cc.

References bzero, check_table_access(), st_table_share::db, DBUG_ENTER, EXTRA_ACL, hash_element(), LOCK_open, my_strcasecmp, st_open_table_list::next, open_cache, pthread_mutex_lock, st_hash::records, SELECT_ACL, sql_alloc(), LEX_STRING::str, strcmp(), system_charset_info, st_table_share::table_name, VOID, and wild_compare().

Referenced by fill_open_tables().

{
  int result = 0;
  OPEN_TABLE_LIST **start_list, *open_list;
  TABLE_LIST table_list;
  DBUG_ENTER("list_open_tables");

  VOID(pthread_mutex_lock(&LOCK_open));
  bzero((char*) &table_list,sizeof(table_list));
  start_list= &open_list;
  open_list=0;

  for (uint idx=0 ; result == 0 && idx < open_cache.records; idx++)
  {
    OPEN_TABLE_LIST *table;
    TABLE *entry=(TABLE*) hash_element(&open_cache,idx);
    TABLE_SHARE *share= entry->s;

    if (db && my_strcasecmp(system_charset_info, db, share->db.str))
      continue;
    if (wild && wild_compare(share->table_name.str, wild, 0))
      continue;

    /* Check if user has SELECT privilege for any column in the table */
    table_list.db=         share->db.str;
    table_list.table_name= share->table_name.str;
    table_list.grant.privilege=0;

    if (check_table_access(thd,SELECT_ACL | EXTRA_ACL,&table_list,1))
      continue;
    /* need to check if we haven't already listed it */
    for (table= open_list  ; table ; table=table->next)
    {
      if (!strcmp(table->table, share->table_name.str) &&
          !strcmp(table->db,    share->db.str))
      {
        if (entry->in_use)
          table->in_use++;
        if (entry->locked_by_name)
          table->locked++;
        break;
      }
    }
    if (table)
      continue;
    if (!(*start_list = (OPEN_TABLE_LIST *)
          sql_alloc(sizeof(**start_list)+share->table_cache_key.length)))
    {
      open_list=0;                              // Out of memory
      break;
    }
    strmov((*start_list)->table=
           strmov(((*start_list)->db= (char*) ((*start_list)+1)),
                  share->db.str)+1,
           share->table_name.str);
    (*start_list)->in_use= entry->in_use ? 1 : 0;
    (*start_list)->locked= entry->locked_by_name ? 1 : 0;
    start_list= &(*start_list)->next;
    *start_list=0;
  }
  VOID(pthread_mutex_unlock(&LOCK_open));
  DBUG_RETURN(open_list);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int lock_tables	(	THD *	thd,
		TABLE_LIST *	tables,
		uint	count,
		bool *	need_reopen
	)

Definition at line 3294 of file sql_base.cc.

References check_lock_and_start_stmt(), DBUG_ASSERT, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, FALSE, ha_rollback_stmt, has_two_write_locked_tables_with_auto_increment(), HAVE_ROW_BASED_REPLICATION, st_table_list::lock_type, mark_real_tables_as_free_for_reuse(), mysql_lock_tables(), mysql_unlock_tables(), st_table_list::next_global, OPTION_TABLE_LOCK, st_table_list::placeholder(), st_table::query_id, st_table_list::schema_table, SQLCOM_LOCK_TABLES, start(), st_table_list::table, and TRUE.

{
  TABLE_LIST *table;

  DBUG_ENTER("lock_tables");
  /*
    We can't meet statement requiring prelocking if we already
    in prelocked mode.
  */
  DBUG_ASSERT(!thd->prelocked_mode || !thd->lex->requires_prelocking());

  *need_reopen= FALSE;

#ifdef HAVE_ROW_BASED_REPLICATION
  /*
    CREATE ... SELECT UUID() locks no tables, we have to test here.
  */
  if (thd->lex->binlog_row_based_if_mixed)
    thd->set_current_stmt_binlog_row_based_if_mixed();
#endif /*HAVE_ROW_BASED_REPLICATION*/

  if (!tables && !thd->lex->requires_prelocking())
    DBUG_RETURN(0);

  /*
    We need this extra check for thd->prelocked_mode because we want to avoid
    attempts to lock tables in substatements. Checking for thd->locked_tables
    is not enough in some situations. For example for SP containing
    "drop table t3; create temporary t3 ..; insert into t3 ...;"
    thd->locked_tables may be 0 after drop tables, and without this extra
    check insert will try to lock temporary table t3, that will lead
    to memory leak...
  */
  if (!thd->locked_tables && !thd->prelocked_mode)
  {
    DBUG_ASSERT(thd->lock == 0);        // You must lock everything at once
    TABLE **start,**ptr;

    if (!(ptr=start=(TABLE**) thd->alloc(sizeof(TABLE*)*count)))
      DBUG_RETURN(-1);
    for (table= tables; table; table= table->next_global)
    {
      if (!table->placeholder() && !table->schema_table)
        *(ptr++)= table->table;
    }

    /* We have to emulate LOCK TABLES if we are statement needs prelocking. */
    if (thd->lex->requires_prelocking())
    {
      thd->in_lock_tables=1;
      thd->options|= OPTION_TABLE_LOCK;
#ifdef HAVE_ROW_BASED_REPLICATION
      /*
        If we have >= 2 different tables to update with auto_inc columns,
        statement-based binlogging won't work. We can solve this problem in
        mixed mode by switching to row-based binlogging:
      */
      if (thd->variables.binlog_format == BINLOG_FORMAT_MIXED &&
          has_two_write_locked_tables_with_auto_increment(tables))
      {
        thd->lex->binlog_row_based_if_mixed= TRUE;
        thd->set_current_stmt_binlog_row_based_if_mixed();
      }
#endif
    }

    if (! (thd->lock= mysql_lock_tables(thd, start, (uint) (ptr - start),
                                        MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN,
                                        need_reopen)))
    {
      if (thd->lex->requires_prelocking())
      {
        thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
        thd->in_lock_tables=0;
      }
      DBUG_RETURN(-1);
    }
    if (thd->lex->requires_prelocking() &&
        thd->lex->sql_command != SQLCOM_LOCK_TABLES)
    {
      TABLE_LIST *first_not_own= thd->lex->first_not_own_table();
      /*
        We just have done implicit LOCK TABLES, and now we have
        to emulate first open_and_lock_tables() after it.

        Note that "LOCK TABLES" can also be marked as requiring prelocking
        (e.g. if one locks view which uses functions). We should not emulate
        such open_and_lock_tables() in this case. We also should not set
        THD::prelocked_mode or first close_thread_tables() call will do
        "UNLOCK TABLES".
      */
      thd->locked_tables= thd->lock;
      thd->lock= 0;
      thd->in_lock_tables=0;

      for (table= tables; table != first_not_own; table= table->next_global)
      {
        if (!table->placeholder() && !table->schema_table)
        {
          table->table->query_id= thd->query_id;
          if (check_lock_and_start_stmt(thd, table->table, table->lock_type))
          {
            ha_rollback_stmt(thd);
            mysql_unlock_tables(thd, thd->locked_tables);
            thd->locked_tables= 0;
            thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
            DBUG_RETURN(-1);
          }
        }
      }
      /*
        Let us mark all tables which don't belong to the statement itself,
        and was marked as occupied during open_tables() as free for reuse.
      */
      mark_real_tables_as_free_for_reuse(first_not_own);
      DBUG_PRINT("info",("prelocked_mode= PRELOCKED"));
      thd->prelocked_mode= PRELOCKED;
    }
  }
  else
  {
    TABLE_LIST *first_not_own= thd->lex->first_not_own_table();
    for (table= tables; table != first_not_own; table= table->next_global)
    {
      if (!table->placeholder() && !table->schema_table &&
          check_lock_and_start_stmt(thd, table->table, table->lock_type))
      {
        ha_rollback_stmt(thd);
        DBUG_RETURN(-1);
      }
    }
    /*
      If we are under explicit LOCK TABLES and our statement requires
      prelocking, we should mark all "additional" tables as free for use
      and enter prelocked mode.
    */
    if (thd->lex->requires_prelocking())
    {
      mark_real_tables_as_free_for_reuse(first_not_own);
      DBUG_PRINT("info", ("thd->prelocked_mode= PRELOCKED_UNDER_LOCK_TABLES"));
      thd->prelocked_mode= PRELOCKED_UNDER_LOCK_TABLES;
    }
  }
  DBUG_RETURN(0);
}

Here is the call graph for this function:

TABLE_LIST** make_leaves_list	(	TABLE_LIST **	list,
		TABLE_LIST *	tables
	)

Definition at line 5320 of file sql_base.cc.

References DBUG_ASSERT, list(), st_table_list::next_local, and VIEW_ALGORITHM_MERGE.

Referenced by setup_tables().

{
  for (TABLE_LIST *table= tables; table; table= table->next_local)
  {
    if (table->merge_underlying_list)
    {
      DBUG_ASSERT(table->view &&
                  table->effective_algorithm == VIEW_ALGORITHM_MERGE);
      list= make_leaves_list(list, table->merge_underlying_list);
    }
    else
    {
      *list= table;
      list= &table->next_leaf;
    }
  }
  return list;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool mark_common_columns	(	THD *	thd,
		TABLE_LIST *	table_ref_1,
		TABLE_LIST *	table_ref_2,
		List< String > *	using_fields,
		uint *	found_using_fields
	)			[static]

Definition at line 4618 of file sql_base.cc.

References add_join_on(), st_table_list::alias, backup, bitmap_set_bit(), Natural_join_column::create_item(), DBUG_ASSERT, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, Field_iterator_table_ref::end_of_fields(), ER_NON_UNIQ_ERROR, err, FALSE, Natural_join_column::field(), Field::field_index, Item::FIELD_ITEM, Field_iterator_table_ref::get_or_create_column_ref(), Bitmap< 64 >::intersect(), Natural_join_column::is_common, st_table_list::is_join_columns_complete, st_table_list::is_natural_join, JOIN_TYPE_RIGHT, Bitmap< 64 >::merge(), st_table::merge_keys, my_error(), my_strcasecmp, MYF, Natural_join_column::name(), st_table_list::nested_join, Field_iterator_table_ref::next(), NULL, st_table_list::outer_join, Field::part_of_key, st_table::read_set, Item::REF_ITEM, Field_iterator_table_ref::set(), set_new_item_local_context(), system_charset_info, st_table_list::table, Natural_join_column::table_ref, test_if_string_in_list(), TRUE, Item::type(), and st_table::used_keys.

Referenced by store_top_level_join_columns().

{
  Field_iterator_table_ref it_1, it_2;
  Natural_join_column *nj_col_1, *nj_col_2;
  Query_arena *arena, backup;
  bool result= TRUE;
  bool first_outer_loop= TRUE;
  /*
    Leaf table references to which new natural join columns are added
    if the leaves are != NULL.
  */
  TABLE_LIST *leaf_1= (table_ref_1->nested_join &&
                       !table_ref_1->is_natural_join) ?
                      NULL : table_ref_1;
  TABLE_LIST *leaf_2= (table_ref_2->nested_join &&
                       !table_ref_2->is_natural_join) ?
                      NULL : table_ref_2;

  DBUG_ENTER("mark_common_columns");
  DBUG_PRINT("info", ("operand_1: %s  operand_2: %s",
                      table_ref_1->alias, table_ref_2->alias));

  *found_using_fields= 0;
  arena= thd->activate_stmt_arena_if_needed(&backup);

  for (it_1.set(table_ref_1); !it_1.end_of_fields(); it_1.next())
  {
    bool found= FALSE;
    const char *field_name_1;
    if (!(nj_col_1= it_1.get_or_create_column_ref(leaf_1)))
      goto err;
    field_name_1= nj_col_1->name();

    /*
      Find a field with the same name in table_ref_2.

      Note that for the second loop, it_2.set() will iterate over
      table_ref_2->join_columns and not generate any new elements or
      lists.
    */
    nj_col_2= NULL;
    for (it_2.set(table_ref_2); !it_2.end_of_fields(); it_2.next())
    {
      Natural_join_column *cur_nj_col_2;
      const char *cur_field_name_2;
      if (!(cur_nj_col_2= it_2.get_or_create_column_ref(leaf_2)))
        goto err;
      cur_field_name_2= cur_nj_col_2->name();

      /*
        Compare the two columns and check for duplicate common fields.
        A common field is duplicate either if it was already found in
        table_ref_2 (then found == TRUE), or if a field in table_ref_2
        was already matched by some previous field in table_ref_1
        (then cur_nj_col_2->is_common == TRUE).
      */
      if (!my_strcasecmp(system_charset_info, field_name_1, cur_field_name_2))
      {
        if (found || cur_nj_col_2->is_common)
        {
          my_error(ER_NON_UNIQ_ERROR, MYF(0), field_name_1, thd->where);
          goto err;
        }
        nj_col_2= cur_nj_col_2;
        found= TRUE;
      }
    }
    if (first_outer_loop && leaf_2)
    {
      /*
        Make sure that the next inner loop "knows" that all columns
        are materialized already.
      */
      leaf_2->is_join_columns_complete= TRUE;
      first_outer_loop= FALSE;
    }
    if (!found)
      continue;                                 // No matching field

    /*
      field_1 and field_2 have the same names. Check if they are in the USING
      clause (if present), mark them as common fields, and add a new
      equi-join condition to the ON clause.
    */
    if (nj_col_2 &&
        (!using_fields ||
          test_if_string_in_list(field_name_1, using_fields)))
    {
      Item *item_1=   nj_col_1->create_item(thd);
      Item *item_2=   nj_col_2->create_item(thd);
      Field *field_1= nj_col_1->field();
      Field *field_2= nj_col_2->field();
      Item_ident *item_ident_1, *item_ident_2;
      Item_func_eq *eq_cond;

      if (!item_1 || !item_2)
        goto err;                               // out of memory

      /*
        The following assert checks that the two created items are of
        type Item_ident.
      */
      DBUG_ASSERT(!thd->lex->current_select->no_wrap_view_item);
      /*
        In the case of no_wrap_view_item == 0, the created items must be
        of sub-classes of Item_ident.
      */
      DBUG_ASSERT(item_1->type() == Item::FIELD_ITEM ||
                  item_1->type() == Item::REF_ITEM);
      DBUG_ASSERT(item_2->type() == Item::FIELD_ITEM ||
                  item_2->type() == Item::REF_ITEM);

      /*
        We need to cast item_1,2 to Item_ident, because we need to hook name
        resolution contexts specific to each item.
      */
      item_ident_1= (Item_ident*) item_1;
      item_ident_2= (Item_ident*) item_2;
      /*
        Create and hook special name resolution contexts to each item in the
        new join condition . We need this to both speed-up subsequent name
        resolution of these items, and to enable proper name resolution of
        the items during the execute phase of PS.
      */
      if (set_new_item_local_context(thd, item_ident_1, nj_col_1->table_ref) ||
          set_new_item_local_context(thd, item_ident_2, nj_col_2->table_ref))
        goto err;

      if (!(eq_cond= new Item_func_eq(item_ident_1, item_ident_2)))
        goto err;                               /* Out of memory. */

      /*
        Add the new equi-join condition to the ON clause. Notice that
        fix_fields() is applied to all ON conditions in setup_conds()
        so we don't do it here.
       */
      add_join_on((table_ref_1->outer_join & JOIN_TYPE_RIGHT ?
                   table_ref_1 : table_ref_2),
                  eq_cond);

      nj_col_1->is_common= nj_col_2->is_common= TRUE;

      if (field_1)
      {
        TABLE *table_1= nj_col_1->table_ref->table;
        /* Mark field_1 used for table cache. */
        bitmap_set_bit(table_1->read_set, field_1->field_index);
        table_1->used_keys.intersect(field_1->part_of_key);
        table_1->merge_keys.merge(field_1->part_of_key);
      }
      if (field_2)
      {
        TABLE *table_2= nj_col_2->table_ref->table;
        /* Mark field_2 used for table cache. */
        bitmap_set_bit(table_2->read_set, field_2->field_index);
        table_2->used_keys.intersect(field_2->part_of_key);
        table_2->merge_keys.merge(field_2->part_of_key);
      }

      if (using_fields != NULL)
        ++(*found_using_fields);
    }
  }
  if (leaf_1)
    leaf_1->is_join_columns_complete= TRUE;

  /*
    Everything is OK.
    Notice that at this point there may be some column names in the USING
    clause that are not among the common columns. This is an SQL error and
    we check for this error in store_natural_using_join_columns() when
    (found_using_fields < length(join_using_fields)).
  */
  result= FALSE;

err:
  if (arena)
    thd->restore_active_arena(arena, &backup);
  DBUG_RETURN(result);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void mark_real_tables_as_free_for_reuse

(

TABLE_LIST *

table

)

[static]

Definition at line 3258 of file sql_base.cc.

References st_table_list::next_global, st_table_list::placeholder(), st_table::query_id, st_table_list::schema_table, and st_table_list::table.

Referenced by lock_tables().

{
  for (; table; table= table->next_global)
    if (!table->placeholder() && !table->schema_table)
      table->table->query_id= 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void mark_used_tables_as_free_for_reuse	(	THD *	thd,
		TABLE *	table
	)			[static]

Definition at line 945 of file sql_base.cc.

References st_table::file, handler::ha_reset(), st_table::next, and st_table::query_id.

Referenced by close_tables_for_reopen(), and close_thread_tables().

{
  for (; table ; table= table->next)
  {
    if (table->query_id == thd->query_id)
    {
      table->query_id= 0;
      table->file->ha_reset();
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void mysql_rm_tmp_tables

(

void

)

[static]

Definition at line 6023 of file sql_base.cc.

References bcmp, DBUG_ENTER, st_my_dir::dir_entry, FN_LIBCHAR, FN_REFLEN, st_my_tmpdir::list, st_my_tmpdir::max, my_delete(), my_dir(), MY_DONT_SORT, MY_WME, MYF, mysql_tmpdir_list, fileinfo::name, st_my_dir::number_off_files, tmp_file_prefix, tmp_file_prefix_length, and VOID.

Referenced by table_cache_init().

{
  uint i, idx;
  char  filePath[FN_REFLEN], *tmpdir;
  MY_DIR *dirp;
  FILEINFO *file;
  DBUG_ENTER("mysql_rm_tmp_tables");

  for (i=0; i<=mysql_tmpdir_list.max; i++)
  {
    tmpdir=mysql_tmpdir_list.list[i];
    /* See if the directory exists */
    if (!(dirp = my_dir(tmpdir,MYF(MY_WME | MY_DONT_SORT))))
      continue;

    /* Remove all SQLxxx tables from directory */

    for (idx=0 ; idx < (uint) dirp->number_off_files ; idx++)
    {
      file=dirp->dir_entry+idx;

      /* skiping . and .. */
      if (file->name[0] == '.' && (!file->name[1] ||
                                   (file->name[1] == '.' &&  !file->name[2])))
        continue;

      if (!bcmp(file->name,tmp_file_prefix,tmp_file_prefix_length))
      {
        sprintf(filePath,"%s%c%s",tmpdir,FN_LIBCHAR,file->name);
        VOID(my_delete(filePath,MYF(MY_WME)));
      }
    }
    my_dirend(dirp);
  }
  DBUG_VOID_RETURN;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mysql_wait_completed_table	(	ALTER_PARTITION_PARAM_TYPE *	lpt,
		TABLE *	my_table
	)

Definition at line 6448 of file sql_base.cc.

References DBUG_ENTER, DBUG_VOID_RETURN, FALSE, hash_first(), hash_next(), st_table::in_use, key, key_length, KILL_CONNECTION, LOCK_open, MAX_DBKEY_LENGTH, mysql_lock_abort(), mysql_lock_abort_for_thread(), open_cache, pthread_mutex_lock, pthread_mutex_unlock, relink_unused(), st_table::s, strmov(), st_table_share::version, and VOID.

{
  char key[MAX_DBKEY_LENGTH];
  uint key_length;
  TABLE *table;
  DBUG_ENTER("mysql_wait_completed_table");

  key_length=(uint) (strmov(strmov(key,lpt->db)+1,lpt->table_name)-key)+1;
  VOID(pthread_mutex_lock(&LOCK_open));
  HASH_SEARCH_STATE state;
  for (table= (TABLE*) hash_first(&open_cache,(byte*) key,key_length,
                                  &state) ;
       table;
       table= (TABLE*) hash_next(&open_cache,(byte*) key,key_length,
                                 &state))
  {
    THD *in_use= table->in_use;
    table->s->version= 0L;
    if (!in_use)
    {
      relink_unused(table);
    }
    else
    {
      /* Kill delayed insert threads */
      if ((in_use->system_thread & SYSTEM_THREAD_DELAYED_INSERT) &&
          ! in_use->killed)
      {
        in_use->killed= THD::KILL_CONNECTION;
        pthread_mutex_lock(&in_use->mysys_var->mutex);
        if (in_use->mysys_var->current_cond)
        {
          pthread_mutex_lock(in_use->mysys_var->current_mutex);
          pthread_cond_broadcast(in_use->mysys_var->current_cond);
          pthread_mutex_unlock(in_use->mysys_var->current_mutex);
        }
        pthread_mutex_unlock(&in_use->mysys_var->mutex);
      }
      /*
        Now we must abort all tables locks used by this thread
        as the thread may be waiting to get a lock for another table
      */
      for (TABLE *thd_table= in_use->open_tables;
           thd_table ;
           thd_table= thd_table->next)
      {
        if (thd_table->db_stat)         // If table is open
          mysql_lock_abort_for_thread(lpt->thd, thd_table);
      }
    }
  }
  /*
    We start by removing all unused objects from the cache and marking
    those in use for removal after completion. Now we also need to abort
    all that are locked and are not progressing due to being locked
    by our lock. We don't upgrade our lock here.
  */
  mysql_lock_abort(lpt->thd, my_table, FALSE);
  VOID(pthread_mutex_unlock(&LOCK_open));
  DBUG_VOID_RETURN;
}

Here is the call graph for this function:

bool open_and_lock_tables	(	THD *	thd,
		TABLE_LIST *	tables
	)

Definition at line 3189 of file sql_base.cc.

References close_tables_for_reopen(), DBUG_ENTER, DBUG_RETURN, lock_tables, mysql_derived_filling(), mysql_derived_prepare(), mysql_handle_derived(), open_tables(), and TRUE.

Referenced by execute_sqlcom_select(), mysql_admin_table(), mysql_delete(), mysql_execute_command(), mysql_insert(), mysql_load(), mysql_table_grant(), mysql_test_delete(), mysql_test_do_fields(), mysql_test_select(), mysql_test_set_fields(), mysqld_help(), sp_lex_keeper::reset_lex_and_exec_core(), and select_like_stmt_test_with_open_n_lock().

{
  uint counter;
  bool need_reopen;
  DBUG_ENTER("open_and_lock_tables");

  for ( ; ; ) 
  {
    if (open_tables(thd, &tables, &counter, 0))
      DBUG_RETURN(-1);
    if (!lock_tables(thd, tables, counter, &need_reopen))
      break;
    if (!need_reopen)
      DBUG_RETURN(-1);
    close_tables_for_reopen(thd, &tables);
  }
  if (mysql_handle_derived(thd->lex, &mysql_derived_prepare) ||
      (thd->fill_derived_tables() &&
       mysql_handle_derived(thd->lex, &mysql_derived_filling)))
    DBUG_RETURN(TRUE); /* purecov: inspected */
  DBUG_RETURN(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TABLE* open_ltable	(	THD *	thd,
		TABLE_LIST *	table_list,
		thr_lock_type	lock_type
	)

Definition at line 3090 of file sql_base.cc.

References check_lock_and_start_stmt(), DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, FRMTYPE_TABLE, st_table_list::grant, st_table::grant, st_reginfo::lock_type, st_table_list::lock_type, mysql_lock_tables(), open_table(), st_table::reginfo, st_table_list::required_type, st_table_list::table, TL_UNLOCK, TL_WRITE, and TL_WRITE_ALLOW_READ.

Referenced by change_password(), db_show_routine_status(), handle_delayed_insert(), mysql_admin_table(), mysql_alter_table(), mysql_checksum_table(), mysql_create_like_table(), mysql_discard_or_import_tablespace(), mysql_install_plugin(), mysql_table_dump(), mysql_uninstall_plugin(), and open_proc_table_for_update().

{
  TABLE *table;
  bool refresh;
  DBUG_ENTER("open_ltable");

  thd->proc_info="Opening table";
  thd->current_tablenr= 0;
  /* open_ltable can be used only for BASIC TABLEs */
  table_list->required_type= FRMTYPE_TABLE;
  while (!(table= open_table(thd, table_list, thd->mem_root, &refresh, 0)) &&
         refresh)
    ;

  if (table)
  {
#if defined( __WIN__)
    /* Win32 can't drop a file that is open */
    if (lock_type == TL_WRITE_ALLOW_READ)
    {
      lock_type= TL_WRITE;
    }
#endif /* __WIN__ */
    table_list->lock_type= lock_type;
    table_list->table=     table;
    table->grant= table_list->grant;
    if (thd->locked_tables)
    {
      if (check_lock_and_start_stmt(thd, table, lock_type))
        table= 0;
    }
    else
    {
      DBUG_ASSERT(thd->lock == 0);      // You must lock everything at once
      if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)
        if (! (thd->lock= mysql_lock_tables(thd, &table_list->table, 1, 0,
                                            &refresh)))
          table= 0;
    }
  }
  thd->proc_info=0;
  DBUG_RETURN(table);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool open_new_frm	(	THD *	thd,
		TABLE_SHARE *	share,
		const char *	alias,
		uint	db_stat,
		uint	prgflag,
		uint	ha_open_flags,
		TABLE *	outparam,
		TABLE_LIST *	table_desc,
		MEM_ROOT *	mem_root
	)			[static]

Definition at line 6317 of file sql_base.cc.

References bzero, st_table_share::db, DBUG_ENTER, DBUG_RETURN, ER_FRM_UNKNOWN_TYPE, ER_WRONG_OBJECT, err, FN_REFLEN, FRMTYPE_TABLE, is_equal(), LEX_STRING::length, my_error(), MYF, mysql_make_view(), st_table_share::normalized_path, NullS, OPEN_VIEW_NO_PARSE, parser, st_table_share::path, path, reg_ext, st_table_list::required_type, sql_parse_prepare(), LEX_STRING::str, strxmov(), st_table_share::table_name, and view_type.

Referenced by open_unireg_entry().

{
  LEX_STRING pathstr;
  File_parser *parser;
  char path[FN_REFLEN];
  DBUG_ENTER("open_new_frm");

  /* Create path with extension */
  pathstr.length= (uint) (strxmov(path, share->normalized_path.str, reg_ext,
                                  NullS)- path);
  pathstr.str=    path;

  if ((parser= sql_parse_prepare(&pathstr, mem_root, 1)))
  {
    if (is_equal(&view_type, parser->type()))
    {
      if (table_desc == 0 || table_desc->required_type == FRMTYPE_TABLE)
      {
        my_error(ER_WRONG_OBJECT, MYF(0), share->db.str, share->table_name.str,
                 "BASE TABLE");
        goto err;
      }
      if (mysql_make_view(thd, parser, table_desc,
                          (prgflag & OPEN_VIEW_NO_PARSE)))
        goto err;
    }
    else
    {
      /* only VIEWs are supported now */
      my_error(ER_FRM_UNKNOWN_TYPE, MYF(0), share->path,  parser->type()->str);
      goto err;
    }
    DBUG_RETURN(0);
  }
 
err:
  bzero(outparam, sizeof(TABLE));       // do not run repair
  DBUG_RETURN(1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool open_normal_and_derived_tables	(	THD *	thd,
		TABLE_LIST *	tables,
		uint	flags
	)

Definition at line 3233 of file sql_base.cc.

References DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, mysql_derived_prepare(), mysql_handle_derived(), open_tables(), and TRUE.

Referenced by get_all_tables(), mysql_test_insert(), mysqld_list_fields(), and mysqld_show_create().

{
  uint counter;
  DBUG_ENTER("open_normal_and_derived_tables");
  DBUG_ASSERT(!thd->fill_derived_tables());
  if (open_tables(thd, &tables, &counter, flags) ||
      mysql_handle_derived(thd->lex, &mysql_derived_prepare))
    DBUG_RETURN(TRUE); /* purecov: inspected */
  DBUG_RETURN(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TABLE* open_table	(	THD *	thd,
		TABLE_LIST *	table_list,
		MEM_ROOT *	mem_root,
		bool *	refresh,
		uint	flags
	)

Definition at line 1809 of file sql_base.cc.

References st_table_list::alias, build_table_filename(), check_stack_overrun(), check_unused, close_old_data_files(), COND_refresh, create_table_def_key(), st_table_list::db, DBUG_ASSERT, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, ER_CANT_REOPEN_TABLE, ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG, ER_TABLE_NOT_LOCKED, error, FN_REFLEN, FRMTYPE_VIEW, hash_delete(), hash_first(), hash_next(), st_table::in_use, int(), key, key_length, LOCK_open, st_table_list::lock_type, MAX_DBKEY_LENGTH, memcmp(), memcpy, my_error(), my_free, my_hash_insert(), my_malloc(), my_realloc(), my_strcasecmp, MY_WME, MYF, mysql_frm_type(), mysql_ha_flush(), st_table::next, NO_TMP_TABLE, NULL, open_cache, open_unireg_entry(), OPEN_VIEW_NO_PARSE, path, st_table::prev, pthread_mutex_lock, pthread_mutex_unlock, st_table::query_id, st_hash::records, refresh_version, reg1, reg_ext, st_table_list::skip_temporary, STACK_MIN_SIZE_FOR_OPEN, STATUS_NO_RECORD, strcmp(), strlen(), system_charset_info, table_alias_charset, table_cache_size, st_table_list::table_name, TL_READ, TL_WRITE_ALLOW_WRITE, TRUE, unused_tables, st_table_list::updatable, st_table_list::view, VOID, and wait_for_condition().

Referenced by ha_myisammrg::append_create_info(), create_table_from_items(), fill_defined_view_parts(), open_ltable(), open_proc_table_for_read(), ha_myisammrg::store_lock(), and ha_myisammrg::update_create_info().

{
  reg1  TABLE *table;
  char  key[MAX_DBKEY_LENGTH];
  uint  key_length;
  char  *alias= table_list->alias;
  HASH_SEARCH_STATE state;
  DBUG_ENTER("open_table");

  /* find a unused table in the open table cache */
  if (refresh)
    *refresh=0;

  /* an open table operation needs a lot of the stack space */
  if (check_stack_overrun(thd, STACK_MIN_SIZE_FOR_OPEN, (char *)&alias))
    DBUG_RETURN(0);

  if (thd->killed)
    DBUG_RETURN(0);

  key_length= (create_table_def_key(thd, key, table_list, 1) -
               TMP_TABLE_KEY_EXTRA);

  if (!table_list->skip_temporary)
  {
    for (table= thd->temporary_tables; table ; table=table->next)
    {
      if (table->s->table_cache_key.length == key_length +
          TMP_TABLE_KEY_EXTRA &&
          !memcmp(table->s->table_cache_key.str, key,
                  key_length + TMP_TABLE_KEY_EXTRA))
      {
        if (table->query_id == thd->query_id ||
            thd->prelocked_mode && table->query_id)
        {
          my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
          DBUG_RETURN(0);
        }
        table->query_id= thd->query_id;
        table->clear_query_id= 1;
        thd->tmp_table_used= 1;
        DBUG_PRINT("info",("Using temporary table"));
        goto reset;
      }
    }
  }

  if (!(flags & MYSQL_OPEN_IGNORE_LOCKED_TABLES) &&
      (thd->locked_tables || thd->prelocked_mode))
  {                                             // Using table locks
    TABLE *best_table= 0;
    int best_distance= INT_MIN;
    bool check_if_used= thd->prelocked_mode &&
                        ((int) table_list->lock_type >=
                         (int) TL_WRITE_ALLOW_WRITE);
    for (table=thd->open_tables; table ; table=table->next)
    {
      if (table->s->table_cache_key.length == key_length &&
          !memcmp(table->s->table_cache_key.str, key, key_length))
      {
        if (check_if_used && table->query_id &&
            table->query_id != thd->query_id)
        {
          /*
            If we are in stored function or trigger we should ensure that
            we won't change table that is already used by calling statement.
            So if we are opening table for writing, we should check that it
            is not already open by some calling stamement.
          */
          my_error(ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG, MYF(0),
                   table->s->table_name.str);
          DBUG_RETURN(0);
        }
        if (!my_strcasecmp(system_charset_info, table->alias, alias) &&
            table->query_id != thd->query_id && /* skip tables already used */
            !(thd->prelocked_mode && table->query_id))
        {
          int distance= ((int) table->reginfo.lock_type -
                         (int) table_list->lock_type);
          /*
            Find a table that either has the exact lock type requested,
            or has the best suitable lock. In case there is no locked
            table that has an equal or higher lock than requested,
            we us the closest matching lock to be able to produce an error
            message about wrong lock mode on the table. The best_table
            is changed if bd < 0 <= d or bd < d < 0 or 0 <= d < bd.

            distance <  0 - No suitable lock found
            distance >  0 - we have lock mode higher then we require
            distance == 0 - we have lock mode exactly which we need
          */
          if (best_distance < 0 && distance > best_distance ||
              distance >= 0 && distance < best_distance)
          {
            best_distance= distance;
            best_table= table;
            if (best_distance == 0 && !check_if_used)
            {
              /*
                If we have found perfect match and we don't need to check that
                table is not used by one of calling statements (assuming that
                we are inside of function or trigger) we can finish iterating
                through open tables list.
              */
              break;
            }
          }
        }
      }
    }
    if (best_table)
    {
      table= best_table;
      table->query_id= thd->query_id;
      DBUG_PRINT("info",("Using locked table"));
      goto reset;
    }
    /*
      is it view?
      (it is work around to allow to open view with locked tables,
      real fix will be made after definition cache will be made)
    */
    {
      char path[FN_REFLEN];
      enum legacy_db_type not_used;
      build_table_filename(path, sizeof(path) - 1,
                           table_list->db, table_list->table_name, reg_ext, 0);
      if (mysql_frm_type(thd, path, &not_used) == FRMTYPE_VIEW)
      {
        /*
          Will not be used (because it's VIEW) but has to be passed.
          Also we will not free it (because it is a stack variable).
        */
        TABLE tab;
        table= &tab;
        VOID(pthread_mutex_lock(&LOCK_open));
        if (!open_unireg_entry(thd, table, table_list, alias,
                              key, key_length, mem_root, 0))
        {
          DBUG_ASSERT(table_list->view != 0);
          VOID(pthread_mutex_unlock(&LOCK_open));
          DBUG_RETURN(0); // VIEW
        }
        VOID(pthread_mutex_unlock(&LOCK_open));
      }
    }
    my_error(ER_TABLE_NOT_LOCKED, MYF(0), alias);
    DBUG_RETURN(0);
  }

  VOID(pthread_mutex_lock(&LOCK_open));

  if (!thd->open_tables)
    thd->version=refresh_version;
  else if ((thd->version != refresh_version) &&
           ! (flags & MYSQL_LOCK_IGNORE_FLUSH))
  {
    /* Someone did a refresh while thread was opening tables */
    if (refresh)
      *refresh=1;
    VOID(pthread_mutex_unlock(&LOCK_open));
    DBUG_RETURN(0);
  }

  /* close handler tables which are marked for flush */
  if (thd->handler_tables)
    mysql_ha_flush(thd, (TABLE_LIST*) NULL, MYSQL_HA_REOPEN_ON_USAGE, TRUE);

  for (table= (TABLE*) hash_first(&open_cache, (byte*) key, key_length,
                                  &state);
       table && table->in_use ;
       table= (TABLE*) hash_next(&open_cache, (byte*) key, key_length,
                                 &state))
  {
    /*
      Here we flush tables marked for flush. However we never flush log
      tables here. They are flushed only on FLUSH LOGS.
    */
    if (table->s->version != refresh_version && !table->s->log_table)
    {
      DBUG_PRINT("note",
                 ("Found table '%s.%s' with different refresh version",
                  table_list->db, table_list->table_name));

      if (flags & MYSQL_LOCK_IGNORE_FLUSH)
      {
        /* Force close at once after usage */
        thd->version= table->s->version;
        continue;
      }

      /*
        There is a refresh in progress for this table
        Wait until the table is freed or the thread is killed.
      */
      close_old_data_files(thd,thd->open_tables,0,0);
      if (table->in_use != thd)
        wait_for_condition(thd, &LOCK_open, &COND_refresh);
      else
      {
        VOID(pthread_mutex_unlock(&LOCK_open));
      }
      if (refresh)
        *refresh=1;
      DBUG_RETURN(0);
    }
  }
  if (table)
  {
    if (table == unused_tables)
    {                                           // First unused
      unused_tables=unused_tables->next;        // Remove from link
      if (table == unused_tables)
        unused_tables=0;
    }
    table->prev->next=table->next;              /* Remove from unused list */
    table->next->prev=table->prev;
    table->in_use= thd;
  }
  else
  {
    int error;
    /* Free cache if too big */
    while (open_cache.records > table_cache_size && unused_tables)
      VOID(hash_delete(&open_cache,(byte*) unused_tables)); /* purecov: tested */

    /* make a new table */
    if (!(table=(TABLE*) my_malloc(sizeof(*table),MYF(MY_WME))))
    {
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(NULL);
    }

    error= open_unireg_entry(thd, table, table_list, alias, key, key_length,
                             mem_root, (flags & OPEN_VIEW_NO_PARSE));
    if (error > 0)
    {
      my_free((gptr)table, MYF(0));
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(NULL);
    }
    if (table_list->view || error < 0)
    {
      /*
        VIEW not really opened, only frm were read.
        Set 1 as a flag here
      */
      if (error < 0)
        table_list->view= (st_lex*)1;

      my_free((gptr)table, MYF(0));
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(0); // VIEW
    }
    DBUG_PRINT("info", ("inserting table %p into the cache", table));
    VOID(my_hash_insert(&open_cache,(byte*) table));
  }

  check_unused();                               // Debugging call

  VOID(pthread_mutex_unlock(&LOCK_open));
  if (refresh)
  {
    table->next=thd->open_tables;               /* Link into simple list */
    thd->open_tables=table;
  }
  table->reginfo.lock_type=TL_READ;             /* Assume read */

 reset:
  DBUG_ASSERT(table->s->ref_count > 0 || table->s->tmp_table != NO_TMP_TABLE);

  if (thd->lex->need_correct_ident())
    table->alias_name_used= my_strcasecmp(table_alias_charset,
                                          table->s->table_name.str, alias);
  /* Fix alias if table name changes */
  if (strcmp(table->alias, alias))
  {
    uint length=(uint) strlen(alias)+1;
    table->alias= (char*) my_realloc((char*) table->alias, length,
                                     MYF(MY_WME));
    memcpy((char*) table->alias, alias, length);
  }
  /* These variables are also set in reopen_table() */
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
  table->null_row= table->maybe_null= table->force_index= 0;
  table->status=STATUS_NO_RECORD;
  table->keys_in_use_for_query= table->s->keys_in_use;
  table->insert_values= 0;
  table->used_keys= table->s->keys_for_keyread;
  table->fulltext_searched= 0;
  table->file->ft_handler= 0;
  if (table->timestamp_field)
    table->timestamp_field_type= table->timestamp_field->get_auto_set_type();
  table_list->updatable= 1; // It is not derived table nor non-updatable VIEW
  table->clear_column_bitmaps();
  DBUG_ASSERT(table->key_read == 0);
  DBUG_RETURN(table);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int open_tables	(	THD *	thd,
		TABLE_LIST **	start,
		uint *	counter,
		uint	flags
	)

Definition at line 2830 of file sql_base.cc.

References DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, st_table_list::derived, err, init_alloc_root(), mysql_schema_table(), st_table_list::next_global, st_table_list::schema_table, sp_cache_routines_and_add_tables(), sp_get_prelocking_info(), start(), and st_table_list::view.

Referenced by mysql_ha_open(), mysql_multi_update_prepare(), mysql_test_update(), mysql_update(), open_and_lock_tables(), open_normal_and_derived_tables(), and simple_open_n_lock_tables().

{
  TABLE_LIST *tables;
  bool refresh;
  int result=0;
  MEM_ROOT new_frm_mem;
  /* Also used for indicating that prelocking is need */
  TABLE_LIST **query_tables_last_own;
  DBUG_ENTER("open_tables");
  /*
    temporary mem_root for new .frm parsing.
    TODO: variables for size
  */
  init_alloc_root(&new_frm_mem, 8024, 8024);

  thd->current_tablenr= 0;
 restart:
  *counter= 0;
  query_tables_last_own= 0;
  thd->proc_info="Opening tables";

  /*
    If we are not already executing prelocked statement and don't have
    statement for which table list for prelocking is already built, let
    us cache routines and try to build such table list.

  */

  if (!thd->prelocked_mode && !thd->lex->requires_prelocking() &&
      thd->lex->sroutines_list.elements)
  {
    bool first_no_prelocking, need_prelocking;
    TABLE_LIST **save_query_tables_last= thd->lex->query_tables_last;

    DBUG_ASSERT(thd->lex->query_tables == *start);
    sp_get_prelocking_info(thd, &need_prelocking, &first_no_prelocking);

    if (sp_cache_routines_and_add_tables(thd, thd->lex, first_no_prelocking))
    {
      /*
        Serious error during reading stored routines from mysql.proc table.
        Something's wrong with the table or its contents, and an error has
        been emitted; we must abort.
      */
      result= -1;
      goto err;
    }
    else if (need_prelocking)
    {
      query_tables_last_own= save_query_tables_last;
      *start= thd->lex->query_tables;
    }
  }

  for (tables= *start; tables ;tables= tables->next_global)
  {
    /*
      Ignore placeholders for derived tables. After derived tables
      processing, link to created temporary table will be put here.
      If this is derived table for view then we still want to process
      routines used by this view.
     */
    if (tables->derived)
    {
      if (tables->view)
        goto process_view_routines;
      continue;
    }
    if (tables->schema_table)
    {
      if (!mysql_schema_table(thd, thd->lex, tables))
        continue;
      DBUG_RETURN(-1);
    }
    (*counter)++;
    
    if (!tables->table &&
        !(tables->table= open_table(thd, tables, &new_frm_mem, &refresh, flags)))
    {
      free_root(&new_frm_mem, MYF(MY_KEEP_PREALLOC));

      if (tables->view)
      {
        /* VIEW placeholder */
        (*counter)--;

        /*
          tables->next_global list consists of two parts:
          1) Query tables and underlying tables of views.
          2) Tables used by all stored routines that this statement invokes on
             execution.
          We need to know where the bound between these two parts is. If we've
          just opened a view, which was the last table in part #1, and it
          has added its base tables after itself, adjust the boundary pointer
          accordingly.
        */
        if (query_tables_last_own == &(tables->next_global) &&
            tables->view->query_tables)
          query_tables_last_own= tables->view->query_tables_last;
        /*
          Let us free memory used by 'sroutines' hash here since we never
          call destructor for this LEX.
        */
        hash_free(&tables->view->sroutines);
        goto process_view_routines;
      }

      if (refresh)                              // Refresh in progress
      {
        /*
          We have met name-locked or old version of table. Now we have
          to close all tables which are not up to date. We also have to
          throw away set of prelocked tables (and thus close tables from
          this set that were open by now) since it possible that one of
          tables which determined its content was changed.

          Instead of implementing complex/non-robust logic mentioned
          above we simply close and then reopen all tables.

          In order to prepare for recalculation of set of prelocked tables
          we pretend that we have finished calculation which we were doing
          currently.
        */
        if (query_tables_last_own)
          thd->lex->mark_as_requiring_prelocking(query_tables_last_own);
        close_tables_for_reopen(thd, start);
        goto restart;
      }
      result= -1;                               // Fatal error
      break;
    }
    else
    {
      /*
        If we are not already in prelocked mode and extended table list is not
        yet built and we have trigger for table being opened then we should
        cache all routines used by its triggers and add their tables to
        prelocking list.
        If we lock table for reading we won't update it so there is no need to
        process its triggers since they never will be activated.
      */
      if (!thd->prelocked_mode && !thd->lex->requires_prelocking() &&
          tables->table->triggers &&
          tables->lock_type >= TL_WRITE_ALLOW_WRITE)
      {
        if (!query_tables_last_own)
          query_tables_last_own= thd->lex->query_tables_last;
        if (sp_cache_routines_and_add_tables_for_triggers(thd, thd->lex,
                                                          tables))
        {
          /*
            Serious error during reading stored routines from mysql.proc table.
            Something's wrong with the table or its contents, and an error has
            been emitted; we must abort.
          */
          result= -1;
          goto err;
        }
      }
      free_root(&new_frm_mem, MYF(MY_KEEP_PREALLOC));
    }

    if (tables->lock_type != TL_UNLOCK && ! thd->locked_tables)
      tables->table->reginfo.lock_type=tables->lock_type;
    tables->table->grant= tables->grant;

process_view_routines:
    /*
      Again we may need cache all routines used by this view and add
      tables used by them to table list.
    */
    if (tables->view && !thd->prelocked_mode &&
        !thd->lex->requires_prelocking() &&
        tables->view->sroutines_list.elements)
    {
      /* We have at least one table in TL here. */
      if (!query_tables_last_own)
        query_tables_last_own= thd->lex->query_tables_last;
      if (sp_cache_routines_and_add_tables_for_view(thd, thd->lex, tables))
      {
        /*
          Serious error during reading stored routines from mysql.proc table.
          Something's wrong with the table or its contents, and an error has
          been emitted; we must abort.
        */
        result= -1;
        goto err;
      }
    }
  }

 err:
  thd->proc_info=0;
  free_root(&new_frm_mem, MYF(0));              // Free pre-alloced block

  if (query_tables_last_own)
    thd->lex->mark_as_requiring_prelocking(query_tables_last_own);

  DBUG_RETURN(result);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TABLE* open_temporary_table	(	THD *	thd,
		const char *	path,
		const char *	db,
		const char *	table_name,
		bool	link_in_list
	)

Definition at line 3489 of file sql_base.cc.

References COMPUTE_TYPES, create_table_def_key(), st_table_list::db, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, EXTRA_RECORD, FALSE, free_table_share(), HA_GET_INDEX, HA_OPEN_KEYFILE, ha_open_options, HA_OPEN_RNDFILE, init_tmp_table_share(), key_length, MAX_DBKEY_LENGTH, memcpy, my_free, my_malloc(), MY_WME, MYF, open_table_def(), open_table_from_share(), READ_KEYINFO, slave_open_temp_tables, strend(), strlen(), strmov(), st_table_list::table_name, TL_WRITE, TMP_TABLE, and TRANSACTIONAL_TMP_TABLE.

Referenced by mysql_create_like_table(), mysql_create_table_internal(), and mysql_truncate().

{
  TABLE *tmp_table;
  TABLE_SHARE *share;
  char cache_key[MAX_DBKEY_LENGTH], *saved_cache_key, *tmp_path;
  uint key_length;
  TABLE_LIST table_list;
  DBUG_ENTER("open_temporary_table");
  DBUG_PRINT("enter", ("table: '%s'.'%s'  path: '%s'",
                       db, table_name, path));

  table_list.db=         (char*) db;
  table_list.table_name= (char*) table_name;
  /* Create the cache_key for temporary tables */
  key_length= create_table_def_key(thd, cache_key, &table_list, 1);

  if (!(tmp_table= (TABLE*) my_malloc(sizeof(*tmp_table) + sizeof(*share) +
                                      strlen(path)+1 + key_length,
                                      MYF(MY_WME))))
    DBUG_RETURN(0);                             /* purecov: inspected */

  share= (TABLE_SHARE*) (tmp_table+1);
  tmp_path= (char*) (share+1);
  saved_cache_key= strmov(tmp_path, path)+1;
  memcpy(saved_cache_key, cache_key, key_length);

  init_tmp_table_share(share, saved_cache_key, key_length,
                       strend(saved_cache_key)+1, tmp_path);

  if (open_table_def(thd, share, 0) ||
      open_table_from_share(thd, share, table_name,
                            (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
                                    HA_GET_INDEX),
                            READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
                            ha_open_options,
                            tmp_table, FALSE))
  {
    /* No need to lock share->mutex as this is not needed for tmp tables */
    free_table_share(share);
    my_free((char*) tmp_table,MYF(0));
    DBUG_RETURN(0);
  }

  tmp_table->reginfo.lock_type= TL_WRITE;        // Simulate locked
  share->tmp_table= (tmp_table->file->has_transactions() ? 
                     TRANSACTIONAL_TMP_TABLE : TMP_TABLE);

  if (link_in_list)
  {
    /* growing temp list at the head */
    tmp_table->next= thd->temporary_tables;
    if (tmp_table->next)
      tmp_table->next->prev= tmp_table;
    thd->temporary_tables= tmp_table;
    thd->temporary_tables->prev= 0;
    if (thd->slave_thread)
      slave_open_temp_tables++;
  }
  DBUG_RETURN(tmp_table);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int open_unireg_entry	(	THD *	thd,
		TABLE *	entry,
		TABLE_LIST *	table_list,
		const char *	alias,
		char *	cache_key,
		uint	cache_key_length,
		MEM_ROOT *	mem_root,
		uint	flags
	)			[static]

Definition at line 2624 of file sql_base.cc.

References Table_triggers_list::check_n_load(), closefrm(), COMPUTE_TYPES, st_table_share::db, st_table_list::db, DBUG_ENTER, DBUG_RETURN, ER_NOT_KEYFILE, err, error, EXTRA_RECORD, FALSE, get_table_share_with_create(), ha_create_table_from_engine(), HA_GET_INDEX, HA_OPEN_FOR_REPAIR, HA_OPEN_KEYFILE, ha_open_options, HA_OPEN_RNDFILE, HA_TRY_READ_ONLY, int(), MYSQL_LOG::is_open(), st_table_share::is_view, LEX_STRING::length, LOCK_open, lock_table_name(), my_errno, my_error(), my_free, my_malloc(), MY_WME, MYF, mysql_bin_log, mysql_reset_errors(), NullS, open_new_frm(), open_table_from_share(), OPEN_VIEW, OPEN_VIEW_NO_PARSE, pthread_mutex_lock, pthread_mutex_unlock, READ_KEYINFO, st_table_share::ref_count, RELEASE_NORMAL, release_table_share(), RELEASE_WAIT_FOR_DROP, safe_mutex_assert_owner, sql_print_error(), LEX_STRING::str, strmov(), strxmov(), st_table_share::table_name, st_table_list::table_name, TRUE, unlikely, unlock_table_name(), st_table_share::version, and wait_for_locked_table_names().

Referenced by open_table(), reopen_name_locked_table(), and reopen_table().

{
  int error;
  TABLE_SHARE *share;
  uint discover_retry_count= 0;
  DBUG_ENTER("open_unireg_entry");

  safe_mutex_assert_owner(&LOCK_open);

retry:
  if (!(share= get_table_share_with_create(thd, table_list, cache_key,
                                           cache_key_length, 
                                           OPEN_VIEW, &error)))
    DBUG_RETURN(1);

  if (share->is_view)
  {
    /* Open view */
    error= (int) open_new_frm(thd, share, alias,
                              (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
                                      HA_GET_INDEX | HA_TRY_READ_ONLY),
                              READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD |
                              (flags & OPEN_VIEW_NO_PARSE),
                              thd->open_options, entry, table_list,
                              mem_root);
    if (error)
      goto err;
    /* TODO: Don't free this */
    release_table_share(share, RELEASE_NORMAL);
    DBUG_RETURN((flags & OPEN_VIEW_NO_PARSE)? -1 : 0);
  }

  while ((error= open_table_from_share(thd, share, alias,
                                       (uint) (HA_OPEN_KEYFILE |
                                               HA_OPEN_RNDFILE |
                                               HA_GET_INDEX |
                                               HA_TRY_READ_ONLY),
                                       (READ_KEYINFO | COMPUTE_TYPES |
                                        EXTRA_RECORD),
                                       thd->open_options, entry, FALSE)))
  {
    if (error == 7)                             // Table def changed
    {
      share->version= 0;                        // Mark share as old
      if (discover_retry_count++)               // Retry once
        goto err;

      /*
        TODO:
        Here we should wait until all threads has released the table.
        For now we do one retry. This may cause a deadlock if there
        is other threads waiting for other tables used by this thread.
        
        Proper fix would be to if the second retry failed:
        - Mark that table def changed
        - Return from open table
        - Close all tables used by this thread
        - Start waiting that the share is released
        - Retry by opening all tables again
      */
      if (ha_create_table_from_engine(thd, table_list->db,
                                      table_list->table_name))
        goto err;
      /*
        TO BE FIXED
        To avoid deadlock, only wait for release if no one else is
        using the share.
      */
      if (share->ref_count != 1)
        goto err;
      /* Free share and wait until it's released by all threads */
      release_table_share(share, RELEASE_WAIT_FOR_DROP);
      if (!thd->killed)
      {
        mysql_reset_errors(thd, 1);         // Clear warnings
        thd->clear_error();                 // Clear error message
        goto retry;
      }
      DBUG_RETURN(1);
    }
    if (!entry->s || !entry->s->crashed)
      goto err;
     // Code below is for repairing a crashed file
     if ((error= lock_table_name(thd, table_list, TRUE)))
     {
       if (error < 0)
        goto err;
       if (wait_for_locked_table_names(thd, table_list))
       {
        unlock_table_name(thd, table_list);
        goto err;
       }
     }
     pthread_mutex_unlock(&LOCK_open);
     thd->clear_error();                                // Clear error message
     error= 0;
     if (open_table_from_share(thd, share, alias,
                               (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
                                       HA_GET_INDEX |
                                       HA_TRY_READ_ONLY),
                               READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
                               ha_open_options | HA_OPEN_FOR_REPAIR,
                               entry, FALSE) || ! entry->file ||
        (entry->file->is_crashed() && entry->file->check_and_repair(thd)))
     {
       /* Give right error message */
       thd->clear_error();
       my_error(ER_NOT_KEYFILE, MYF(0), share->table_name.str, my_errno);
       sql_print_error("Couldn't repair table: %s.%s", share->db.str,
                       share->table_name.str);
       if (entry->file)
        closefrm(entry, 0);
       error=1;
     }
     else
       thd->clear_error();                      // Clear error message
     pthread_mutex_lock(&LOCK_open);
     unlock_table_name(thd, table_list);
 
     if (error)
       goto err;
     break;
   }

  if (Table_triggers_list::check_n_load(thd, share->db.str,
                                        share->table_name.str, entry, 0))
  {
    closefrm(entry, 0);
    goto err;
  }

  /*
    If we are here, there was no fatal error (but error may be still
    unitialized).
  */
  if (unlikely(entry->file->implicit_emptied))
  {
    entry->file->implicit_emptied= 0;
    if (mysql_bin_log.is_open())
    {
      char *query, *end;
      uint query_buf_size= 20 + share->db.length + share->table_name.length +1;
      if ((query= (char*) my_malloc(query_buf_size,MYF(MY_WME))))
      {
        /* this DELETE FROM is needed even with row-based binlogging */
        end = strxmov(strmov(query, "DELETE FROM `"),
                      share->db.str,"`.`",share->table_name.str,"`", NullS);
        thd->binlog_query(THD::STMT_QUERY_TYPE,
                          query, (ulong)(end-query), FALSE, FALSE);
        my_free(query, MYF(0));
      }
      else
      {
        /*
          As replication is maybe going to be corrupted, we need to warn the
          DBA on top of warning the client (which will automatically be done
          because of MYF(MY_WME) in my_malloc() above).
        */
        sql_print_error("When opening HEAP table, could not allocate memory "
                        "to write 'DELETE FROM `%s`.`%s`' to the binary log",
                        table_list->db, table_list->table_name);
        delete entry->triggers;
        closefrm(entry, 0);
        goto err;
      }
    }
  }
  DBUG_RETURN(0);

err:
  release_table_share(share, RELEASE_NORMAL);
  DBUG_RETURN(1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void release_table_share	(	TABLE_SHARE *	share,
		enum release_type	type
	)

Definition at line 502 of file sql_base.cc.

References st_table_share::db, DBUG_ASSERT, DBUG_ENTER, DBUG_PRINT, DBUG_VOID_RETURN, end_of_unused_share, free_table_share(), hash_delete(), hash_replace(), hash_search(), key, key_length, LOCK_open, LOCK_table_share, st_table_share::next, st_table_share::prev, pthread_mutex_lock, pthread_mutex_unlock, st_hash::records, refresh_version, RELEASE_WAIT_FOR_DROP, safe_mutex_assert_owner, LEX_STRING::str, table_def_cache, and table_def_size.

Referenced by close_handle_and_leave_table_as_lock(), closefrm(), mysql_drop_view(), open_unireg_entry(), and prepare_for_repair().

{
  bool to_be_deleted= 0;
  DBUG_ENTER("release_table_share");
  DBUG_PRINT("enter",
             ("share: 0x%lx  table: %s.%s  ref_count: %u  version: %lu",
              (ulong) share, share->db.str, share->table_name.str,
              share->ref_count, share->version));

  safe_mutex_assert_owner(&LOCK_open);

  pthread_mutex_lock(&share->mutex);
  if (!--share->ref_count)
  {
    if (share->version != refresh_version)
      to_be_deleted=1;
    else
    {
      /* Link share last in used_table_share list */
      DBUG_PRINT("info",("moving share to unused list"));

      DBUG_ASSERT(share->next == 0);
      pthread_mutex_lock(&LOCK_table_share);
      share->prev= end_of_unused_share.prev;
      *end_of_unused_share.prev= share;
      end_of_unused_share.prev= &share->next;
      share->next= &end_of_unused_share;
      pthread_mutex_unlock(&LOCK_table_share);

      to_be_deleted= (table_def_cache.records > table_def_size);
    }
  }

  if (to_be_deleted)
  {
    DBUG_PRINT("info", ("Deleting share"));
    hash_delete(&table_def_cache, (byte*) share);
    DBUG_VOID_RETURN;
  }
  pthread_mutex_unlock(&share->mutex);
  DBUG_VOID_RETURN;


#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
  if (to_be_deleted)
  {
    /*
      We must try again with new locks as we must get LOCK_open
      before share->mutex
    */
    pthread_mutex_unlock(&share->mutex);
    pthread_mutex_lock(&LOCK_open);
    pthread_mutex_lock(&share->mutex);
    if (!share->ref_count)
    {                                           // No one is using this now
      TABLE_SHARE *name_lock;
      if (share->replace_with_name_lock && (name_lock=get_name_lock(share)))
      {
        /*
          This code is execured when someone does FLUSH TABLES while on has
          locked tables.
         */
        (void) hash_search(&def_cache,(byte*) key,key_length);
        hash_replace(&def_cache, def_cache.current_record,(byte*) name_lock);
      }
      else
      {
        /* Remove table definition */
        hash_delete(&def_cache,(byte*) share);
      }
      pthread_mutex_unlock(&LOCK_open);
      free_table_share(share);
    }
    else
    {
      pthread_mutex_unlock(&LOCK_open);
      if (type == RELEASE_WAIT_FOR_DROP)
        wait_for_table(share, "Waiting for close");
      else
        pthread_mutex_unlock(&share->mutex);
    }
  }
  else if (type == RELEASE_WAIT_FOR_DROP)
    wait_for_table(share, "Waiting for close");
  else
    pthread_mutex_unlock(&share->mutex);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void relink_unused

(

TABLE *

table

)

[static]

Definition at line 1619 of file sql_base.cc.

References check_unused, st_table::next, st_table::prev, and unused_tables.

Referenced by mysql_wait_completed_table(), remove_db_from_cache(), and remove_table_from_cache().

{
  if (table != unused_tables)
  {
    table->prev->next=table->next;              /* Remove from unused list */
    table->next->prev=table->prev;
    table->next=unused_tables;                  /* Link in unused tables */
    table->prev=unused_tables->prev;
    unused_tables->prev->next=table;
    unused_tables->prev=table;
    unused_tables=table;
    check_unused();
  }
}

Here is the caller graph for this function:

void remove_db_from_cache

(

const char *

db

)

Definition at line 6079 of file sql_base.cc.

References hash_element(), open_cache, st_hash::records, relink_unused(), and strcmp().

Referenced by mysql_rm_db().

{
  for (uint idx=0 ; idx < open_cache.records ; idx++)
  {
    TABLE *table=(TABLE*) hash_element(&open_cache,idx);
    if (!strcmp(table->s->db.str, db))
    {
      table->s->version= 0L;                    /* Free when thread is ready */
      if (!table->in_use)
        relink_unused(table);
    }
  }
  while (unused_tables && !unused_tables->s->version)
    VOID(hash_delete(&open_cache,(byte*) unused_tables));
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool remove_table_from_cache	(	THD *	thd,
		const char *	db,
		const char *	table_name,
		uint	flags
	)

Definition at line 6128 of file sql_base.cc.

References broadcast_refresh(), COND_refresh, st_table::db_stat, DBUG_ENTER, DBUG_PRINT, dropping_tables, hash_delete(), hash_first(), hash_next(), hash_search(), st_table::in_use, key, key_length, KILL_CONNECTION, likely, LOCK_open, MAX_DBKEY_LENGTH, st_table_share::mutex, mysql_lock_abort_for_thread(), open_cache, pthread_mutex_lock, pthread_mutex_unlock, st_table_share::ref_count, relink_unused(), st_table::s, set_timespec, strmov(), table_def_cache, unused_tables, st_table_share::version, and VOID.

Referenced by abort_and_upgrade_lock(), close_cached_tables(), close_open_tables_and_downgrade(), lock_table_name(), mysql_admin_table(), mysql_rm_table_part2(), and wait_while_table_is_used().

{
  char key[MAX_DBKEY_LENGTH];
  uint key_length;
  TABLE *table;
  TABLE_SHARE *share;
  bool result= 0, signalled= 0;
  DBUG_ENTER("remove_table_from_cache");
  DBUG_PRINT("enter", ("Table: '%s.%s'  flags: %u", db, table_name, flags));

  key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
  for (;;)
  {
    HASH_SEARCH_STATE state;
    result= signalled= 0;

    for (table= (TABLE*) hash_first(&open_cache, (byte*) key, key_length,
                                    &state);
         table;
         table= (TABLE*) hash_next(&open_cache, (byte*) key, key_length,
                                   &state))
    {
      THD *in_use;

      table->s->version=0L;             /* Free when thread is ready */
      if (!(in_use=table->in_use))
      {
        DBUG_PRINT("info",("Table was not in use"));
        relink_unused(table);
      }
      else if (in_use != thd)
      {
        DBUG_PRINT("info", ("Table was in use by other thread"));
        in_use->some_tables_deleted=1;
        if (table->db_stat)
        {
          DBUG_PRINT("info", ("Found another active instance of the table"));
          result=1;
        }
        /* Kill delayed insert threads */
        if ((in_use->system_thread & SYSTEM_THREAD_DELAYED_INSERT) &&
            ! in_use->killed)
        {
          in_use->killed= THD::KILL_CONNECTION;
          pthread_mutex_lock(&in_use->mysys_var->mutex);
          if (in_use->mysys_var->current_cond)
          {
            pthread_mutex_lock(in_use->mysys_var->current_mutex);
            signalled= 1;
            pthread_cond_broadcast(in_use->mysys_var->current_cond);
            pthread_mutex_unlock(in_use->mysys_var->current_mutex);
          }
          pthread_mutex_unlock(&in_use->mysys_var->mutex);
        }
        /*
          Now we must abort all tables locks used by this thread
          as the thread may be waiting to get a lock for another table
        */
        for (TABLE *thd_table= in_use->open_tables;
             thd_table ;
             thd_table= thd_table->next)
        {
          if (thd_table->db_stat)               // If table is open
            signalled|= mysql_lock_abort_for_thread(thd, thd_table);
        }
      }
      else
      {
        DBUG_PRINT("info", ("Table was in use by current thread. db_stat: %u",
                            table->db_stat));
        result= result || (flags & RTFC_OWNED_BY_THD_FLAG);
      }
    }
    while (unused_tables && !unused_tables->s->version)
      VOID(hash_delete(&open_cache,(byte*) unused_tables));

    DBUG_PRINT("info", ("Removing table from table_def_cache"));
    /* Remove table from table definition cache if it's not in use */
    if ((share= (TABLE_SHARE*) hash_search(&table_def_cache,(byte*) key,
                                           key_length)))
    {
      DBUG_PRINT("info", ("share version: %lu  ref_count: %u",
                          share->version, share->ref_count));
      share->version= 0;                          // Mark for delete
      if (share->ref_count == 0)
      {
        pthread_mutex_lock(&share->mutex);
        VOID(hash_delete(&table_def_cache, (byte*) share));
      }
    }

    if (result && (flags & RTFC_WAIT_OTHER_THREAD_FLAG))
    {
      /*
        Signal any thread waiting for tables to be freed to
        reopen their tables
      */
      broadcast_refresh();
      DBUG_PRINT("info", ("Waiting for refresh signal"));
      if (!(flags & RTFC_CHECK_KILLED_FLAG) || !thd->killed)
      {
        dropping_tables++;
        if (likely(signalled))
          (void) pthread_cond_wait(&COND_refresh, &LOCK_open);
        else
        {
          struct timespec abstime;
          /*
            It can happen that another thread has opened the
            table but has not yet locked any table at all. Since
            it can be locked waiting for a table that our thread
            has done LOCK TABLE x WRITE on previously, we need to
            ensure that the thread actually hears our signal
            before we go to sleep. Thus we wait for a short time
            and then we retry another loop in the
            remove_table_from_cache routine.
          */
          set_timespec(abstime, 10);
          pthread_cond_timedwait(&COND_refresh, &LOCK_open, &abstime);
        }
        dropping_tables--;
        continue;
      }
    }
    break;
  }
  DBUG_RETURN(result);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool rename_temporary_table	(	THD *	thd,
		TABLE *	table,
		const char *	db,
		const char *	table_name
	)

Definition at line 1597 of file sql_base.cc.

References alloc_root(), create_table_def_key(), st_table_list::db, DBUG_ENTER, DBUG_RETURN, key, key_length, MAX_DBKEY_LENGTH, st_table_share::mem_root, st_table::s, st_table_share::set_table_cache_key(), and st_table_list::table_name.

{
  char *key;
  uint key_length;
  TABLE_SHARE *share= table->s;
  TABLE_LIST table_list;
  DBUG_ENTER("rename_temporary_table");

  if (!(key=(char*) alloc_root(&share->mem_root, MAX_DBKEY_LENGTH)))
    DBUG_RETURN(1);                             /* purecov: inspected */

  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
  key_length= create_table_def_key(thd, key, &table_list, 1);
  share->set_table_cache_key(key, key_length);
  DBUG_RETURN(0);
}

Here is the call graph for this function:

bool reopen_name_locked_table	(	THD *	thd,
		TABLE_LIST *	table_list
	)

Definition at line 1733 of file sql_base.cc.

References check_unused, st_table::const_table, DBUG_ENTER, DBUG_RETURN, FALSE, st_table_share::flush_version, st_table::force_index, st_table::in_use, intern_close_table(), st_table_share::keys_for_keyread, st_table_share::keys_in_use, st_table::keys_in_use_for_query, LEX_STRING::length, LOCK_open, st_table::maybe_null, st_table::next, st_table::null_row, open_unireg_entry(), st_table::s, safe_mutex_assert_owner, st_table::status, STATUS_NO_RECORD, LEX_STRING::str, st_table_list::table, st_table_share::table_cache_key, st_table_list::table_name, st_table::tablenr, TRUE, st_table::used_fields, st_table::used_keys, and st_table_share::version.

Referenced by mysql_create_or_drop_trigger(), prepare_for_repair(), and prepare_for_restore().

{
  TABLE *table= table_list->table;
  TABLE_SHARE *share;
  char *table_name= table_list->table_name;
  TABLE orig_table;
  DBUG_ENTER("reopen_name_locked_table");

  safe_mutex_assert_owner(&LOCK_open);

  if (thd->killed || !table)
    DBUG_RETURN(TRUE);

  orig_table= *table;

  if (open_unireg_entry(thd, table, table_list, table_name,
                        table->s->table_cache_key.str,
                        table->s->table_cache_key.length, thd->mem_root, 0))
  {
    intern_close_table(table);
    /*
      If there was an error during opening of table (for example if it
      does not exist) '*table' object can be wiped out. To be able
      properly release name-lock in this case we should restore this
      object to its original state.
    */
    *table= orig_table;
    DBUG_RETURN(TRUE);
  }

  share= table->s;
  share->version=0;
  share->flush_version=0;
  table->in_use = thd;
  check_unused();
  table->next = thd->open_tables;
  thd->open_tables = table;
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
  table->null_row= table->maybe_null= table->force_index= 0;
  table->status=STATUS_NO_RECORD;
  table->keys_in_use_for_query= share->keys_in_use;
  table->used_keys= share->keys_for_keyread;
  DBUG_RETURN(FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool reopen_table

(

TABLE *

table

)

[static]

Definition at line 2143 of file sql_base.cc.

References st_table::alias, st_table_list::belong_to_view, broadcast_refresh(), handler::change_table_ptr(), closefrm(), st_table::const_table, st_table_share::db, st_table_list::db, st_table::db_stat, DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, st_table::default_column_bitmaps(), error, st_key_part_info::field, st_table::field, st_table::file, st_table::grant, st_table::in_use, st_filesort_info::io_cache, key, st_table::key_info, st_key::key_part, st_table_share::keys, st_table_share::keys_for_keyread, st_table_share::keys_in_use, st_table::keys_in_use_for_query, LEX_STRING::length, st_reginfo::lock_type, st_table::maybe_null, st_table::next, st_table_list::next_local, st_table::null_row, open_unireg_entry(), st_table::prev, st_table_share::ref_count, st_table::reginfo, st_table::s, Table_triggers_list::set_table(), st_table::sort, sql_print_error(), st_table::status, LEX_STRING::str, Field::table, st_table_list::table, st_table_share::table_cache_key, st_table_share::table_map_id, st_table_share::table_name, st_table_list::table_name, st_table::tablenr, st_table::triggers, st_key::usable_key_parts, st_table::used_fields, st_table::used_keys, VOID, and wait_for_locked_table_names().

Referenced by reopen_tables().

{
  TABLE tmp;
  bool error= 1;
  Field **field;
  uint key,part;
  TABLE_LIST table_list;
  THD *thd= table->in_use;
  DBUG_ENTER("reopen_table");

  DBUG_ASSERT(table->s->ref_count == 0);
  DBUG_ASSERT(!table->sort.io_cache);

#ifdef EXTRA_DEBUG
  if (table->db_stat)
    sql_print_error("Table %s had a open data handler in reopen_table",
                    table->alias);
#endif
  table_list.db=         table->s->db.str;
  table_list.table_name= table->s->table_name.str;
  table_list.table=      table;
  table_list.belong_to_view= 0;
  table_list.next_local= 0;

  if (wait_for_locked_table_names(thd, &table_list))
    DBUG_RETURN(1);                             // Thread was killed

  if (open_unireg_entry(thd, &tmp, &table_list,
                        table->alias,
                        table->s->table_cache_key.str,
                        table->s->table_cache_key.length,
                        thd->mem_root, 0))
    goto end;

  /* This list copies variables set by open_table */
  tmp.tablenr=          table->tablenr;
  tmp.used_fields=      table->used_fields;
  tmp.const_table=      table->const_table;
  tmp.null_row=         table->null_row;
  tmp.maybe_null=       table->maybe_null;
  tmp.status=           table->status;
  tmp.keys_in_use_for_query= tmp.s->keys_in_use;
  tmp.used_keys=        tmp.s->keys_for_keyread;

  tmp.s->table_map_id=  table->s->table_map_id;

  /* Get state */
  tmp.in_use=           thd;
  tmp.reginfo.lock_type=table->reginfo.lock_type;
  tmp.grant=            table->grant;

  /* Replace table in open list */
  tmp.next=             table->next;
  tmp.prev=             table->prev;

  delete table->triggers;
  if (table->file)
    VOID(closefrm(table, 1));           // close file, free everything

  *table= tmp;
  table->default_column_bitmaps();
  table->file->change_table_ptr(table, table->s);

  DBUG_ASSERT(table->alias != 0);
  for (field=table->field ; *field ; field++)
  {
    (*field)->table= (*field)->orig_table= table;
    (*field)->table_name= &table->alias;
  }
  for (key=0 ; key < table->s->keys ; key++)
  {
    for (part=0 ; part < table->key_info[key].usable_key_parts ; part++)
      table->key_info[key].key_part[part].field->table= table;
  }
  if (table->triggers)
    table->triggers->set_table(table);

  broadcast_refresh();
  error=0;

 end:
  DBUG_RETURN(error);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool reopen_tables	(	THD *	thd,
		bool	get_locks,
		bool	in_refresh
	)

Definition at line 2257 of file sql_base.cc.

References st_table::alias, broadcast_refresh(), st_table::db_stat, DBUG_ENTER, DBUG_RETURN, ER_CANT_REOPEN_TABLE, error, hash_delete(), lock, LOCK_open, st_table::locked_by_flush, my_afree, my_alloca, my_error(), MYF, mysql_lock_merge(), mysql_lock_tables(), st_table::next, open_cache, reopen_table(), st_table::s, safe_mutex_assert_owner, st_table_share::version, and VOID.

Referenced by close_cached_tables(), mysql_multi_update_prepare(), and wait_for_tables().

{
  TABLE *table,*next,**prev;
  TABLE **tables,**tables_ptr;                  // For locks
  bool error=0, not_used;
  DBUG_ENTER("reopen_tables");

  if (!thd->open_tables)
    DBUG_RETURN(0);

  safe_mutex_assert_owner(&LOCK_open);
  if (get_locks)
  {
    /* The ptr is checked later */
    uint opens=0;
    for (table= thd->open_tables; table ; table=table->next)
      opens++;
    tables= (TABLE**) my_alloca(sizeof(TABLE*)*opens);
  }
  else
    tables= &thd->open_tables;
  tables_ptr =tables;

  prev= &thd->open_tables;
  for (table=thd->open_tables; table ; table=next)
  {
    uint db_stat=table->db_stat;
    next=table->next;
    if (!tables || (!db_stat && reopen_table(table)))
    {
      my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
      VOID(hash_delete(&open_cache,(byte*) table));
      error=1;
    }
    else
    {
      *prev= table;
      prev= &table->next;
      if (get_locks && !db_stat)
        *tables_ptr++= table;                   // need new lock on this
      if (in_refresh)
      {
        table->s->version=0;
        table->locked_by_flush=0;
      }
    }
  }
  if (tables != tables_ptr)                     // Should we get back old locks
  {
    MYSQL_LOCK *lock;
    /* We should always get these locks */
    thd->some_tables_deleted=0;
    if ((lock= mysql_lock_tables(thd, tables, (uint) (tables_ptr - tables),
                                 0, &not_used)))
    {
      thd->locked_tables=mysql_lock_merge(thd->locked_tables,lock);
    }
    else
      error=1;
  }
  if (get_locks && tables)
  {
    my_afree((gptr) tables);
  }
  broadcast_refresh();
  *prev=0;
  DBUG_RETURN(error);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool rm_temporary_table	(	handlerton *	base,
		char *	path
	)

Definition at line 3552 of file sql_base.cc.

References current_thd, DBUG_ENTER, DBUG_RETURN, handler::delete_table(), error, get_new_handler(), my_delete(), my_errno, MYF, reg_ext, sql_print_warning(), strend(), and strmov().

Referenced by close_temporary(), mysql_create_like_table(), mysql_create_table_internal(), and mysql_truncate().

{
  bool error=0;
  handler *file;
  char *ext;
  DBUG_ENTER("rm_temporary_table");

  strmov(ext= strend(path), reg_ext);
  if (my_delete(path,MYF(0)))
    error=1; /* purecov: inspected */
  *ext= 0;                              // remove extension
  file= get_new_handler((TABLE_SHARE*) 0, current_thd->mem_root, base);
  if (file && file->delete_table(path))
  {
    error=1;
    sql_print_warning("Could not remove temporary table: '%s', error: %d",
                      path, my_errno);
  }
  delete file;
  DBUG_RETURN(error);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool set_new_item_local_context	(	THD *	thd,
		Item_ident *	item,
		TABLE_LIST *	table_ref
	)			[static]

Definition at line 4573 of file sql_base.cc.

References Item_ident::context, FALSE, Name_resolution_context::first_name_resolution_table, Name_resolution_context::init(), Name_resolution_context::last_name_resolution_table, and TRUE.

Referenced by mark_common_columns().

{
  Name_resolution_context *context;
  if (!(context= new (thd->mem_root) Name_resolution_context))
    return TRUE;
  context->init();
  context->first_name_resolution_table=
    context->last_name_resolution_table= table_ref;
  item->context= context;
  return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int setup_conds	(	THD *	thd,
		TABLE_LIST *	tables,
		TABLE_LIST *	leaves,
		COND **	conds
	)

Definition at line 5768 of file sql_base.cc.

References backup, st_table_list::check_option, DBUG_ENTER, DBUG_PRINT, st_table_list::effective_with_check, st_table_list::embedding, FALSE, MARK_COLUMNS_READ, st_table_list::next_leaf, st_table_list::next_local, NULL, st_table_list::prepare_check_option(), st_table_list::prepare_where(), st_table_list::top_table(), and st_table_list::where.

Referenced by mysql_prepare_delete(), mysql_prepare_update(), and setup_without_group().

{
  SELECT_LEX *select_lex= thd->lex->current_select;
  Query_arena *arena= thd->stmt_arena, backup;
  TABLE_LIST *table= NULL;      // For HP compilers
  /*
    it_is_update set to TRUE when tables of primary SELECT_LEX (SELECT_LEX
    which belong to LEX, i.e. most up SELECT) will be updated by
    INSERT/UPDATE/LOAD
    NOTE: using this condition helps to prevent call of prepare_check_option()
    from subquery of VIEW, because tables of subquery belongs to VIEW
    (see condition before prepare_check_option() call)
  */
  bool it_is_update= (select_lex == &thd->lex->select_lex) &&
    thd->lex->which_check_option_applicable();
  DBUG_ENTER("setup_conds");

  if (select_lex->conds_processed_with_permanent_arena ||
      arena->is_conventional())
    arena= 0;                                   // For easier test

  thd->mark_used_columns= MARK_COLUMNS_READ;
  DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
  select_lex->cond_count= 0;

  for (table= tables; table; table= table->next_local)
  {
    if (table->prepare_where(thd, conds, FALSE))
      goto err_no_arena;
  }

  if (*conds)
  {
    thd->where="where clause";
    if (!(*conds)->fixed && (*conds)->fix_fields(thd, conds) ||
        (*conds)->check_cols(1))
      goto err_no_arena;
  }

  /*
    Apply fix_fields() to all ON clauses at all levels of nesting,
    including the ones inside view definitions.
  */
  for (table= leaves; table; table= table->next_leaf)
  {
    TABLE_LIST *embedded; /* The table at the current level of nesting. */
    TABLE_LIST *embedding= table; /* The parent nested table reference. */
    do
    {
      embedded= embedding;
      if (embedded->on_expr)
      {
        /* Make a join an a expression */
        thd->where="on clause";
        if (!embedded->on_expr->fixed &&
            embedded->on_expr->fix_fields(thd, &embedded->on_expr) ||
            embedded->on_expr->check_cols(1))
          goto err_no_arena;
        select_lex->cond_count++;
      }
      embedding= embedded->embedding;
    }
    while (embedding &&
           embedding->nested_join->join_list.head() == embedded);

    /* process CHECK OPTION */
    if (it_is_update)
    {
      TABLE_LIST *view= table->top_table();
      if (view->effective_with_check)
      {
        if (view->prepare_check_option(thd))
          goto err_no_arena;
        thd->change_item_tree(&table->check_option, view->check_option);
      }
    }
  }

  if (!thd->stmt_arena->is_conventional())
  {
    /*
      We are in prepared statement preparation code => we should store
      WHERE clause changing for next executions.

      We do this ON -> WHERE transformation only once per PS/SP statement.
    */
    select_lex->where= *conds;
    select_lex->conds_processed_with_permanent_arena= 1;
  }
  DBUG_RETURN(test(thd->net.report_error));

err_no_arena:
  DBUG_RETURN(1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool setup_fields	(	THD *	thd,
		Item **	ref_pointer_array,
		List< Item > &	fields,
		enum_mark_columns	mark_used_columns,
		List< Item > *	sum_func_list,
		bool	allow_sum_func
	)

Definition at line 5254 of file sql_base.cc.

References bzero, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, base_list::elements, List_iterator< T >::ref(), reg2, Item::SUM_FUNC_ITEM, test, and TRUE.

Referenced by check_insert_fields(), check_update_fields(), mysql_do(), mysql_insert(), mysql_load(), mysql_prepare_insert(), mysql_test_do_fields(), mysql_test_insert(), and JOIN::prepare().

{
  reg2 Item *item;
  enum_mark_columns save_mark_used_columns= thd->mark_used_columns;
  nesting_map save_allow_sum_func= thd->lex->allow_sum_func;
  List_iterator<Item> it(fields);
  DBUG_ENTER("setup_fields");

  thd->mark_used_columns= mark_used_columns;
  DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
  if (allow_sum_func)
    thd->lex->allow_sum_func|= 1 << thd->lex->current_select->nest_level;
  thd->where= THD::DEFAULT_WHERE;

  /*
    To prevent fail on forward lookup we fill it with zerows,
    then if we got pointer on zero after find_item_in_list we will know
    that it is forward lookup.

    There is other way to solve problem: fill array with pointers to list,
    but it will be slower.

    TODO: remove it when (if) we made one list for allfields and
    ref_pointer_array
  */
  if (ref_pointer_array)
    bzero(ref_pointer_array, sizeof(Item *) * fields.elements);

  Item **ref= ref_pointer_array;
  while ((item= it++))
  {
    if (!item->fixed && item->fix_fields(thd, it.ref()) ||
        (item= *(it.ref()))->check_cols(1))
    {
      thd->lex->allow_sum_func= save_allow_sum_func;
      thd->mark_used_columns= save_mark_used_columns;
      DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
      DBUG_RETURN(TRUE); /* purecov: inspected */
    }
    if (ref)
      *(ref++)= item;
    if (item->with_sum_func && item->type() != Item::SUM_FUNC_ITEM &&
        sum_func_list)
      item->split_sum_func(thd, ref_pointer_array, *sum_func_list);
    thd->used_tables|= item->used_tables();
  }
  thd->lex->allow_sum_func= save_allow_sum_func;
  thd->mark_used_columns= save_mark_used_columns;
  DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
  DBUG_RETURN(test(thd->net.report_error));
}

Here is the call graph for this function:

Here is the caller graph for this function:

int setup_ftfuncs

(

SELECT_LEX *

select_lex

)

Definition at line 6259 of file sql_base.cc.

References Item_func_match::eq(), Item_func_match::fix_index(), and List_iterator< T >::rewind().

Referenced by mysql_prepare_delete(), mysql_prepare_update(), and JOIN::prepare().

{
  List_iterator<Item_func_match> li(*(select_lex->ftfunc_list)),
                                 lj(*(select_lex->ftfunc_list));
  Item_func_match *ftf, *ftf2;

  while ((ftf=li++))
  {
    if (ftf->fix_index())
      return 1;
    lj.rewind();
    while ((ftf2=lj++) != ftf)
    {
      if (ftf->eq(ftf2,1) && !ftf2->master)
        ftf2->master=ftf;
    }
  }

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool setup_natural_join_row_types	(	THD *	thd,
		List< TABLE_LIST > *	from_clause,
		Name_resolution_context *	context
	)			[static]

Definition at line 5125 of file sql_base.cc.

References base_list::elements, FALSE, st_table_list::first_leaf_for_name_resolution(), st_table_list::next_name_resolution_table, NULL, Name_resolution_context::select_lex, store_top_level_join_columns(), and TRUE.

{
  thd->where= "from clause";
  if (from_clause->elements == 0)
    return FALSE; /* We come here in the case of UNIONs. */

  List_iterator_fast<TABLE_LIST> table_ref_it(*from_clause);
  TABLE_LIST *table_ref; /* Current table reference. */
  /* Table reference to the left of the current. */
  TABLE_LIST *left_neighbor;
  /* Table reference to the right of the current. */
  TABLE_LIST *right_neighbor= NULL;

  /* Note that tables in the list are in reversed order */
  for (left_neighbor= table_ref_it++; left_neighbor ; )
  {
    table_ref= left_neighbor;
    left_neighbor= table_ref_it++;
    /* For stored procedures do not redo work if already done. */
    if (context->select_lex->first_execution)
    {
      if (store_top_level_join_columns(thd, table_ref,
                                       left_neighbor, right_neighbor))
        return TRUE;
      if (left_neighbor)
      {
        TABLE_LIST *first_leaf_on_the_right;
        first_leaf_on_the_right= table_ref->first_leaf_for_name_resolution();
        left_neighbor->next_name_resolution_table= first_leaf_on_the_right;
      }
    }
    right_neighbor= table_ref;
  }

  /*
    Store the top-most, left-most NATURAL/USING join, so that we start
    the search from that one instead of context->table_list. At this point
    right_neighbor points to the left-most top-level table reference in the
    FROM clause.
  */
  DBUG_ASSERT(right_neighbor);
  context->first_name_resolution_table=
    right_neighbor->first_leaf_for_name_resolution();

  return FALSE;
}

Here is the call graph for this function:

bool setup_tables	(	THD *	thd,
		Name_resolution_context *	context,
		List< TABLE_LIST > *	from_clause,
		TABLE_LIST *	tables,
		TABLE_LIST **	leaves,
		bool	select_insert
	)

Definition at line 5367 of file sql_base.cc.

References backup, DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, st_table_list::effective_algorithm, ER_TOO_MANY_TABLES, Name_resolution_context::first_name_resolution_table, get_key_map_from_key_list(), st_table_list::ignore_index, make_leaves_list(), map, MAX_TABLES, st_table_list::merge_underlying_list, my_error(), MYF, st_table_list::next_leaf, st_table_list::next_local, st_table::pos_in_table_list, st_table_list::setup_underlying(), st_table_list::table, Name_resolution_context::table_list, st_table_list::top_table(), st_table_list::use_index, st_table_list::view, and VIEW_ALGORITHM_MERGE.

Referenced by db_show_routine_status(), mysqld_help(), and setup_tables_and_check_access().

{
  uint tablenr= 0;
  DBUG_ENTER("setup_tables");

  context->table_list= context->first_name_resolution_table= tables;

  /*
    this is used for INSERT ... SELECT.
    For select we setup tables except first (and its underlying tables)
  */
  TABLE_LIST *first_select_table= (select_insert ?
                                   tables->next_local:
                                   0);
  if (!(*leaves))
    make_leaves_list(leaves, tables);

  TABLE_LIST *table_list;
  for (table_list= *leaves;
       table_list;
       table_list= table_list->next_leaf, tablenr++)
  {
    TABLE *table= table_list->table;
    table->pos_in_table_list= table_list;
    if (first_select_table &&
        table_list->top_table() == first_select_table)
    {
      /* new counting for SELECT of INSERT ... SELECT command */
      first_select_table= 0;
      tablenr= 0;
    }
    setup_table_map(table, table_list, tablenr);
    table->used_keys= table->s->keys_for_keyread;
    table->merge_keys.clear_all();
    if (table_list->use_index)
    {
      key_map map;
      get_key_map_from_key_list(&map, table, table_list->use_index);
      if (map.is_set_all())
        DBUG_RETURN(1);
      table->keys_in_use_for_query=map;
    }
    if (table_list->ignore_index)
    {
      key_map map;
      get_key_map_from_key_list(&map, table, table_list->ignore_index);
      if (map.is_set_all())
        DBUG_RETURN(1);
      table->keys_in_use_for_query.subtract(map);
    }
    table->used_keys.intersect(table->keys_in_use_for_query);
  }
  if (tablenr > MAX_TABLES)
  {
    my_error(ER_TOO_MANY_TABLES,MYF(0),MAX_TABLES);
    DBUG_RETURN(1);
  }
  for (table_list= tables;
       table_list;
       table_list= table_list->next_local)
  {
    if (table_list->merge_underlying_list)
    {
      DBUG_ASSERT(table_list->view &&
                  table_list->effective_algorithm == VIEW_ALGORITHM_MERGE);
      Query_arena *arena= thd->stmt_arena, backup;
      bool res;
      if (arena->is_conventional())
        arena= 0;                                   // For easier test
      else
        thd->set_n_backup_active_arena(arena, &backup);
      res= table_list->setup_underlying(thd);
      if (arena)
        thd->restore_active_arena(arena, &backup);
      if (res)
        DBUG_RETURN(1);
    }
  }

  /* Precompute and store the row types of NATURAL/USING joins. */
  if (setup_natural_join_row_types(thd, from_clause, context))
    DBUG_RETURN(1);

  DBUG_RETURN(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool setup_tables_and_check_access	(	THD *	thd,
		Name_resolution_context *	context,
		List< TABLE_LIST > *	from_clause,
		TABLE_LIST *	tables,
		TABLE_LIST **	leaves,
		bool	select_insert,
		ulong	want_access
	)

Definition at line 5479 of file sql_base.cc.

References st_table_list::belong_to_view, check_single_table_access(), FALSE, st_table_list::hide_view_error(), st_table_list::next_leaf, NULL, setup_tables(), and TRUE.

Referenced by mysql_load(), mysql_multi_delete_prepare(), mysql_multi_update_prepare(), mysql_prepare_delete(), mysql_prepare_insert_check_table(), mysql_prepare_update(), and JOIN::prepare().

{
  TABLE_LIST *leaves_tmp= NULL;

  if (setup_tables(thd, context, from_clause, tables,
                   &leaves_tmp, select_insert))
    return TRUE;

  *leaves= leaves_tmp;

  for (; leaves_tmp; leaves_tmp= leaves_tmp->next_leaf)
  {
    if (leaves_tmp->belong_to_view && 
        check_single_table_access(thd, want_access,  leaves_tmp))
    {
      tables->hide_view_error(thd);
      return TRUE;
    }
  }
  return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int setup_wild	(	THD *	thd,
		TABLE_LIST *	tables,
		List< Item > &	fields,
		List< Item > *	sum_func_list,
		uint	wild_num
	)

Definition at line 5179 of file sql_base.cc.

References backup, DBUG_ENTER, DBUG_RETURN, base_list::elements, Item_subselect::EXISTS_SUBS, Item::FIELD_ITEM, insert_fields(), List_iterator< T >::replace(), Item_subselect::substype(), and Item::type().

Referenced by JOIN::prepare().

{
  if (!wild_num)
    return(0);

  Item *item;
  List_iterator<Item> it(fields);
  Query_arena *arena, backup;
  DBUG_ENTER("setup_wild");

  /*
    Don't use arena if we are not in prepared statements or stored procedures
    For PS/SP we have to use arena to remember the changes
  */
  arena= thd->activate_stmt_arena_if_needed(&backup);

  while (wild_num && (item= it++))
  {
    if (item->type() == Item::FIELD_ITEM &&
        ((Item_field*) item)->field_name &&
        ((Item_field*) item)->field_name[0] == '*' &&
        !((Item_field*) item)->field)
    {
      uint elem= fields.elements;
      bool any_privileges= ((Item_field *) item)->any_privileges;
      Item_subselect *subsel= thd->lex->current_select->master_unit()->item;
      if (subsel &&
          subsel->substype() == Item_subselect::EXISTS_SUBS)
      {
        /*
          It is EXISTS(SELECT * ...) and we can replace * by any constant.

          Item_int do not need fix_fields() because it is basic constant.
        */
        it.replace(new Item_int("Not_used", (longlong) 1, 21));
      }
      else if (insert_fields(thd, ((Item_field*) item)->context,
                             ((Item_field*) item)->db_name,
                             ((Item_field*) item)->table_name, &it,
                             any_privileges))
      {
        if (arena)
          thd->restore_active_arena(arena, &backup);
        DBUG_RETURN(-1);
      }
      if (sum_func_list)
      {
        /*
          sum_func_list is a list that has the fields list as a tail.
          Because of this we have to update the element count also for this
          list after expanding the '*' entry.
        */
        sum_func_list->elements+= fields.elements - elem;
      }
      wild_num--;
    }
  }
  if (arena)
  {
    /* make * substituting permanent */
    SELECT_LEX *select_lex= thd->lex->current_select;
    select_lex->with_wild= 0;
    select_lex->item_list= fields;

    thd->restore_active_arena(arena, &backup);
  }
  DBUG_RETURN(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int simple_open_n_lock_tables	(	THD *	thd,
		TABLE_LIST *	tables
	)

Definition at line 3152 of file sql_base.cc.

References close_tables_for_reopen(), DBUG_ENTER, DBUG_RETURN, lock_tables, and open_tables().

Referenced by acl_reload(), Event_scheduler::check_system_tables(), grant_reload(), my_tz_find_with_opening_tz_tables(), my_tz_init(), mysql_execute_command(), mysql_grant(), mysql_routine_grant(), mysql_table_grant(), Events::open_event_table(), open_grant_tables(), Log_to_csv_event_handler::open_log_table(), and plugin_load().

{
  uint counter;
  bool need_reopen;
  DBUG_ENTER("simple_open_n_lock_tables");

  for ( ; ; ) 
  {
    if (open_tables(thd, &tables, &counter, 0))
      DBUG_RETURN(-1);
    if (!lock_tables(thd, tables, counter, &need_reopen))
      break;
    if (!need_reopen)
      DBUG_RETURN(-1);
    close_tables_for_reopen(thd, &tables);
  }
  DBUG_RETURN(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool store_natural_using_join_columns	(	THD *	thd,
		TABLE_LIST *	natural_using_join,
		TABLE_LIST *	table_ref_1,
		TABLE_LIST *	table_ref_2,
		List< String > *	using_fields,
		uint	found_using_fields
	)			[static]

Definition at line 4838 of file sql_base.cc.

References backup, String::c_ptr(), List< T >::concat(), current_thd, DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, base_list::elements, Field_iterator_table_ref::end_of_fields(), ER_BAD_FIELD_ERROR, err, FALSE, Field_iterator_table_ref::get_natural_column_ref(), Natural_join_column::is_common, st_table_list::is_join_columns_complete, st_table_list::join_columns, my_error(), my_strcasecmp, MYF, Natural_join_column::name(), Field_iterator_table_ref::next(), List< T >::push_back(), Field_iterator_table_ref::set(), system_charset_info, and TRUE.

Referenced by store_top_level_join_columns().

{
  Field_iterator_table_ref it_1, it_2;
  Natural_join_column *nj_col_1, *nj_col_2;
  Query_arena *arena, backup;
  bool result= TRUE;
  List<Natural_join_column> *non_join_columns;
  DBUG_ENTER("store_natural_using_join_columns");

  DBUG_ASSERT(!natural_using_join->join_columns);

  arena= thd->activate_stmt_arena_if_needed(&backup);

  if (!(non_join_columns= new List<Natural_join_column>) ||
      !(natural_using_join->join_columns= new List<Natural_join_column>))
    goto err;

  /* Append the columns of the first join operand. */
  for (it_1.set(table_ref_1); !it_1.end_of_fields(); it_1.next())
  {
    nj_col_1= it_1.get_natural_column_ref();
    if (nj_col_1->is_common)
    {
      natural_using_join->join_columns->push_back(nj_col_1);
      /* Reset the common columns for the next call to mark_common_columns. */
      nj_col_1->is_common= FALSE;
    }
    else
      non_join_columns->push_back(nj_col_1);
  }

  /*
    Check that all columns in the USING clause are among the common
    columns. If this is not the case, report the first one that was
    not found in an error.
  */
  if (using_fields && found_using_fields < using_fields->elements)
  {
    String *using_field_name;
    List_iterator_fast<String> using_fields_it(*using_fields);
    while ((using_field_name= using_fields_it++))
    {
      const char *using_field_name_ptr= using_field_name->c_ptr();
      List_iterator_fast<Natural_join_column>
        it(*(natural_using_join->join_columns));
      Natural_join_column *common_field;

      for (;;)
      {
        /* If reached the end of fields, and none was found, report error. */
        if (!(common_field= it++))
        {
          my_error(ER_BAD_FIELD_ERROR, MYF(0), using_field_name_ptr,
                   current_thd->where);
          goto err;
        }
        if (!my_strcasecmp(system_charset_info,
                           common_field->name(), using_field_name_ptr))
          break;                                // Found match
      }
    }
  }

  /* Append the non-equi-join columns of the second join operand. */
  for (it_2.set(table_ref_2); !it_2.end_of_fields(); it_2.next())
  {
    nj_col_2= it_2.get_natural_column_ref();
    if (!nj_col_2->is_common)
      non_join_columns->push_back(nj_col_2);
    else
    {
      /* Reset the common columns for the next call to mark_common_columns. */
      nj_col_2->is_common= FALSE;
    }
  }

  if (non_join_columns->elements > 0)
    natural_using_join->join_columns->concat(non_join_columns);
  natural_using_join->is_join_columns_complete= TRUE;

  result= FALSE;

err:
  if (arena)
    thd->restore_active_arena(arena, &backup);
  DBUG_RETURN(result);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool store_top_level_join_columns	(	THD *	thd,
		TABLE_LIST *	table_ref,
		TABLE_LIST *	left_neighbor,
		TABLE_LIST *	right_neighbor
	)			[static]

Definition at line 4962 of file sql_base.cc.

References backup, DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, err, FALSE, st_table_list::first_leaf_for_name_resolution(), st_table_list::is_natural_join, st_nested_join::join_list, JOIN_TYPE_RIGHT, st_table_list::join_using_fields, st_table_list::last_leaf_for_name_resolution(), mark_common_columns(), st_table_list::natural_join, st_table_list::nested_join, st_table_list::next_name_resolution_table, NULL, st_table_list::on_expr, st_table_list::outer_join, store_natural_using_join_columns(), swap_variables, and TRUE.

Referenced by setup_natural_join_row_types().

{
  Query_arena *arena, backup;
  bool result= TRUE;

  DBUG_ENTER("store_top_level_join_columns");

  arena= thd->activate_stmt_arena_if_needed(&backup);

  /* Call the procedure recursively for each nested table reference. */
  if (table_ref->nested_join)
  {
    List_iterator_fast<TABLE_LIST> nested_it(table_ref->nested_join->join_list);
    TABLE_LIST *same_level_left_neighbor= nested_it++;
    TABLE_LIST *same_level_right_neighbor= NULL;
    /* Left/right-most neighbors, possibly at higher levels in the join tree. */
    TABLE_LIST *real_left_neighbor, *real_right_neighbor;

    while (same_level_left_neighbor)
    {
      TABLE_LIST *cur_table_ref= same_level_left_neighbor;
      same_level_left_neighbor= nested_it++;
      /*
        The order of RIGHT JOIN operands is reversed in 'join list' to
        transform it into a LEFT JOIN. However, in this procedure we need
        the join operands in their lexical order, so below we reverse the
        join operands. Notice that this happens only in the first loop,
        and not in the second one, as in the second loop
        same_level_left_neighbor == NULL.
        This is the correct behavior, because the second loop sets
        cur_table_ref reference correctly after the join operands are
        swapped in the first loop.
      */
      if (same_level_left_neighbor &&
          cur_table_ref->outer_join & JOIN_TYPE_RIGHT)
      {
        /* This can happen only for JOIN ... ON. */
        DBUG_ASSERT(table_ref->nested_join->join_list.elements == 2);
        swap_variables(TABLE_LIST*, same_level_left_neighbor, cur_table_ref);
      }

      /*
        Pick the parent's left and right neighbors if there are no immediate
        neighbors at the same level.
      */
      real_left_neighbor=  (same_level_left_neighbor) ?
                           same_level_left_neighbor : left_neighbor;
      real_right_neighbor= (same_level_right_neighbor) ?
                           same_level_right_neighbor : right_neighbor;

      if (cur_table_ref->nested_join &&
          store_top_level_join_columns(thd, cur_table_ref,
                                       real_left_neighbor, real_right_neighbor))
        goto err;
      same_level_right_neighbor= cur_table_ref;
    }
  }

  /*
    If this is a NATURAL/USING join, materialize its result columns and
    convert to a JOIN ... ON.
  */
  if (table_ref->is_natural_join)
  {
    DBUG_ASSERT(table_ref->nested_join &&
                table_ref->nested_join->join_list.elements == 2);
    List_iterator_fast<TABLE_LIST> operand_it(table_ref->nested_join->join_list);
    /*
      Notice that the order of join operands depends on whether table_ref
      represents a LEFT or a RIGHT join. In a RIGHT join, the operands are
      in inverted order.
     */
    TABLE_LIST *table_ref_2= operand_it++; /* Second NATURAL join operand.*/
    TABLE_LIST *table_ref_1= operand_it++; /* First NATURAL join operand. */
    List<String> *using_fields= table_ref->join_using_fields;
    uint found_using_fields;

    /*
      The two join operands were interchanged in the parser, change the order
      back for 'mark_common_columns'.
    */
    if (table_ref_2->outer_join & JOIN_TYPE_RIGHT)
      swap_variables(TABLE_LIST*, table_ref_1, table_ref_2);
    if (mark_common_columns(thd, table_ref_1, table_ref_2,
                            using_fields, &found_using_fields))
      goto err;

    /*
      Swap the join operands back, so that we pick the columns of the second
      one as the coalesced columns. In this way the coalesced columns are the
      same as of an equivalent LEFT JOIN.
    */
    if (table_ref_1->outer_join & JOIN_TYPE_RIGHT)
      swap_variables(TABLE_LIST*, table_ref_1, table_ref_2);
    if (store_natural_using_join_columns(thd, table_ref, table_ref_1,
                                         table_ref_2, using_fields,
                                         found_using_fields))
      goto err;

    /*
      Change NATURAL JOIN to JOIN ... ON. We do this for both operands
      because either one of them or the other is the one with the
      natural join flag because RIGHT joins are transformed into LEFT,
      and the two tables may be reordered.
    */
    table_ref_1->natural_join= table_ref_2->natural_join= NULL;

    /* Add a TRUE condition to outer joins that have no common columns. */
    if (table_ref_2->outer_join &&
        !table_ref_1->on_expr && !table_ref_2->on_expr)
      table_ref_2->on_expr= new Item_int((longlong) 1,1);   /* Always true. */

    /* Change this table reference to become a leaf for name resolution. */
    if (left_neighbor)
    {
      TABLE_LIST *last_leaf_on_the_left;
      last_leaf_on_the_left= left_neighbor->last_leaf_for_name_resolution();
      last_leaf_on_the_left->next_name_resolution_table= table_ref;
    }
    if (right_neighbor)
    {
      TABLE_LIST *first_leaf_on_the_right;
      first_leaf_on_the_right= right_neighbor->first_leaf_for_name_resolution();
      table_ref->next_name_resolution_table= first_leaf_on_the_right;
    }
    else
      table_ref->next_name_resolution_table= NULL;
  }
  result= FALSE; /* All is OK.