/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


/* Basic functions needed by many modules */

#include "mysql_priv.h"
#include "sql_select.h"
#include "sp_head.h"
#include "sql_trigger.h"
#include <m_ctype.h>
#include <my_dir.h>
#include <hash.h>
#include <nisam.h>
#ifdef	__WIN__
#include <io.h>
#endif

TABLE *unused_tables;				/* Used by mysql_test */
HASH open_cache;				/* Used by mysql_test */

static int open_unireg_entry(THD *thd, TABLE *entry, const char *db,
			     const char *name, const char *alias,
			     TABLE_LIST *table_list, MEM_ROOT *mem_root);
static void free_cache_entry(TABLE *entry);
static void mysql_rm_tmp_tables(void);
static my_bool open_new_frm(const char *path, const char *alias,
                            const char *db, const char *table_name,
			    uint db_stat, uint prgflag,
			    uint ha_open_flags, TABLE *outparam,
			    TABLE_LIST *table_desc, MEM_ROOT *mem_root);
static void relink_tables_for_multidelete(THD *thd);

extern "C" byte *table_cache_key(const byte *record,uint *length,
				 my_bool not_used __attribute__((unused)))
{
  TABLE *entry=(TABLE*) record;
  *length= entry->s->key_length;
  return (byte*) entry->s->table_cache_key;
}

bool table_cache_init(void)
{
  mysql_rm_tmp_tables();
  return hash_init(&open_cache, &my_charset_bin, table_cache_size+16,
		   0, 0,table_cache_key,
		   (hash_free_key) free_cache_entry, 0) != 0;
}

void table_cache_free(void)
{
  DBUG_ENTER("table_cache_free");
  close_cached_tables((THD*) 0,0,(TABLE_LIST*) 0);
  if (!open_cache.records)			// Safety first
    hash_free(&open_cache);
  DBUG_VOID_RETURN;
}

uint cached_tables(void)
{
  return open_cache.records;
}

#ifdef EXTRA_DEBUG
static void check_unused(void)
{
  uint count=0,idx=0;
  TABLE *cur_link,*start_link;

  if ((start_link=cur_link=unused_tables))
  {
    do
    {
      if (cur_link != cur_link->next->prev || cur_link != cur_link->prev->next)
      {
	DBUG_PRINT("error",("Unused_links aren't linked properly")); /* purecov: inspected */
	return; /* purecov: inspected */
      }
    } while (count++ < open_cache.records &&
	     (cur_link=cur_link->next) != start_link);
    if (cur_link != start_link)
    {
      DBUG_PRINT("error",("Unused_links aren't connected")); /* purecov: inspected */
    }
  }
  for (idx=0 ; idx < open_cache.records ; idx++)
  {
    TABLE *entry=(TABLE*) hash_element(&open_cache,idx);
    if (!entry->in_use)
      count--;
  }
  if (count != 0)
  {
    DBUG_PRINT("error",("Unused_links doesn't match open_cache: diff: %d", /* purecov: inspected */
			count)); /* purecov: inspected */
  }
}
#else
#define check_unused()
#endif

/*
  Create a list for all open tables matching SQL expression

  SYNOPSIS
    list_open_tables()
    thd			Thread THD
    wild		SQL like expression

  NOTES
    One gets only a list of tables for which one has any kind of privilege.
    db and table names are allocated in result struct, so one doesn't need
    a lock on LOCK_open when traversing the return list.

  RETURN VALUES
    NULL	Error (Probably OOM)
    #		Pointer to list of names of open tables.
*/

OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *wild)
{
  int result = 0;
  OPEN_TABLE_LIST **start_list, *open_list;
  TABLE_LIST table_list;
  char name[NAME_LEN*2];
  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;

    DBUG_ASSERT(share->table_name);
    if ((!share->table_name))			// To be removed
      continue;					// Shouldn't happen
    if (wild)
    {
      strxmov(name,share->table_cache_key,".",share->table_name,NullS);
      if (wild_compare(name,wild,0))
	continue;
    }

    /* Check if user has SELECT privilege for any column in the table */
    table_list.db=        (char*) share->db;
    table_list.table_name= (char*) share->table_name;
    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) &&
	  !strcmp(table->db,entry->s->db))
      {
	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->key_length)))
    {
      open_list=0;				// Out of memory
      break;
    }
    strmov((*start_list)->table=
	   strmov(((*start_list)->db= (char*) ((*start_list)+1)),
		  entry->s->db)+1,
	   entry->s->table_name);
    (*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);
}

/*****************************************************************************
 *	 Functions to free open table cache
 ****************************************************************************/


void intern_close_table(TABLE *table)
{						// Free all structures
  free_io_cache(table);
  delete table->triggers;
  if (table->file)
    VOID(closefrm(table));			// close file
}

/*
  Remove table from the open table cache

  SYNOPSIS
    free_cache_entry()
    table		Table to remove

  NOTE
    We need to have a lock on LOCK_open when calling this
*/

static void free_cache_entry(TABLE *table)
{
  DBUG_ENTER("free_cache_entry");
  safe_mutex_assert_owner(&LOCK_open);

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

/* Free resources allocated by filesort() and read_record() */

void free_io_cache(TABLE *table)
{
  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;
}

/*
  Close all tables which aren't in use by any thread

  THD can be NULL, but then if_wait_for_refresh must be FALSE
  and tables must be NULL.
*/

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

  VOID(pthread_mutex_lock(&LOCK_open));
  if (!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
    }
    refresh_version++;				// Force close of open tables
  }
  else
  {
    bool found=0;
    for (TABLE_LIST *table= tables; table; table= table->next_local)
    {
      if (remove_table_from_cache(thd, table->db, table->table_name, 1))
	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);
    bool found=1;
    /* Wait until all threads has closed all the tables we had locked */
    DBUG_PRINT("info",
	       ("Waiting for others 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->version) < refresh_version && table->db_stat)
	{
	  found=1;
	  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;
  }
  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);
}


/*
  Close all tables used by thread

  SYNOPSIS
    close_thread_tables()
    thd			Thread handler
    lock_in_use		Set to 1 (0 = default) if caller has a lock on
			LOCK_open
    skip_derived	Set to 1 (0 = default) if we should not free derived
			tables.

  IMPLEMENTATION
    Unlocks tables and frees derived tables.
    Put all normal tables used by thread in free list.
*/

void close_thread_tables(THD *thd, bool lock_in_use, bool skip_derived, 
                         TABLE *stopper)
{
  bool found_old_table;
  DBUG_ENTER("close_thread_tables");

  if (thd->derived_tables && !skip_derived)
  {
    TABLE *table, *next;
    /*
      Close all derived tables generated from questions 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 (thd->locked_tables)
  {
    ha_commit_stmt(thd);			// If select statement
    DBUG_VOID_RETURN;				// LOCK TABLES in use
  }

  if (thd->lock)
  {
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;
  }
  /* VOID(pthread_sigmask(SIG_SETMASK,&thd->block_signals,NULL)); */
  if (!lock_in_use)
    VOID(pthread_mutex_lock(&LOCK_open));
  safe_mutex_assert_owner(&LOCK_open);

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

 found_old_table= 0;
  while (thd->open_tables != stopper)
    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 */
    VOID(pthread_cond_broadcast(&COND_refresh));
  }
  if (!lock_in_use)
    VOID(pthread_mutex_unlock(&LOCK_open));
  /*  VOID(pthread_sigmask(SIG_SETMASK,&thd->signals,NULL)); */
  DBUG_VOID_RETURN;
}

/* move one table to free list */

bool close_thread_table(THD *thd, TABLE **table_ptr)
{
  DBUG_ENTER("close_thread_table");

  bool found_old_table= 0;
  TABLE *table= *table_ptr;
  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);
    }
    else
    {
      // Free memory and reset for next loop
      table->file->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);
}

	/* Close and delete temporary tables */

void close_temporary(TABLE *table,bool delete_table)
{
  DBUG_ENTER("close_temporary");
  char path[FN_REFLEN];
  db_type table_type=table->s->db_type;
  strmov(path,table->s->path);
  free_io_cache(table);
  closefrm(table);
  my_free((char*) table,MYF(0));
  if (delete_table)
    rm_temporary_table(table_type, path);
  DBUG_VOID_RETURN;
}


void close_temporary_tables(THD *thd)
{
  TABLE *table,*next;
  char *query, *name_in_query, *end;
  uint greatest_key_length= 0;

  if (!thd->temporary_tables)
    return;
  
  /*
    We write a DROP TEMPORARY TABLE for each temp table left, so that our
    replication slave can clean them up. Not one multi-table DROP TABLE binlog
    event: this would cause problems if slave uses --replicate-*-table.
  */
  LINT_INIT(end);

  /* We'll re-use always same buffer so make it big enough for longest name */
  for (table=thd->temporary_tables ; table ; table=table->next)
    greatest_key_length= max(greatest_key_length, table->s->key_length);

  if ((query = alloc_root(thd->mem_root, greatest_key_length+50)))
    // Better add "if exists", in case a RESET MASTER has been done
    name_in_query= strmov(query, "DROP /*!40005 TEMPORARY */ TABLE IF EXISTS `");

  for (table=thd->temporary_tables ; table ; table=next)
  {
    /*
      In we are OOM for 'query' this is not fatal. We skip temporary tables
      not created directly by the user.
    */
    if (query && mysql_bin_log.is_open() && (table->s->table_name[0] != '#'))
    {
      /*
        Here we assume table_cache_key always starts
        with \0 terminated db name
      */
      end = strxmov(name_in_query, table->s->db, "`.`",
                    table->s->table_name, "`", NullS);
      Query_log_event qinfo(thd, query, (ulong)(end-query), 0, FALSE);
      /*
        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. And, if thread is
        killed now, it's not clever either.
        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);
    }
    next=table->next;
    close_temporary(table);
  }
  thd->temporary_tables=0;
}


/*
  Find table in list.

  SYNOPSIS
    find_table_in_list()
    table		Pointer to table list
    offset		Offset to which list in table structure to use
    db_name		Data base name
    table_name		Table name

  NOTES:
    This is called by find_table_in_local_list() and
    find_table_in_global_list().

  RETURN VALUES
    NULL	Table not found
    #		Pointer to found table.
*/

TABLE_LIST *find_table_in_list(TABLE_LIST *table,
                               uint offset,
                               const char *db_name,
                               const char *table_name)
{
  if (lower_case_table_names)
  {
    for (; table; table= *(TABLE_LIST **) ((char*) table + offset))
    {
      if ((table->table == 0 || table->table->s->tmp_table == NO_TMP_TABLE) &&
          ((!strcmp(table->db, db_name) &&
            !strcmp(table->table_name, table_name)) ||
           (table->view &&
            !my_strcasecmp(table_alias_charset,
                           table->db, db_name) &&
            !my_strcasecmp(table_alias_charset,
                           table->table->alias, table_name))))
        break;
    }
  }
  else
  {
    for (; table; table= *(TABLE_LIST **) ((char*) table + offset))
    {
      if ((table->table == 0 || table->table->s->tmp_table == NO_TMP_TABLE) &&
          ((!strcmp(table->db, db_name) &&
            !strcmp(table->table_name, table_name)) ||
           (table->view &&
            !strcmp(table->table->s->db, db_name) &&
            !strcmp(table->table->alias, table_name))))
        break;
    }
  }
  return table;
}


/*
  Test that table is unique

  SYNOPSIS
    unique_table()
    table       table which should be chaked
    table_list  list of tables

  RETURN
    found duplicate
    0 if table is unique
*/

TABLE_LIST* unique_table(TABLE_LIST *table, TABLE_LIST *table_list)
{
  DBUG_ENTER("unique_table");
  DBUG_PRINT("enter", ("table alias: %s", table->alias));
  TABLE_LIST *res;
  const char *d_name= table->db, *t_name= table->table_name;
  char d_name_buff[MAX_ALIAS_NAME], t_name_buff[MAX_ALIAS_NAME];
  /* temporary table is always unique */
  if (table->table && table->table->s->tmp_table != NO_TMP_TABLE)
    return 0;
  if (table->view)
  {
    /* it is view and table opened */
    if (lower_case_table_names)
    {
      strmov(t_name_buff, table->table->alias);
      my_casedn_str(files_charset_info, t_name_buff);
      t_name= t_name_buff;
      strmov(d_name_buff, table->table->s->db);
      my_casedn_str(files_charset_info, d_name_buff);
      d_name= d_name_buff;
    }
    else
    {
      d_name= table->table->s->db;
      t_name= table->table->alias;
    }
  }

  DBUG_PRINT("info", ("real table: %s.%s", d_name, t_name));
  for(;;)
  {
    if (!(res= find_table_in_global_list(table_list, d_name, t_name)) ||
        !res->table || res->table != table->table)
      break;
    /* if we found entry of this table try again. */
    table_list= res->next_global;
    DBUG_PRINT("info", ("found same copy of table"));
  }
  DBUG_RETURN(res);
}


TABLE **find_temporary_table(THD *thd, const char *db, const char *table_name)
{
  char	key[MAX_DBKEY_LENGTH];
  uint	key_length= (uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
  TABLE *table,**prev;

  int4store(key+key_length,thd->server_id);
  key_length += 4;
  int4store(key+key_length,thd->variables.pseudo_thread_id);
  key_length += 4;

  prev= &thd->temporary_tables;
  for (table=thd->temporary_tables ; table ; table=table->next)
  {
    if (table->s->key_length == key_length &&
	!memcmp(table->s->table_cache_key,key,key_length))
      return prev;
    prev= &table->next;
  }
  return 0;					// Not a temporary table
}

bool close_temporary_table(THD *thd, const char *db, const char *table_name)
{
  TABLE *table,**prev;

  if (!(prev=find_temporary_table(thd,db,table_name)))
    return 1;
  table= *prev;
  *prev= table->next;
  close_temporary(table);
  if (thd->slave_thread)
    --slave_open_temp_tables;
  return 0;
}

/*
  Used by ALTER TABLE when the table is a temporary one. It changes something
  only if the ALTER contained a RENAME clause (otherwise, table_name is the old
  name).
  Prepares a table cache key, which is the concatenation of db, table_name and
  thd->slave_proxy_id, separated by '\0'.
*/

bool rename_temporary_table(THD* thd, TABLE *table, const char *db,
			    const char *table_name)
{
  char *key;
  TABLE_SHARE *share= table->s;

  if (!(key=(char*) alloc_root(&table->mem_root,
			       (uint) strlen(db)+
			       (uint) strlen(table_name)+6+4)))
    return 1;				/* purecov: inspected */
  share->key_length= (uint)
    (strmov((char*) (share->table_name= strmov(share->table_cache_key= key,
                                               db)+1),
	    table_name) - share->table_cache_key)+1;
  share->db= share->table_cache_key;
  int4store(key+share->key_length, thd->server_id);
  share->key_length+= 4;
  int4store(key+share->key_length, thd->variables.pseudo_thread_id);
  share->key_length+= 4;
  return 0;
}


	/* move table first in unused links */

static void relink_unused(TABLE *table)
{
  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();
  }
}


/*
  Remove all instances of table from the current open list
  Free all locks on tables that are done with LOCK TABLES
 */

TABLE *unlink_open_table(THD *thd, TABLE *list, TABLE *find)
{
  char key[MAX_DBKEY_LENGTH];
  uint key_length= find->s->key_length;
  TABLE *start=list,**prev,*next;
  prev= &start;

  memcpy(key, find->s->table_cache_key, key_length);
  for (; list ; list=next)
  {
    next=list->next;
    if (list->s->key_length == key_length &&
	!memcmp(list->s->table_cache_key, key, key_length))
    {
      if (thd->locked_tables)
	mysql_lock_remove(thd, thd->locked_tables,list);
      VOID(hash_delete(&open_cache,(byte*) list)); // Close table
    }
    else
    {
      *prev=list;				// put in use list
      prev= &list->next;
    }
  }
  *prev=0;
  // Notify any 'refresh' threads
  pthread_cond_broadcast(&COND_refresh);
  return start;
}


/*
   When we call the following function we must have a lock on
   LOCK_open ; This lock will be unlocked on return.
*/

void wait_for_refresh(THD *thd)
{
  safe_mutex_assert_owner(&LOCK_open);

  /* Wait until the current table is up to date */
  const char *proc_info;
  thd->mysys_var->current_mutex= &LOCK_open;
  thd->mysys_var->current_cond= &COND_refresh;
  proc_info=thd->proc_info;
  thd->proc_info="Waiting for table";
  if (!thd->killed)
    (void) pthread_cond_wait(&COND_refresh,&LOCK_open);

  pthread_mutex_unlock(&LOCK_open);	// Must be unlocked first
  pthread_mutex_lock(&thd->mysys_var->mutex);
  thd->mysys_var->current_mutex= 0;
  thd->mysys_var->current_cond= 0;
  thd->proc_info= proc_info;
  pthread_mutex_unlock(&thd->mysys_var->mutex);
}


TABLE *reopen_name_locked_table(THD* thd, TABLE_LIST* table_list)
{
  DBUG_ENTER("reopen_name_locked_table");
  if (thd->killed)
    DBUG_RETURN(0);
  TABLE *table;
  TABLE_SHARE *share;
  if (!(table = table_list->table))
    DBUG_RETURN(0);

  char* db = thd->db ? thd->db : table_list->db;
  char* table_name = table_list->table_name;
  char	key[MAX_DBKEY_LENGTH];
  uint	key_length;
  key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;

  pthread_mutex_lock(&LOCK_open);
  if (open_unireg_entry(thd, table, db, table_name, table_name, 0,
                        thd->mem_root) ||
      !(table->s->table_cache_key= memdup_root(&table->mem_root, (char*) key,
                                               key_length)))
  {
    delete table->triggers;
    closefrm(table);
    pthread_mutex_unlock(&LOCK_open);
    DBUG_RETURN(0);
  }

  share= table->s;
  share->db= share->table_cache_key;
  share->key_length=key_length;
  share->version=0;
  share->flush_version=0;
  table->in_use = thd;
  check_unused();
  pthread_mutex_unlock(&LOCK_open);
  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(table);
}


/******************************************************************************
** open a table
** Uses a cache of open tables to find a table not in use.
** If refresh is a NULL pointer, then the is no version number checking and
** the table is not put in the thread-open-list
** If the return value is NULL and refresh is set then one must close
** all tables and retry the open
******************************************************************************/


TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
		  bool *refresh)
{
  reg1	TABLE *table;
  char	key[MAX_DBKEY_LENGTH];
  uint	key_length;
  char	*alias= table_list->alias;
  DBUG_ENTER("open_table");

  /* find a unused table in the open table cache */
  if (refresh)
    *refresh=0;
  if (thd->killed)
    DBUG_RETURN(0);
  key_length= (uint) (strmov(strmov(key, table_list->db)+1,
			     table_list->table_name)-key)+1;
  int4store(key + key_length, thd->server_id);
  int4store(key + key_length + 4, thd->variables.pseudo_thread_id);

  if (!table_list->skip_temporary)
  {
    for (table= thd->temporary_tables; table ; table=table->next)
    {
      if (table->s->key_length == key_length + TMP_TABLE_KEY_EXTRA &&
	  !memcmp(table->s->table_cache_key, key,
		  key_length + TMP_TABLE_KEY_EXTRA))
      {
	if (table->query_id == thd->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 (thd->locked_tables)
  {						// Using table locks
    for (table=thd->open_tables; table ; table=table->next)
    {
      if (table->s->key_length == key_length &&
	  !memcmp(table->s->table_cache_key,key,key_length) &&
	  !my_strcasecmp(system_charset_info, table->alias, alias))
      {
	if (table->query_id != thd->query_id)
	  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];
      strxnmov(path, FN_REFLEN, mysql_data_home, "/", table_list->db, "/",
               table_list->table_name, reg_ext, NullS);
      (void) unpack_filename(path, path);
      if (mysql_frm_type(path) == FRMTYPE_VIEW)
      {
        TABLE tab;// will not be used (because it's VIEW) but have to be passed
        table= &tab;
        VOID(pthread_mutex_lock(&LOCK_open));
        if (open_unireg_entry(thd, table, table_list->db,
                              table_list->table_name,
                              alias, table_list, mem_root))
        {
          table->next=table->prev=table;
          free_cache_entry(table);
        }
        else
        {
          DBUG_ASSERT(table_list->view);
          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 && refresh)
  {
    /* Someone did a refresh while thread was opening tables */
    *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);

  for (table=(TABLE*) hash_search(&open_cache,(byte*) key,key_length) ;
       table && table->in_use ;
       table = (TABLE*) hash_next(&open_cache,(byte*) key,key_length))
  {
    if (table->s->version != refresh_version)
    {
      /*
      ** 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_refresh(thd);
      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
  {
    TABLE_SHARE *share;
    /* 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);
    }
    if (open_unireg_entry(thd, table, table_list->db, table_list->table_name,
			  alias, table_list, mem_root) ||
	(!table_list->view && 
	 !(table->s->table_cache_key= memdup_root(&table->mem_root,
                                                  (char*) key,
                                                  key_length))))
    {
      table->next=table->prev=table;
      free_cache_entry(table);
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(NULL);
    }
    if (table_list->view)
    {
      my_free((gptr)table, MYF(0));
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(0); // VIEW
    }
    share= table->s;
    share->db=            share->table_cache_key;
    share->key_length=    key_length;
    share->version=       refresh_version;
    share->flush_version= flush_version;
    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:
  if (thd->lex->need_correct_ident())
    table->alias_name_used= my_strcasecmp(table_alias_charset,
                                          table->s->table_name, 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;
  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
  DBUG_ASSERT(table->key_read == 0);
  DBUG_RETURN(table);
}


TABLE *find_locked_table(THD *thd, const char *db,const char *table_name)
{
  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->key_length == key_length &&
	!memcmp(table->s->table_cache_key,key,key_length))
      return table;
  }
  return(0);
}


/****************************************************************************
** Reopen an table because the definition has changed. The date file for the
** table is already closed.
** Returns 0 if ok.
** If table can't be reopened, the entry is unchanged.
****************************************************************************/

bool reopen_table(TABLE *table,bool locked)
{
  TABLE tmp;
  char *db= table->s->table_cache_key;
  const char *table_name= table->s->table_name;
  bool error= 1;
  Field **field;
  uint key,part;
  DBUG_ENTER("reopen_table");

#ifdef EXTRA_DEBUG
  if (table->db_stat)
    sql_print_error("Table %s had a open data handler in reopen_table",
		    table->alias);
#endif
  if (!locked)
    VOID(pthread_mutex_lock(&LOCK_open));
  safe_mutex_assert_owner(&LOCK_open);

  if (open_unireg_entry(table->in_use, &tmp, db, table_name,
			table->alias, 0, table->in_use->mem_root))
    goto end;
  free_io_cache(table);

  if (!(tmp.s->table_cache_key= memdup_root(&tmp.mem_root,db,
                                            table->s->key_length)))
  {
    delete tmp.triggers;
    closefrm(&tmp);				// End of memory
    goto end;
  }
  tmp.s->db= tmp.s->table_cache_key;

  /* 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.force_index=	tmp.force_index;

  /* Get state */
  tmp.s->key_length=	table->s->key_length;
  tmp.in_use=    	table->in_use;
  tmp.reginfo.lock_type=table->reginfo.lock_type;
  tmp.s->version=	refresh_version;
  tmp.s->tmp_table=	table->s->tmp_table;
  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));		// close file, free everything

  *table= tmp;
  table->s= &table->share_not_to_be_used;
  table->file->change_table_ptr(table);

  DBUG_ASSERT(table->alias);
  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;
  VOID(pthread_cond_broadcast(&COND_refresh));
  error=0;

 end:
  if (!locked)
    VOID(pthread_mutex_unlock(&LOCK_open));
  DBUG_RETURN(error);
}


/*
  Used with ALTER TABLE:
  Close all instanses of table when LOCK TABLES is in used;
  Close first all instances of table and then reopen them
 */

bool close_data_tables(THD *thd,const char *db, const char *table_name)
{
  TABLE *table;
  for (table=thd->open_tables; table ; table=table->next)
  {
    if (!strcmp(table->s->table_name, table_name) &&
	!strcmp(table->s->db, db))
    {
      mysql_lock_remove(thd, thd->locked_tables,table);
      table->file->close();
      table->db_stat=0;
    }
  }
  return 0;					// For the future
}


/*
  Reopen all tables with closed data files
  One should have lock on LOCK_open when calling this
*/

bool reopen_tables(THD *thd,bool get_locks,bool in_refresh)
{
  DBUG_ENTER("reopen_tables");
  safe_mutex_assert_owner(&LOCK_open);

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

  TABLE *table,*next,**prev;
  TABLE **tables,**tables_ptr;			// For locks
  bool error=0;
  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,1)))
    {
      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))))
    {
      thd->locked_tables=mysql_lock_merge(thd->locked_tables,lock);
    }
    else
      error=1;
  }
  if (get_locks && tables)
  {
    my_afree((gptr) tables);
  }
  VOID(pthread_cond_broadcast(&COND_refresh)); // Signal to refresh
  *prev=0;
  DBUG_RETURN(error);
}

/*
  Close handlers for tables in list, but leave the TABLE structure
  intact so that we can re-open these quickly
  abort_locks is set if called from flush_tables.
*/

void close_old_data_files(THD *thd, TABLE *table, bool abort_locks,
			  bool send_refresh)
{
  DBUG_ENTER("close_old_data_files");
  bool found=send_refresh;
  for (; table ; table=table->next)
  {
    if (table->s->version != refresh_version)
    {
      found=1;
      if (!abort_locks)				// If not from flush tables
	table->s->version= refresh_version;	// Let other threads use table
      if (table->db_stat)
      {
	if (abort_locks)
	{
	  mysql_lock_abort(thd,table);		// Close waiting threads
	  mysql_lock_remove(thd, thd->locked_tables,table);
	  table->locked_by_flush=1;		// Will be reopened with locks
	}
	table->file->close();
	table->db_stat=0;
      }
    }
  }
  if (found)
    VOID(pthread_cond_broadcast(&COND_refresh)); // Signal to refresh
  DBUG_VOID_RETURN;
}


/*
  Wait until all threads has closed the tables in the list
  We have also to wait if there is thread that has a lock on this table even
  if the table is closed
*/

bool table_is_used(TABLE *table, bool wait_for_name_lock)
{
  do
  {
    char *key= table->s->table_cache_key;
    uint key_length= table->s->key_length;
    for (TABLE *search=(TABLE*) hash_search(&open_cache,
					    (byte*) key,key_length) ;
	 search ;
	 search = (TABLE*) hash_next(&open_cache,(byte*) key,key_length))
    {
      if (search->locked_by_flush ||
	  search->locked_by_name && wait_for_name_lock ||
	  search->db_stat && search->s->version < refresh_version)
	return 1;				// Table is used
    }
  } while ((table=table->next));
  return 0;
}


/* Wait until all used tables are refreshed */

bool wait_for_tables(THD *thd)
{
  bool result;
  DBUG_ENTER("wait_for_tables");

  thd->proc_info="Waiting for tables";
  pthread_mutex_lock(&LOCK_open);
  while (!thd->killed)
  {
    thd->some_tables_deleted=0;
    close_old_data_files(thd,thd->open_tables,0,dropping_tables != 0);
    mysql_ha_flush(thd, (TABLE_LIST*) NULL, MYSQL_HA_REOPEN_ON_USAGE);
    if (!table_is_used(thd->open_tables,1))
      break;
    (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
  }
  if (thd->killed)
    result= 1;					// aborted
  else
  {
    /* Now we can open all tables without any interference */
    thd->proc_info="Reopen tables";
    result=reopen_tables(thd,0,0);
  }
  pthread_mutex_unlock(&LOCK_open);
  thd->proc_info=0;
  DBUG_RETURN(result);
}


/* drop tables from locked list */

bool drop_locked_tables(THD *thd,const char *db, const char *table_name)
{
  TABLE *table,*next,**prev;
  bool found=0;
  prev= &thd->open_tables;
  for (table= thd->open_tables; table ; table=next)
  {
    next=table->next;
    if (!strcmp(table->s->table_name, table_name) &&
	!strcmp(table->s->db, db))
    {
      mysql_lock_remove(thd, thd->locked_tables,table);
      VOID(hash_delete(&open_cache,(byte*) table));
      found=1;
    }
    else
    {
      *prev=table;
      prev= &table->next;
    }
  }
  *prev=0;
  if (found)
    VOID(pthread_cond_broadcast(&COND_refresh)); // Signal to refresh
  if (thd->locked_tables && thd->locked_tables->table_count == 0)
  {
    my_free((gptr) thd->locked_tables,MYF(0));
    thd->locked_tables=0;
  }
  return found;
}


/*
  If we have the table open, which only happens when a LOCK TABLE has been
  done on the table, change the lock type to a lock that will abort all
  other threads trying to get the lock.
*/

void abort_locked_tables(THD *thd,const char *db, const char *table_name)
{
  TABLE *table;
  for (table= thd->open_tables; table ; table= table->next)
  {
    if (!strcmp(table->s->table_name,table_name) &&
	!strcmp(table->s->db, db))
    {
      mysql_lock_abort(thd,table);
      break;
    }
  }
}


/*
  Load a table definition from file and open unireg table

  SYNOPSIS
    open_unireg_entry()
    thd			Thread handle
    entry		Store open table definition here
    db			Database name
    name		Table name
    alias		Alias name
    table_desc		TABLE_LIST descriptor (used with views)
    mem_root		temporary mem_root for parsing

  NOTES
   Extra argument for open is taken from thd->open_options

  RETURN
    0	ok
    #	Error
*/
static int open_unireg_entry(THD *thd, TABLE *entry, const char *db,
			     const char *name, const char *alias,
			     TABLE_LIST *table_desc, MEM_ROOT *mem_root)
{
  char path[FN_REFLEN];
  int error;
  uint discover_retry_count= 0;
  DBUG_ENTER("open_unireg_entry");

  strxmov(path, mysql_data_home, "/", db, "/", name, NullS);
  while ((error= openfrm(thd, path, alias,
		         (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
			         HA_GET_INDEX | HA_TRY_READ_ONLY |
                                 NO_ERR_ON_NEW_FRM),
		      READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
		      thd->open_options, entry)) &&
      (error != 5 ||
       (fn_format(path, path, 0, reg_ext, MY_UNPACK_FILENAME),
        open_new_frm(path, alias, db, name,
                     (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
                             HA_GET_INDEX | HA_TRY_READ_ONLY),
                     READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
                     thd->open_options, entry, table_desc, mem_root))))

  {
    if (!entry->s || !entry->s->crashed)
    {
      /*
        Frm file could not be found on disk
        Since it does not exist, no one can be using it
        LOCK_open has been locked to protect from someone else
        trying to discover the table at the same time.
      */
      if (discover_retry_count++ != 0)
       goto err;
      if (ha_create_table_from_engine(thd, db, name, TRUE) != 0)
       goto err;

      thd->clear_error(); // Clear error message
      continue;
    }

    // Code below is for repairing a crashed file
    TABLE_LIST table_list;
    bzero((char*) &table_list, sizeof(table_list)); // just for safe
    table_list.db=(char*) db;
    table_list.table_name=(char*) name;

    safe_mutex_assert_owner(&LOCK_open);

    if ((error=lock_table_name(thd,&table_list)))
    {
      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 (openfrm(thd, path, 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) || ! 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), name, my_errno);
      sql_print_error("Couldn't repair table: %s.%s",db,name);
      if (entry->file)
	closefrm(entry);
      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 (error == 5)
    DBUG_RETURN(0);	// we have just opened VIEW

  if (Table_triggers_list::check_n_load(thd, db, name, entry))
    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 + 2*NAME_LEN + 1;
      if ((query= (char*)my_malloc(query_buf_size,MYF(MY_WME))))
      {
        end = strxmov(strmov(query, "DELETE FROM `"),
                      db,"`.`",name,"`", NullS);
        Query_log_event qinfo(thd, query, (ulong)(end-query), 0, FALSE);
        mysql_bin_log.write(&qinfo);
        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",db,name);
        delete entry->triggers;
        if (entry->file)
          closefrm(entry);
        goto err;
      }
    }
  }
  DBUG_RETURN(0);
err:
  /* Hide "Table doesn't exist" errors if table belong to view */
  if (thd->net.last_errno == ER_NO_SUCH_TABLE &&
      table_desc && table_desc->belong_to_view)
  {
    TABLE_LIST * view= table_desc->belong_to_view;
    thd->clear_error();
    my_error(ER_VIEW_INVALID, MYF(0), view->view_db.str, view->view_name.str);
  }
  DBUG_RETURN(1);
}

/*
  Open all tables in list

  SYNOPSIS
    open_tables()
    thd - thread handler
    start - list of tables
    counter - number of opened tables will be return using this parameter

  RETURN
    0  - OK
    -1 - error
*/

int open_tables(THD *thd, TABLE_LIST *start, uint *counter)
{
  TABLE_LIST *tables;
  bool refresh;
  int result=0;
  DBUG_ENTER("open_tables");
  MEM_ROOT new_frm_mem;
  /*
    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;
  thd->proc_info="Opening 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 (tables->derived)
      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)))
    {
      free_root(&new_frm_mem, MYF(MY_KEEP_PREALLOC));
      if (tables->view)
      {
	(*counter)--;
	continue; //VIEW placeholder
      }

      if (refresh)				// Refresh in progress
      {
	/* close all 'old' tables used by this thread */
	pthread_mutex_lock(&LOCK_open);
	// if query_id is not reset, we will get an error
	// re-opening a temp table
	thd->version=refresh_version;
	TABLE **prev_table= &thd->open_tables;
	bool found=0;
	for (TABLE_LIST *tmp= start; tmp; tmp= tmp->next_global)
	{
	  /* Close normal (not temporary) changed tables */
	  if (tmp->table && ! tmp->table->s->tmp_table)
	  {
	    if (tmp->table->s->version != refresh_version ||
		! tmp->table->db_stat)
	    {
	      VOID(hash_delete(&open_cache,(byte*) tmp->table));
	      tmp->table=0;
	      found=1;
	    }
	    else
	    {
	      *prev_table= tmp->table;		// Relink open list
	      prev_table= &tmp->table->next;
	    }
	  }
	}
	*prev_table=0;
	pthread_mutex_unlock(&LOCK_open);
	if (found)
	  VOID(pthread_cond_broadcast(&COND_refresh)); // Signal to refresh
	goto restart;
      }
      result= -1;				// Fatal error
      break;
    }
    else
      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;
  }
  thd->proc_info=0;
  free_root(&new_frm_mem, MYF(0));              // Free pre-alloced block
  DBUG_RETURN(result);
}


/*
  Check that lock is ok for tables; Call start stmt if ok

  SYNOPSIS
    check_lock_and_start_stmt()
    thd			Thread handle
    table_list		Table to check
    lock_type		Lock used for table

  RETURN VALUES
  0	ok
  1	error
*/

static bool check_lock_and_start_stmt(THD *thd, TABLE *table,
				      thr_lock_type lock_type)
{
  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)))
  {
    table->file->print_error(error,MYF(0));
    DBUG_RETURN(1);
  }
  DBUG_RETURN(0);
}


/*
  Open and lock one table

  SYNOPSIS
    open_ltable()
    thd			Thread handler
    table_list		Table to open is first table in this list
    lock_type		Lock to use for open

  RETURN VALUES
    table		Opened table
    0			Error
  
    If ok, the following are also set:
      table_list->lock_type 	lock_type
      table_list->table		table
*/

TABLE *open_ltable(THD *thd, TABLE_LIST *table_list, thr_lock_type lock_type)
{
  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)) &&
         refresh)
    ;

  if (table)
  {
#if defined( __WIN__) || defined(OS2)
    /* Win32 can't drop a file that is open */
    if (lock_type == TL_WRITE_ALLOW_READ)
    {
      lock_type= TL_WRITE;
    }
#endif /* __WIN__ || OS2 */
    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)))
	  table= 0;
    }
  }
  thd->proc_info=0;
  DBUG_RETURN(table);
}


/*
  Open all tables in list and locks them for read without derived
  tables processing.

  SYNOPSIS
    simple_open_n_lock_tables()
    thd		- thread handler
    tables	- list of tables for open&locking

  RETURN
    0  - ok
    -1 - error

  NOTE
    The lock will automaticly be freed by close_thread_tables()
*/

int simple_open_n_lock_tables(THD *thd, TABLE_LIST *tables)
{
  DBUG_ENTER("simple_open_n_lock_tables");
  uint counter;
  if (open_tables(thd, tables, &counter) || lock_tables(thd, tables, counter))
    DBUG_RETURN(-1);				/* purecov: inspected */
  DBUG_RETURN(0);
}


/*
  Open all tables in list, locks them and process derived tables
  tables processing.

  SYNOPSIS
    open_and_lock_tables()
    thd		- thread handler
    tables	- list of tables for open&locking

  RETURN
    FALSE - ok
    TRUE  - error

  NOTE
    The lock will automaticly be freed by close_thread_tables()
*/

bool open_and_lock_tables(THD *thd, TABLE_LIST *tables)
{
  uint counter;
  DBUG_ENTER("open_and_lock_tables");
  if (open_tables(thd, tables, &counter) ||
      lock_tables(thd, tables, counter) ||
      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 */
  relink_tables_for_multidelete(thd);
  DBUG_RETURN(0);
}


/*
  Open all tables in list and process derived tables

  SYNOPSIS
    open_normal_and_derived_tables
    thd		- thread handler
    tables	- list of tables for open&locking

  RETURN
    FALSE - ok
    TRUE  - error

  NOTE 
    This is to be used on prepare stage when you don't read any
    data from the tables.
*/

bool open_normal_and_derived_tables(THD *thd, TABLE_LIST *tables)
{
  uint counter;
  DBUG_ENTER("open_normal_and_derived_tables");
  DBUG_ASSERT(!thd->fill_derived_tables());
  if (open_tables(thd, tables, &counter) ||
      mysql_handle_derived(thd->lex, &mysql_derived_prepare))
    DBUG_RETURN(TRUE); /* purecov: inspected */
  relink_tables_for_multidelete(thd);           // Not really needed, but
  DBUG_RETURN(0);
}


/*
  Let us propagate pointers to open tables from global table list
  to table lists for multi-delete
*/

static void relink_tables_for_multidelete(THD *thd)
{
  if (thd->lex->all_selects_list->next_select_in_list())
  {
    for (SELECT_LEX *sl= thd->lex->all_selects_list;
	 sl;
	 sl= sl->next_select_in_list())
    {
      for (TABLE_LIST *cursor= (TABLE_LIST *) sl->table_list.first;
           cursor;
           cursor=cursor->next_local)
      {
        if (cursor->correspondent_table)
          cursor->table= cursor->correspondent_table->table;
      }
    }
  }
}


/*
  Lock all tables in list

  SYNOPSIS
    lock_tables()
    thd			Thread handler
    tables		Tables to lock
    count		umber of opened tables

  NOTES
    You can't call lock_tables twice, as this would break the dead-lock-free
    handling thr_lock gives us.  You most always get all needed locks at
    once.

  RETURN VALUES
   0	ok
   -1	Error
*/

int lock_tables(THD *thd, TABLE_LIST *tables, uint count)
{
  TABLE_LIST *table;
  if (!tables)
    return 0;

  if (!thd->locked_tables)
  {
    DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
    TABLE **start,**ptr;
    if (!(ptr=start=(TABLE**) thd->alloc(sizeof(TABLE*)*count)))
      return -1;
    for (table= tables; table; table= table->next_global)
    {
      if (!table->placeholder() && !table->schema_table)
	*(ptr++)= table->table;
    }
    if (!(thd->lock=mysql_lock_tables(thd,start, (uint) (ptr - start))))
      return -1;				/* purecov: inspected */
  }
  else
  {
    for (table= tables; table; table= table->next_global)
    {
      if (!table->placeholder() && 
	  check_lock_and_start_stmt(thd, table->table, table->lock_type))
      {
	ha_rollback_stmt(thd);
	return -1;
      }
    }
  }
  return 0;
}


/*
  Open a single table without table caching and don't set it in open_list
  Used by alter_table to open a temporary table and when creating
  a temporary table with CREATE TEMPORARY ...
*/

TABLE *open_temporary_table(THD *thd, const char *path, const char *db,
			    const char *table_name, bool link_in_list)
{
  TABLE *tmp_table;
  TABLE_SHARE *share;
  DBUG_ENTER("open_temporary_table");

  /*
    The extra size in my_malloc() is for table_cache_key
    4 bytes for master thread id if we are in the slave
    1 byte to terminate db
    1 byte to terminate table_name
    total of 6 extra bytes in my_malloc in addition to table/db stuff
  */
  if (!(tmp_table=(TABLE*) my_malloc(sizeof(*tmp_table)+(uint) strlen(db)+
				     (uint) strlen(table_name)+6+4,
				     MYF(MY_WME))))
    DBUG_RETURN(0);				/* purecov: inspected */

  if (openfrm(thd, path, table_name,
	      (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE | HA_GET_INDEX),
	      READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
	      ha_open_options,
	      tmp_table))
  {
    my_free((char*) tmp_table,MYF(0));
    DBUG_RETURN(0);
  }

  share= tmp_table->s;
  tmp_table->reginfo.lock_type=TL_WRITE;	 // Simulate locked
  share->tmp_table= (tmp_table->file->has_transactions() ? 
                     TRANSACTIONAL_TMP_TABLE : TMP_TABLE);
  share->table_cache_key= (char*) (tmp_table+1);
  share->db= share->table_cache_key;
  share->key_length= (uint) (strmov(((char*) (share->table_name=
                                              strmov(share->table_cache_key,
                                                     db)+1)),
                                    table_name) -
                             share->table_cache_key) +1;
  int4store(share->table_cache_key + share->key_length, thd->server_id);
  share->key_length+= 4;
  int4store(share->table_cache_key + share->key_length,
	    thd->variables.pseudo_thread_id);
  share->key_length+= 4;

  if (link_in_list)
  {
    tmp_table->next=thd->temporary_tables;
    thd->temporary_tables=tmp_table;
    if (thd->slave_thread)
      slave_open_temp_tables++;
  }
  DBUG_RETURN(tmp_table);
}


bool rm_temporary_table(enum db_type base, char *path)
{
  bool error=0;
  DBUG_ENTER("rm_temporary_table");

  fn_format(path, path,"",reg_ext,4);
  unpack_filename(path,path);
  if (my_delete(path,MYF(0)))
    error=1; /* purecov: inspected */
  *fn_ext(path)='\0';				// remove extension
  handler *file=get_new_handler((TABLE*) 0, base);
  if (file && file->delete_table(path))
  {
    error=1;
    sql_print_warning("Could not remove tmp table: '%s', error: %d",
                      path, my_errno);
  }
  delete file;
  DBUG_RETURN(error);
}


/*****************************************************************************
** find field in list or tables. if field is unqualifed and unique,
** return unique field
******************************************************************************/

/* Special Field pointers for find_field_in_tables returning */
Field *not_found_field= (Field*) 0x1;
Field *view_ref_found= (Field*) 0x2; 

#define WRONG_GRANT (Field*) -1


/*
  Find field in table or view

  SYNOPSIS
    find_field_in_table()
    thd				thread handler
    table_list			table where to find
    name			name of field
    item_name                   name of item if it will be created (VIEW)
    length			length of name
    ref				expression substituted in VIEW should be
				  passed using this reference (return
				  view_ref_found)
    check_grants_table		do check columns grants for table?
    check_grants_view		do check columns grants for view?
    allow_rowid			do allow finding of "_rowid" field?
    cached_field_index_ptr	cached position in field list (used to
				  speedup prepared tables field finding)
    register_tree_change        TRUE if ref is not stack variable and we
                                  need register changes in item tree

  RETURN
    0			field is not found
    view_ref_found	found value in VIEW (real result is in *ref)
    #			pointer to field
*/

Field *
find_field_in_table(THD *thd, TABLE_LIST *table_list,
                    const char *name, const char *item_name,
                    uint length, Item **ref,
                    bool check_grants_table, bool check_grants_view,
                    bool allow_rowid,
                    uint *cached_field_index_ptr,
                    bool register_tree_change)
{
  Field *fld;
  DBUG_ENTER("find_field_in_table");
  DBUG_PRINT("enter", ("table: '%s'  name: '%s'  item name: '%s'  ref 0x%lx",
		       table_list->alias, name, item_name, (ulong) ref));
  if (table_list->field_translation)
  {
    uint num;
    if (table_list->schema_table_reformed)
    {
      num= thd->lex->current_select->item_list.elements;
    }
    else
    {
      DBUG_ASSERT(ref != 0 && table_list->view != 0);
      num= table_list->view->select_lex.item_list.elements;
    }
    Field_translator *trans= table_list->field_translation;
    for (uint i= 0; i < num; i ++)
    {
      if (!my_strcasecmp(system_charset_info, trans[i].name, name))
      {
        if (table_list->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*) (trans[i].item))->field);
        }
#ifndef NO_EMBEDDED_ACCESS_CHECKS
	if (check_grants_view &&
	    check_grant_column(thd, &table_list->grant,
			       table_list->view_db.str,
			       table_list->view_name.str,
			       name, length))
	  DBUG_RETURN(WRONG_GRANT);
#endif
        if (thd->lex->current_select->no_wrap_view_item)
	{
	  if (register_tree_change)
	    thd->change_item_tree(ref, trans[i].item);
	  else
            *ref= trans[i].item;
	}
        else
        {
          Item_ref *item_ref= new Item_ref(&trans[i].item,
                                           table_list->view_name.str,
                                           item_name);
          /* as far as Item_ref have defined reference it do not need tables */
          if (register_tree_change && item_ref)
            thd->change_item_tree(ref, item_ref);
	  else if (item_ref)
	    *ref= item_ref;
          if (!(*ref)->fixed)
            (*ref)->fix_fields(thd, 0, ref);
        }
	DBUG_RETURN((Field*) view_ref_found);
      }
    }
    DBUG_RETURN(0);
  }
  fld= find_field_in_real_table(thd, table_list->table, name, length,
				check_grants_table, allow_rowid,
				cached_field_index_ptr);
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  /* check for views with temporary table algorithm */
  if (check_grants_view && table_list->view &&
      fld && fld != WRONG_GRANT &&
      check_grant_column(thd, &table_list->grant,
			 table_list->view_db.str,
			 table_list->view_name.str,
			 name, length))
  {
    DBUG_RETURN(WRONG_GRANT);
  }
#endif
  DBUG_RETURN(fld);
}


/*
  Find field in table

  SYNOPSIS
    find_field_in_real_table()
    thd				thread handler
    table_list			table where to find
    name			name of field
    length			length of name
    check_grants		do check columns grants?
    allow_rowid			do allow finding of "_rowid" field?
    cached_field_index_ptr	cached position in field list (used to
				  speedup prepared tables field finding)

  RETURN
    0			field is not found
    #			pointer to field
*/

Field *find_field_in_real_table(THD *thd, TABLE *table,
                                const char *name, uint length,
                                bool check_grants, bool allow_rowid,
                                uint *cached_field_index_ptr)
{
  Field **field_ptr, *field;
  uint cached_field_index= *cached_field_index_ptr;

  /* 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);
  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 && *field_ptr)
  {
    *cached_field_index_ptr= field_ptr - table->field;
    field= *field_ptr;
  }
  else
  {
    if (!allow_rowid ||
        my_strcasecmp(system_charset_info, name, "_rowid") ||
        !(field=table->rowid_field))
      return (Field*) 0;
  }

  if (thd->set_query_id)
  {
    if (field->query_id != thd->query_id)
    {
      field->query_id=thd->query_id;
      table->used_fields++;
      table->used_keys.intersect(field->part_of_key);
    }
    else
      thd->dupp_field=field;
  }
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  if (check_grants && check_grant_column(thd, &table->grant,
					 table->s->db,
					 table->s->table_name, name, length))
    return WRONG_GRANT;
#endif
  return field;
}


/*
  Find field in table list.

  SYNOPSIS
    find_field_in_tables()
    thd			Pointer to current thread structure
    item		Field item that should be found
    tables		Tables to be searched for item
    ref			If 'item' is resolved to a view field, ref is set to
                        point to the found view field
    report_error	Degree of error reporting:
                        - IGNORE_ERRORS then do not report any error
                        - IGNORE_EXCEPT_NON_UNIQUE report only non-unique
                          fields, suppress all other errors
                        - REPORT_EXCEPT_NON_UNIQUE report all other errors
                          except when non-unique fields were found
                        - REPORT_ALL_ERRORS
    check_privileges    need to check privileges

  RETURN VALUES
    0			If error: the found field is not unique, or there are
                        no sufficient access priviliges for the found field,
                        or the field is qualified with non-existing table.
    not_found_field	The function was called with report_error ==
                        (IGNORE_ERRORS || IGNORE_EXCEPT_NON_UNIQUE) and a
			field was not found.
    view_ref_found	View field is found, item passed through ref parameter
    found field         If a item was resolved to some field
*/

Field *
find_field_in_tables(THD *thd, Item_ident *item, TABLE_LIST *tables,
		     Item **ref, find_item_error_report_type report_error,
                     bool check_privileges)
{
  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];


  if (item->cached_table)
  {
    /*
      This shortcut is used by prepared statements. We assuming that
      TABLE_LIST *tables 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.
    */
    if (item->cached_table->table && !item->cached_table->view)
    {
      found= find_field_in_real_table(thd, item->cached_table->table,
				      name, length,
				      test(item->cached_table->
					   table->grant.want_privilege) &&
				      check_privileges,
				      1, &(item->cached_field_index));

    }
    else
    {
      TABLE_LIST *table= item->cached_table;
      found= find_field_in_table(thd, table, name, item->name, length,
				       ref,
				       (table->table &&
					test(table->table->grant.
					     want_privilege) &&
					check_privileges),
				       (test(table->grant.want_privilege) &&
					check_privileges),
				       1, &(item->cached_field_index),
                                       TRUE);
    }
    if (found)
    {
      if (found == WRONG_GRANT)
	return (Field*) 0;
      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 (table_name && table_name[0])
  {						/* Qualified field */
    bool found_table=0;
    for (; tables; tables= tables->next_local)
    {
      /* TODO; Ensure that db and tables->db always points to something ! */
      if (!my_strcasecmp(table_alias_charset, tables->alias, table_name) &&
	  (!db || !db[0] || !tables->db ||  !tables->db[0] ||
           !strcmp(db,tables->db)))
      {
	found_table=1;
	Field *find= find_field_in_table(thd, tables, name, item->name,
                                         length, ref,
					 (tables->table &&
					  test(tables->table->grant.
                                               want_privilege) &&
                                          check_privileges),
					 (test(tables->grant.want_privilege) &&
                                          check_privileges),
					 1, &(item->cached_field_index),
                                         TRUE);
	if (find)
	{
	  item->cached_table= tables;
	  if (!tables->cacheable_table)
	    item->cached_table= 0;
	  if (find == WRONG_GRANT)
	    return (Field*) 0;
	  if (db || !thd->where)
	    return find;
	  if (found)
	  {
            if (report_error == REPORT_ALL_ERRORS ||
                report_error == IGNORE_EXCEPT_NON_UNIQUE)
              my_error(ER_NON_UNIQ_ERROR, MYF(0),
                       item->full_name(),thd->where);
	    return (Field*) 0;
	  }
	  found=find;
	}
      }
    }
    if (found)
      return found;
    if (!found_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
	return (Field*) not_found_field;
    return (Field*) 0;
  }

  bool allow_rowid= tables && !tables->next_local;	// Only one table
  for (; tables ; tables= tables->next_local)
  {
    if (!tables->table && !tables->ancestor)
    {
      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);
      return (Field*) not_found_field;
    }

    Field *field= find_field_in_table(thd, tables, name, item->name,
                                      length, ref,
				      (tables->table &&
				       test(tables->table->grant.
                                            want_privilege) &&
                                       check_privileges),
				      (test(tables->grant.want_privilege) &&
                                       check_privileges),
				      allow_rowid,
                                      &(item->cached_field_index),
                                      TRUE);
    if (field)
    {
      if (field == WRONG_GRANT)
	return (Field*) 0;
      item->cached_table= (!tables->cacheable_table || found) ? 0 : tables;
      if (found)
      {
	if (!thd->where)			// Returns first found
	  break;
        if (report_error == REPORT_ALL_ERRORS ||
            report_error == IGNORE_EXCEPT_NON_UNIQUE)
          my_error(ER_NON_UNIQ_ERROR, MYF(0), name, thd->where);
	return (Field*) 0;
      }
      found=field;
    }
  }
  if (found)
    return found;
  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
    return (Field*) not_found_field;
  return (Field*) 0;
}


/*
  Find Item in list of items (find_field_in_tables analog)

  TODO
    is it better return only counter?

  SYNOPSIS
    find_item_in_list()
    find			Item to find
    items			List of items
    counter			To return number of found item
    report_error
      REPORT_ALL_ERRORS		report errors, return 0 if error
      REPORT_EXCEPT_NOT_FOUND	Do not report 'not found' error and
				return not_found_item, report other errors,
				return 0
      IGNORE_ERRORS		Do not report errors, return 0 if error
    unaliased                   Set to true if item is field which was found
                                by original field name and not by its alias
                                in item list. Set to false otherwise.

  RETURN VALUES
    0			Item is not found or item is not unique,
			error message is reported
    not_found_item	Function was called with
			report_error == REPORT_EXCEPT_NOT_FOUND and
			item was not found. No error message was reported
                        found field
*/

/* Special Item pointer to serve as a return value from find_item_in_list(). */
Item **not_found_item= (Item**) 0x1;


Item **
find_item_in_list(Item *find, List<Item> &items, uint *counter,
                  find_item_error_report_type report_error, bool *unaliased)
{
  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->type() == Item::FIELD_ITEM)
    {
      Item_field *item_field= (Item_field*) 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 && (item->eq(find,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;
}

/****************************************************************************
** Expand all '*' in given fields
****************************************************************************/

int setup_wild(THD *thd, TABLE_LIST *tables, List<Item> &fields,
	       List<Item> *sum_func_list,
	       uint wild_num)
{
  if (!wild_num)
    return(0);

  Item *item;
  List_iterator<Item> it(fields);
  Item_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->change_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,tables,((Item_field*) item)->db_name,
                             ((Item_field*) item)->table_name, &it,
                             any_privileges, arena != 0))
      {
	if (arena)
	  thd->restore_backup_item_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_backup_item_arena(arena, &backup);
  }
  DBUG_RETURN(0);
}

/****************************************************************************
** Check that all given fields exists and fill struct with current data
****************************************************************************/

bool setup_fields(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables, 
                  List<Item> &fields, bool set_query_id,
                  List<Item> *sum_func_list, bool allow_sum_func)
{
  reg2 Item *item;
  List_iterator<Item> it(fields);
  SELECT_LEX *select_lex= thd->lex->current_select;
  DBUG_ENTER("setup_fields");

  thd->set_query_id=set_query_id;
  thd->allow_sum_func= allow_sum_func;
  thd->where="field list";

  /*
    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, tables, it.ref()) ||
	(item= *(it.ref()))->check_cols(1))
    {
      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();
  }
  DBUG_RETURN(test(thd->net.report_error));
}


/*
  make list of leaves of join table tree

  SYNOPSIS
    make_leaves_list()
    list    pointer to pointer on list first element
    tables  table list

  RETURN pointer on pointer to next_leaf of last element
*/

TABLE_LIST **make_leaves_list(TABLE_LIST **list, TABLE_LIST *tables)
{
  for (TABLE_LIST *table= tables; table; table= table->next_local)
  {
    if (table->view && !table->table)
    {
      /* it is for multi table views only, check it */
      DBUG_ASSERT(table->ancestor->next_local);
      list= make_leaves_list(list, table->ancestor);
    }
    else
    {
      *list= table;
      list= &table->next_leaf;
    }
  }
  return list;
}

/*
  prepare tables

  SYNOPSIS
    setup_tables()
    thd		  Thread handler
    tables	  Table list
    conds	  Condition of current SELECT (can be changed by VIEW)
    leaves        List of join table leaves list
    refresh       It is onle refresh for subquery
    select_insert It is SELECT ... INSERT command

  NOTE
    Check also that the 'used keys' and 'ignored keys' exists and set up the
    table structure accordingly
    Create leaf tables list

    This has to be called for all tables that are used by items, as otherwise
    table->map is not set and all Item_field will be regarded as const items.

  RETURN
    FALSE ok;  In this case *map will includes the choosed index
    TRUE  error
*/

bool setup_tables(THD *thd, TABLE_LIST *tables, Item **conds,
                  TABLE_LIST **leaves, bool refresh, bool select_insert)
{
  uint tablenr= 0;
  DBUG_ENTER("setup_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);

  for (TABLE_LIST *table_list= *leaves;
       table_list;
       table_list= table_list->next_leaf, tablenr++)
  {
    TABLE *table= table_list->table;
    if (first_select_table &&
        (table_list->belong_to_view ?
         table_list->belong_to_view :
         table_list) == 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;
    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);
  }
  if (!refresh)
  {
    for (TABLE_LIST *table_list= tables;
	 table_list;
	 table_list= table_list->next_local)
    {
      if (table_list->ancestor &&
	table_list->setup_ancestor(thd, conds,
				   table_list->effective_with_check))
        DBUG_RETURN(1);
    }
  }
  DBUG_RETURN(0);
}


/*
   Create a key_map from a list of index names

   SYNOPSIS
     get_key_map_from_key_list()
     map		key_map to fill in
     table		Table
     index_list		List of index names

   RETURN
     0	ok;  In this case *map will includes the choosed index
     1	error
*/

bool get_key_map_from_key_list(key_map *map, TABLE *table,
                               List<String> *index_list)
{
  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_COLUMN_DOES_NOT_EXITS, MYF(0),
               name->c_ptr(), table->s->table_name);
      map->set_all();
      return 1;
    }
    map->set_bit(pos-1);
  }
  return 0;
}


/*
  Drops in all fields instead of current '*' field

  SYNOPSIS
    insert_fields()
    thd			Thread handler
    tables		List of tables
    db_name		Database name in case of 'database_name.table_name.*'
    table_name		Table name in case of 'table_name.*'
    it			Pointer to '*'
    any_privileges	0 If we should ensure that we have SELECT privileges
		          for all columns
                        1 If any privilege is ok
    allocate_view_names if true view names will be copied to current Item_arena
                        memory (made for SP/PS)
  RETURN
    0	ok
        'it' is updated to point at last inserted
    1	error.  Error message is generated but not sent to client
*/

bool
insert_fields(THD *thd, TABLE_LIST *tables, const char *db_name,
	      const char *table_name, List_iterator<Item> *it,
              bool any_privileges, bool allocate_view_names)
{
  /* allocate variables on stack to avoid pool alloaction */
  Field_iterator_table table_iter;
  Field_iterator_view view_iter;
  uint found;
  char name_buff[NAME_LEN+1];
  DBUG_ENTER("insert_fields");

  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= 0;
  for (; tables; tables= tables->next_local)
  {
    Field_iterator *iterator;
    TABLE_LIST *natural_join_table;
    Field *field;
    TABLE_LIST *embedded;
    TABLE_LIST *last;
    TABLE_LIST *embedding;
    TABLE *table= tables->table;
    bool alias_used= 0;

    if (!table_name || (!my_strcasecmp(table_alias_charset, table_name,
				       tables->alias) &&
			(!db_name || !strcmp(tables->db,db_name))))
    {
      bool view;
#ifndef NO_EMBEDDED_ACCESS_CHECKS
      /* Ensure that we have access right to all columns */
      if (!((table && (table->grant.privilege & SELECT_ACL) ||
	     tables->view && (tables->grant.privilege & SELECT_ACL))) &&
	  !any_privileges)
      {
        if (tables->view)
        {
          view_iter.set(tables);
          if (check_grant_all_columns(thd, SELECT_ACL, &tables->grant,
                                      tables->view_db.str,
                                      tables->view_name.str,
                                      &view_iter))
            goto err;
        }
        else if (!tables->schema_table)
        {
	  DBUG_ASSERT(table != 0);
          table_iter.set(tables);
          if (check_grant_all_columns(thd, SELECT_ACL, &table->grant,
                                      table->s->db,
                                      table->s->table_name,
                                      &table_iter))
            goto err;
        }
      }
#endif
      if (table)
	thd->used_tables|= table->map;
      else
      {
	view_iter.set(tables);
	for (; !view_iter.end_of_fields(); view_iter.next())
	{
	  thd->used_tables|= view_iter.item(thd)->used_tables();
	}
      }
      natural_join_table= 0;
      last= embedded= tables;

      while ((embedding= embedded->embedding) &&
              embedding->join_list->elements != 1)
      {
        TABLE_LIST *next;
        List_iterator_fast<TABLE_LIST> it(embedding->nested_join->join_list);
        last= it++;
        while ((next= it++))
          last= next;
        if (last != tables)
          break;
        embedded= embedding;
      }

      if (tables == last &&
          !embedded->outer_join &&
          embedded->natural_join &&
          !embedded->natural_join->outer_join)
      {
        embedding= embedded->natural_join;
        while (embedding->nested_join)
          embedding= embedding->nested_join->join_list.head();
        natural_join_table= embedding;
      }
      if (tables->field_translation)
      {
        iterator= &view_iter;
	view= 1;
	alias_used= my_strcasecmp(table_alias_charset,
				  tables->table_name, tables->alias);
      }
      else
      {
        iterator= &table_iter;
	view= 0;
      }
      iterator->set(tables);

      for (; !iterator->end_of_fields(); iterator->next())
      {
        Item *not_used_item;
        uint not_used_field_index= NO_CACHED_FIELD_INDEX;
        const char *field_name= iterator->name();
        /* Skip duplicate field names if NATURAL JOIN is used */
        if (!natural_join_table ||
            !find_field_in_table(thd, natural_join_table, field_name,
                                 field_name,
                                 strlen(field_name), &not_used_item, 0, 0, 0,
                                 &not_used_field_index, TRUE))
        {
          Item *item= iterator->item(thd);
	  if (view && !thd->lex->current_select->no_wrap_view_item)
	  {
            /*
              as far as we have view, then item point to view_iter, so we
              can use it directly for this view specific operation
            */
	    item= new Item_ref(view_iter.item_ptr(), tables->view_name.str,
                               field_name);
	  }
          if (!found++)
            (void) it->replace(item);		// Replace '*'
          else
            it->after(item);
#ifndef NO_EMBEDDED_ACCESS_CHECKS
          if (any_privileges)
          {
            /*
              In time of view creation MEGRGE algorithm for underlying
              VIEWs can't be used => it should be Item_field
            */
            DBUG_ASSERT(item->type() == Item::FIELD_ITEM);
            Item_field *fld= (Item_field*)item;
            char *db, *tab;
            if (tables->view)
            {
              db= tables->view_db.str;
              tab= tables->view_name.str;
            }
            else
            {
              db= tables->db;
              tab= tables->table_name;
            }
            if (!tables->schema_table && 
                !(fld->have_privileges= (get_column_grant(thd,
                                                          &table->grant,
                                                          db,
                                                          tab,
                                                          fld->field_name) &
                                         VIEW_ANY_ACL)))
            {
              my_error(ER_COLUMNACCESS_DENIED_ERROR, MYF(0),
                       "ANY",
                       thd->priv_user,
                       thd->host_or_ip,
                       fld->field_name,
                       tab);
              goto err;
            }
          }
#endif
        }
        if ((field= iterator->field()))
        {
          /*
            Mark if field used before in this select.
            Used by 'insert' to verify if a field name is used twice
          */
          if (field->query_id == thd->query_id)
            thd->dupp_field=field;
          field->query_id=thd->query_id;
          table->used_keys.intersect(field->part_of_key);
        }
        else if (allocate_view_names &&
                 thd->lex->current_select->first_execution)
        {
	  Item_field *item;
	  if (alias_used)
	    item= new Item_field(0,
				 thd->strdup(tables->alias),
				 thd->strdup(field_name));
	  else
	    item= new Item_field(thd->strdup(tables->view_db.str),
				 thd->strdup(tables->view_name.str),
				 thd->strdup(field_name));
          /*
            during cleunup() this item will be put in list to replace
            expression from VIEW
          */
          thd->nocheck_register_item_tree_change(it->ref(), item,
                                                 thd->mem_root);
        }
      }
      /*
	All fields are used in case if usual tables (in case of view used
	fields marked in setup_tables during fix_fields of view columns
      */
      if (table)
	table->used_fields= table->s->fields;
    }
  }
  if (found)
    DBUG_RETURN(0);

  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);
#ifndef NO_EMBEDDED_ACCESS_CHECKS
err:
#endif
  DBUG_RETURN(1);
}


/*
  Fix all conditions and outer join expressions

  SYNOPSIS
    setup_conds()
    thd     thread handler
    tables  list of tables for name resolving
    leaves  list of leaves of join table tree
*/

int setup_conds(THD *thd, TABLE_LIST *tables, TABLE_LIST *leaves, COND **conds)
{
  table_map not_null_tables= 0;
  SELECT_LEX *select_lex= thd->lex->current_select;
  Item_arena *arena= thd->current_arena, backup;
  bool save_wrapper= thd->lex->current_select->no_wrap_view_item;
  TABLE_LIST *table= NULL;	// For HP compilers
  DBUG_ENTER("setup_conds");

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

  thd->set_query_id=1;

  thd->lex->current_select->no_wrap_view_item= 1;
  select_lex->cond_count= 0;
  if (*conds)
  {
    thd->where="where clause";
    if (!(*conds)->fixed && (*conds)->fix_fields(thd, tables, conds) ||
	(*conds)->check_cols(1))
      goto err_no_arena;
  }

  /* Check if we are using outer joins */
  for (table= leaves; table; table= table->next_leaf)
  {
    TABLE_LIST *embedded;
    TABLE_LIST *embedding= table;
    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, tables, &embedded->on_expr) ||
	    embedded->on_expr->check_cols(1))
	  goto err_no_arena;
        select_lex->cond_count++;
      }
      if (embedded->natural_join)
      {
        /* Make a join of all fields wich have the same name */
        TABLE_LIST *tab1= embedded;
        TABLE_LIST *tab2= embedded->natural_join;
        if (!(embedded->outer_join & JOIN_TYPE_RIGHT))
        {
          while (tab1->nested_join)
          {
            TABLE_LIST *next;
            List_iterator_fast<TABLE_LIST> it(tab1->nested_join->join_list);
            tab1= it++;
            while ((next= it++))
              tab1= next;
          }
        }
        else
        {
          while (tab1->nested_join)
            tab1= tab1->nested_join->join_list.head();
        }
        if (embedded->outer_join & JOIN_TYPE_RIGHT)
        {
          while (tab2->nested_join)
          {
            TABLE_LIST *next;
            List_iterator_fast<TABLE_LIST> it(tab2->nested_join->join_list);
            tab2= it++;
            while ((next= it++))
              tab2= next;
          }
        }
        else
        {
          while (tab2->nested_join)
            tab2= tab2->nested_join->join_list.head();
        }

        if (arena)
	  arena= thd->change_arena_if_needed(&backup);

        TABLE *t1=tab1->table;
        TABLE *t2=tab2->table;
        Field_iterator_table table_iter;
        Field_iterator_view view_iter;
        Field_iterator *iterator;
        Field *t1_field, *t2_field;
        Item *item_t2= 0;
        Item_cond_and *cond_and= new Item_cond_and();

        if (!cond_and)				// If not out of memory
	  goto err_no_arena;
        cond_and->top_level_item();

        if (table->field_translation)
        {
          iterator= &view_iter;
          view_iter.set(tab1);
        }
        else
        {
          iterator= &table_iter;
          table_iter.set(tab1);
        }

        for (; !iterator->end_of_fields(); iterator->next())
        {
          const char *t1_field_name= iterator->name();
          uint not_used_field_index= NO_CACHED_FIELD_INDEX;

          if ((t2_field= find_field_in_table(thd, tab2, t1_field_name,
                                             t1_field_name,
                                             strlen(t1_field_name), &item_t2,
                                             0, 0, 0,
                                             &not_used_field_index,
                                             FALSE)))
          {
            if (t2_field != view_ref_found)
            {
              if (!(item_t2= new Item_field(thd, t2_field)))
                goto err;
              /* Mark field used for table cache */
              t2_field->query_id= thd->query_id;
              t2->used_keys.intersect(t2_field->part_of_key);
            }
            if ((t1_field= iterator->field()))
            {
              /* Mark field used for table cache */
              t1_field->query_id= thd->query_id;
              t1->used_keys.intersect(t1_field->part_of_key);
            }
            Item_func_eq *tmp= new Item_func_eq(iterator->item(thd),
                                                item_t2);
            if (!tmp)
              goto err;
            cond_and->list.push_back(tmp);
          }
        }
        select_lex->cond_count+= cond_and->list.elements;

        // to prevent natural join processing during PS re-execution
        embedding->natural_join= 0;

        if (cond_and->list.elements)
        {
          COND *on_expr= cond_and;
          if (!on_expr->fixed)
            on_expr->fix_fields(thd, 0, &on_expr);
          if (!embedded->outer_join)			// Not left join
          {
            *conds= and_conds(*conds, cond_and);
            // fix_fields() should be made with temporary memory pool
            if (arena)
              thd->restore_backup_item_arena(arena, &backup);
            if (*conds && !(*conds)->fixed)
            {
              if (!(*conds)->fixed &&
                  (*conds)->fix_fields(thd, tables, conds))
                goto err_no_arena;
            }
          }
          else
          {
            embedded->on_expr= and_conds(embedded->on_expr, cond_and);
            // fix_fields() should be made with temporary memory pool
            if (arena)
              thd->restore_backup_item_arena(arena, &backup);
            if (embedded->on_expr && !embedded->on_expr->fixed)
            {
              if (!embedded->on_expr->fixed &&
                  embedded->on_expr->fix_fields(thd, tables, &embedded->on_expr))
                goto err_no_arena;
            }
          }
        }
        else if (arena)
	  thd->restore_backup_item_arena(arena, &backup);
      }
      embedding= embedded->embedding;
    }
    while (embedding &&
           embedding->nested_join->join_list.head() == embedded);
  }

  if (!thd->current_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;
  }
  thd->lex->current_select->no_wrap_view_item= save_wrapper;
  DBUG_RETURN(test(thd->net.report_error));

err:
  if (arena)
    thd->restore_backup_item_arena(arena, &backup);
err_no_arena:
  thd->lex->current_select->no_wrap_view_item= save_wrapper;
  DBUG_RETURN(1);
}


/******************************************************************************
** Fill a record with data (for INSERT or UPDATE)
** Returns : 1 if some field has wrong type
******************************************************************************/


/*
  Fill fields with given items.

  SYNOPSIS
    fill_record()
    thd           thread handler
    fields        Item_fields list to be filled
    values        values to fill with
    ignore_errors TRUE if we should ignore errors

  RETURN
    FALSE   OK
    TRUE    error occured
*/

bool
fill_record(THD * thd, List<Item> &fields, List<Item> &values,
            bool ignore_errors)
{
  List_iterator_fast<Item> f(fields),v(values);
  Item *value;
  Item_field *field;
  DBUG_ENTER("fill_record");

  while ((field=(Item_field*) f++))
  {
    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);
}


/*
  Fill field buffer with values from Field list

  SYNOPSIS
    fill_record()
    thd           thread handler
    ptr           pointer on pointer to record
    values        list of fields
    ignore_errors TRUE if we should ignore errors

  RETURN
    FALSE   OK
    TRUE    error occured
*/

bool
fill_record(THD *thd, Field **ptr, List<Item> &values, bool ignore_errors)
{
  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) < 0) && !ignore_errors)
    {
      my_message(ER_UNKNOWN_ERROR, ER(ER_UNKNOWN_ERROR), MYF(0));
      DBUG_RETURN(TRUE);
    }
  }
  DBUG_RETURN(thd->net.report_error);
}


static void mysql_rm_tmp_tables(void)
{
  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%s",tmpdir,file->name);
        VOID(my_delete(filePath,MYF(MY_WME)));
    }
  }
  my_dirend(dirp);
  }
  DBUG_VOID_RETURN;
}



/*****************************************************************************
	unireg support functions
*****************************************************************************/

/*
** Invalidate any cache entries that are for some DB
** We can't use hash_delete when looping hash_elements. We mark them first
** and afterwards delete those marked unused.
*/

void remove_db_from_cache(const my_string db)
{
  for (uint idx=0 ; idx < open_cache.records ; idx++)
  {
    TABLE *table=(TABLE*) hash_element(&open_cache,idx);
    if (!strcmp(table->s->db, 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));
}


/*
** free all unused tables
*/

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


/*
  Mark all entries with the table as deleted to force an reopen of the table

  The table will be closed (not stored in cache) by the current thread when
  close_thread_tables() is called.

  RETURN
    0  This thread now have exclusive access to this table and no other thread
       can access the table until close_thread_tables() is called.
    1  Table is in use by another thread
*/

bool remove_table_from_cache(THD *thd, const char *db, const char *table_name,
			     bool return_if_owned_by_thd)
{
  char key[MAX_DBKEY_LENGTH];
  uint key_length;
  TABLE *table;
  bool result=0;
  DBUG_ENTER("remove_table_from_cache");

  key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
  for (table=(TABLE*) hash_search(&open_cache,(byte*) key,key_length) ;
       table;
       table = (TABLE*) hash_next(&open_cache,(byte*) key,key_length))
  {
    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)
    {
      in_use->some_tables_deleted=1;
      if (table->db_stat)
	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);
	  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(thd, thd_table);
      }
    }
    else
      result= result || return_if_owned_by_thd;
  }
  while (unused_tables && !unused_tables->s->version)
    VOID(hash_delete(&open_cache,(byte*) unused_tables));
  DBUG_RETURN(result);
}

int setup_ftfuncs(SELECT_LEX *select_lex)
{
  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;
}


int init_ftfuncs(THD *thd, SELECT_LEX *select_lex, bool no_order)
{
  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;
}


/*
  open new .frm format table

  SYNOPSIS
    open_new_frm()
    path	  path to .frm
    alias	  alias for table
    db            database
    table_name    name of table
    db_stat	  open flags (for example HA_OPEN_KEYFILE|HA_OPEN_RNDFILE..)
		  can be 0 (example in ha_example_table)
    prgflag	  READ_ALL etc..
    ha_open_flags HA_OPEN_ABORT_IF_LOCKED etc..
    outparam	  result table
    table_desc	  TABLE_LIST descriptor
    mem_root	  temporary MEM_ROOT for parsing
*/

static my_bool
open_new_frm(const char *path, const char *alias,
             const char *db, const char *table_name,
             uint db_stat, uint prgflag,
	     uint ha_open_flags, TABLE *outparam, TABLE_LIST *table_desc,
	     MEM_ROOT *mem_root)
{
  LEX_STRING pathstr;
  File_parser *parser;
  DBUG_ENTER("open_new_frm");

  pathstr.str=    (char*) path;
  pathstr.length= strlen(path);

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