~drizzle-trunk/drizzle/development

static pthread_mutex_t LOCK_table_share;

static bool table_def_inited= 0;

 

                             const char *alias,

                             char *cache_key, uint32_t cache_key_length);

static void free_cache_entry(Table *entry);

                                 bool send_refresh);

 

 

    Length of key

*/

 

                          bool tmp_table)

{

  uint32_t key_length= (uint) (my_stpcpy(my_stpcpy(key, table_list->db)+1,

   #  Share for table

*/

 

                             uint32_t key_length, uint32_t db_flags, int *error)

{

  TABLE_SHARE *share;

*/

 

static TABLE_SHARE

                             char *key, uint32_t key_length,

                             uint32_t db_flags, int *error)

{

 

  table_list.db= (char*) db;

  table_list.table_name= (char*) table_name;

  return (TABLE_SHARE*) hash_search(&table_def_cache,(unsigned char*) key, key_length);

}  

 

 

  SYNOPSIS

    list_open_tables()

    wild                SQL like expression

 

  NOTES

    #           Pointer to list of names of open tables.

*/

 

                                  const char *db, const char *wild)

{

  int result = 0;

         won't proceed while write-locked tables are being reopened by other

         threads.

 

          and tables must be NULL.

*/

 

                         bool wait_for_refresh, bool wait_for_placeholders)

{

  bool result=0;

    for (TableList *table= tables; table; table= table->next_local)

    {

      if (remove_table_from_cache(thd, table->db, table->table_name,

        found=1;

    }

    if (!found)

  if specified string is NULL, then any table with a connection string.

*/

 

                                    LEX_STRING *connection, bool have_lock)

{

  uint32_t idx;

          is not reset until the HANDLER is closed.

*/

 

{

  for (Table *table= thd->temporary_tables ; table ; table= table->next)

  {

    set to query_id of original query.

*/

 

{

  for (; table ; table= table->next)

  {

  @remark It should not ordinarily be called directly.

*/

 

{

  bool found_old_table= 0;

 

    leave prelocked mode if needed.

*/

 

{

  Table *table;

 

 

/* move one table to free list */

 

{

  bool found_old_table= 0;

  Table *table= *table_ptr;

 

 

/* close_temporary_tables' internal, 4 is due to uint4korr definition */

                              Table *table)

{

  return uint4korr(table->s->table_cache_key.str + table->s->table_cache_key.length - 4);

  creates one DROP TEMPORARY Table binlog event for each pseudo-thread 

*/

 

{

  Table *table;

  Table *next= NULL;

    check_alias           whether to check tables' aliases

 

  NOTE: to exclude derived tables from check we use following mechanism:

    b) JOIN::prepare set SELECT::exclude_from_table_unique_test if

       because for PS we perform only JOIN::prepare, but we can't set this

       flag in JOIN::prepare if we are not sure that we are in derived table

       processing loop, because multi-update call fix_fields() for some its

    0 if table is unique

*/

 

                         bool check_alias)

{

  TableList *res;

}

 

 

{

  TableList table_list;

 

}

 

 

{

  char  key[MAX_DBKEY_LENGTH];

  uint  key_length;

  @retval -1  the table is in use by a outer query

*/

 

{

  Table *table;

 

  unlink from thd->temporary tables and close temporary table

*/

 

                           bool free_share, bool delete_table)

{

  if (table->prev)

  thd->slave_proxy_id, separated by '\0'.

*/

 

                            const char *table_name)

{

  char *key;

          not locked (for example already unlocked).

*/

 

{

  char key[MAX_DBKEY_LENGTH];

  uint32_t key_length= find->s->table_cache_key.length;

          table that was locked with LOCK TABLES.

*/

 

                     const char *table_name)

{

  if (table->s->tmp_table)

     cond       Condition to wait for

*/

 

{

  /* Wait until the current table is up to date */

  const char *proc_info;

  @return false on success, true otherwise.

*/

 

{

  /* Under LOCK TABLES we must only accept write locked tables. */

  tables->table= find_locked_table(thd, tables->db, tables->table_name);

                  member should point to Table object which was used for

                  name-locking.

      link_in     true  - if Table object for table to be opened should be

                  false - placeholder used for name-locking is already in

                          this list so we only need to preserve Table::next

                          pointer.

    true  - Error

*/

 

{

  Table *table= table_list->table;

  TABLE_SHARE *share;

  else

  {

    /*

      need to set Table::next correctly.

    */

    table->next= orig_table.next;

            case of failure.

*/

 

                                      uint32_t key_length)

{

  Table *table;

    @retval  false  Success. 'table' parameter set according to above rules.

*/

 

                                   const char *table_name, Table **table)

{

  char key[MAX_DBKEY_LENGTH];

    @retval  false  No error. 'exists' out parameter set accordingly.

*/

 

{

  char path[FN_REFLEN];

  int rc;

*/

 

 

{

  register Table *table;

  char key[MAX_DBKEY_LENGTH];

        /*

          We're trying to use the same temporary table twice in a query.

          Right now we don't support this because a temporary table

          it can not be cloned. Emit an error for an unsupported behaviour.

        */

        if (table->query_id)

}

 

 

{

  char  key[MAX_DBKEY_LENGTH];

  uint32_t key_length=(uint) (my_stpcpy(my_stpcpy(key,db)+1,table_name)-key)+1;

  Field **field;

  uint32_t key,part;

  TableList table_list;

 

  assert(table->s->ref_count == 0);

  assert(!table->sort.io_cache);

          the strings are used in a loop even after the share may be freed.

*/

 

                                      const char *table_name)

{

  Table *table;

    @return false in case of success, true - otherwise.

*/

 

{

  Table *table,*next,**prev;

  Table **tables,**tables_ptr;                  // For locks

    @param send_refresh  Should we awake waiters even if we didn't close any tables?

*/

 

                                 bool send_refresh)

{

  bool found= send_refresh;

 

/* Wait until all used tables are refreshed */

 

{

  bool result;

 

*/

 

 

{

  Table *table,*next,**prev, *found= 0;

  prev= &thd->open_tables;

  other threads trying to get the lock.

*/

 

{

  Table *table;

  for (table= thd->open_tables; table ; table= table->next)

    #   Error

*/

 

                             const char *alias,

                             char *cache_key, uint32_t cache_key_length)

{

        /* this DELETE FROM is needed even with row-based binlogging */

        end = strxmov(my_stpcpy(query, "DELETE FROM `"),

                      share->db.str,"`.`",share->table_name.str,"`", NULL);

                          query, (ulong)(end-query), false, false);

        free(query);

      }

    -1 - error

*/

 

{

  TableList *tables= NULL;

  bool refresh;

  1     error

*/

 

                                      thr_lock_type lock_type)

{

  int error;

    and locking issues because it does not call lock_tables().

*/

 

                                thr_lock_type lock_type)

{

  TableList *save_next_global;

      table_list->table         table

*/

 

                   uint32_t lock_flags)

{

  Table *table;

    the third argument set appropriately.

*/

 

{

  uint32_t counter;

  bool need_reopen;

    data from the tables.

*/

 

{

  uint32_t counter;

  assert(!thd->fill_derived_tables());

   @param tables Tables involved in the query

 */

 

{

  if (mysql_bin_log.is_open() && (thd->options & OPTION_BIN_LOG))

  {

   -1   Error

*/

 

{

  TableList *table;

 

 

*/

 

{

  /*

    If table list consists only from tables from prelocking set, table list

   #  Table object

*/

 

                            const char *table_name, bool link_in_list,

                            open_table_mode open_mode)

{

 

#define WRONG_GRANT (Field*) -1

 

{

  if (thd->mark_used_columns != MARK_COLUMNS_NONE)

  {

*/

 

static Field *

                           uint32_t length __attribute__((unused)),

                           Item **ref __attribute__((unused)), bool register_tree_change __attribute__((unused)),

                           TableList **actual_table)

*/

 

Field *

                    bool allow_rowid, uint32_t *cached_field_index_ptr)

{

  Field **field_ptr, *field;

*/

 

Field *

                        const char *name, uint32_t length,

                        const char *item_name, const char *db_name,

                        const char *table_name, Item **ref,

*/

 

Field *

                     TableList *first_table, TableList *last_table,

                     Item **ref, find_item_error_report_type report_error,

                     bool check_privileges, bool register_tree_change)

*/

 

static bool

{

  Name_resolution_context *context;

  if (!(context= new (thd->mem_root) Name_resolution_context))

*/

 

static bool

                    List<String> *using_fields, uint32_t *found_using_fields)

{

  Field_iterator_table_ref it_1, it_2;

*/

 

static bool

                                 TableList *natural_using_join,

                                 TableList *table_ref_1,

                                 TableList *table_ref_2,

*/

 

static bool

                             TableList *left_neighbor,

                             TableList *right_neighbor)

{

    true   Error

    false  OK

*/

                                         List<TableList> *from_clause,

                                         Name_resolution_context *context)

{

** Expand all '*' in given fields

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

 

               TableList *tables __attribute__((unused)),

               List<Item> &fields,

               List<Item> *sum_func_list,

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

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

 

                  List<Item> &fields, enum_mark_columns mark_used_columns,

                  List<Item> *sum_func_list, bool allow_sum_func)

{

  thd->mark_used_columns= mark_used_columns;

  if (allow_sum_func)

    thd->lex->allow_sum_func|= 1 << thd->lex->current_select->nest_level;

  save_is_item_list_lookup= thd->lex->current_select->is_item_list_lookup;

  thd->lex->current_select->is_item_list_lookup= 0;

 

    true  error

*/

 

                  List<TableList> *from_clause, TableList *tables,

                  TableList **leaves, bool select_insert)

{

    false ok;  In this case *map will include the chosen index

    true  error

*/

                                   Name_resolution_context *context,

                                   List<TableList> *from_clause,

                                   TableList *tables,

*/

 

bool

              const char *table_name, List_iterator<Item> *it,

              bool any_privileges __attribute__((unused)))

{

    false if all is OK

*/

 

                TableList *leaves,

                COND **conds)

{

*/

 

bool

{

  List_iterator_fast<Item> f(fields),v(values);

  Item *value, *fld;

*/

 

bool

            bool ignore_errors __attribute__((unused)))

{

  List_iterator_fast<Item> v(values);

  MY_DIR *dirp;

  FILEINFO *file;

  TABLE_SHARE share;

 

    return(1);

  thd->thread_stack= (char*) &thd;

  thd->store_globals();

    my_dirend(dirp);

  }

  delete thd;

  return(0);

}

 

    1  Table is in use by another thread

*/

 

                             uint32_t flags)

{

  char key[MAX_DBKEY_LENGTH];

         table= (Table*) hash_next(&open_cache, (unsigned char*) key, key_length,

                                   &state))

    {

 

      table->s->version=0L;             /* Free when thread is ready */

      if (!(in_use=table->in_use))

        }

      }

      else

    }

    while (unused_tables && !unused_tables->s->version)

      hash_delete(&open_cache,(unsigned char*) unused_tables);