sql_base.cc 273 KB
Newer Older
1
/* Copyright 2000-2008 MySQL AB, 2008 Sun Microsystems, Inc.
2

unknown's avatar
unknown committed
3 4
   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
unknown's avatar
unknown committed
5
   the Free Software Foundation; version 2 of the License.
6

unknown's avatar
unknown committed
7 8 9 10
   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.
11

unknown's avatar
unknown committed
12 13 14 15 16
   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 */


17
/* Basic functions needed by many modules */
unknown's avatar
unknown committed
18 19

#include "mysql_priv.h"
20
#include "debug_sync.h"
21
#include "sql_select.h"
22
#include "sp_head.h"
23
#include "sp.h"
24
#include "sql_trigger.h"
Konstantin Osipov's avatar
Konstantin Osipov committed
25
#include "transaction.h"
26
#include "sql_prepare.h"
unknown's avatar
unknown committed
27 28 29
#include <m_ctype.h>
#include <my_dir.h>
#include <hash.h>
30
#include "rpl_filter.h"
31
#ifdef  __WIN__
unknown's avatar
unknown committed
32 33 34
#include <io.h>
#endif

35 36
#define FLAGSTR(S,F) ((S) & (F) ? #F " " : "")

37 38 39 40 41 42 43 44 45 46 47 48 49 50
/**
  This internal handler is used to trap internally
  errors that can occur when executing open table
  during the prelocking phase.
*/
class Prelock_error_handler : public Internal_error_handler
{
public:
  Prelock_error_handler()
    : m_handled_errors(0), m_unhandled_errors(0)
  {}

  virtual ~Prelock_error_handler() {}

Marc Alff's avatar
Marc Alff committed
51 52 53 54 55 56
  virtual bool handle_condition(THD *thd,
                                uint sql_errno,
                                const char* sqlstate,
                                MYSQL_ERROR::enum_warning_level level,
                                const char* msg,
                                MYSQL_ERROR ** cond_hdl);
57 58 59 60 61 62 63 64 65 66

  bool safely_trapped_errors();

private:
  int m_handled_errors;
  int m_unhandled_errors;
};


bool
Marc Alff's avatar
Marc Alff committed
67 68 69 70 71 72 73 74
Prelock_error_handler::handle_condition(THD *,
                                        uint sql_errno,
                                        const char*,
                                        MYSQL_ERROR::enum_warning_level,
                                        const char*,
                                        MYSQL_ERROR ** cond_hdl)
{
  *cond_hdl= NULL;
75 76 77
  if (sql_errno == ER_NO_SUCH_TABLE)
  {
    m_handled_errors++;
unknown's avatar
unknown committed
78
    return TRUE;
79 80 81
  }

  m_unhandled_errors++;
unknown's avatar
unknown committed
82
  return FALSE;
83 84 85 86 87 88 89 90 91 92 93 94 95
}


bool Prelock_error_handler::safely_trapped_errors()
{
  /*
    If m_unhandled_errors != 0, something else, unanticipated, happened,
    so the error is not trapped but returned to the caller.
    Multiple ER_NO_SUCH_TABLE can be raised in case of views.
  */
  return ((m_handled_errors > 0) && (m_unhandled_errors == 0));
}

96 97 98 99
/**
  @defgroup Data_Dictionary Data Dictionary
  @{
*/
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114

/**
   Total number of TABLE instances for tables in the table definition cache
   (both in use by threads and not in use). This value is accessible to user
   as "Open_tables" status variable.
*/
uint  table_cache_count= 0;
/**
   List that contains all TABLE instances for tables in the table definition
   cache that are not in use by any thread. Recently used TABLE instances are
   appended to the end of the list. Thus the beginning of the list contains
   tables which have been least recently used.
*/
TABLE *unused_tables;
HASH table_def_cache;
unknown's avatar
unknown committed
115 116
static TABLE_SHARE *oldest_unused_share, end_of_unused_share;
static bool table_def_inited= 0;
Konstantin Osipov's avatar
Konstantin Osipov committed
117
static bool table_def_shutdown_in_progress= 0;
unknown's avatar
unknown committed
118

119 120 121 122
static bool check_and_update_table_version(THD *thd, TABLE_LIST *tables,
                                           TABLE_SHARE *table_share);
static bool open_table_entry_fini(THD *thd, TABLE_SHARE *share, TABLE *entry);
static bool auto_repair_table(THD *thd, TABLE_LIST *table_list);
unknown's avatar
unknown committed
123
static void free_cache_entry(TABLE *entry);
unknown's avatar
unknown committed
124
static bool open_new_frm(THD *thd, TABLE_SHARE *share, const char *alias,
125 126 127
                         uint db_stat, uint prgflag,
                         uint ha_open_flags, TABLE *outparam,
                         TABLE_LIST *table_desc, MEM_ROOT *mem_root);
Konstantin Osipov's avatar
Konstantin Osipov committed
128 129
static bool tdc_wait_for_old_versions(THD *thd,
                                      MDL_request_list *mdl_requests);
unknown's avatar
unknown committed
130
static bool
131
has_write_table_with_auto_increment(TABLE_LIST *tables);
unknown's avatar
unknown committed
132

133 134
TABLE *find_table_for_mdl_upgrade(TABLE *list, const char *db,
                                  const char *table_name);
unknown's avatar
unknown committed
135

unknown's avatar
unknown committed
136
uint cached_open_tables(void)
unknown's avatar
unknown committed
137
{
138
  return table_cache_count;
unknown's avatar
unknown committed
139 140
}

unknown's avatar
unknown committed
141

unknown's avatar
unknown committed
142 143 144
#ifdef EXTRA_DEBUG
static void check_unused(void)
{
unknown's avatar
unknown committed
145
  uint count= 0, open_files= 0, idx= 0;
146 147
  TABLE *cur_link, *start_link, *entry;
  TABLE_SHARE *share;
unknown's avatar
unknown committed
148 149 150 151 152 153 154 155 156 157

  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 */
      }
158
    } while (count++ < table_cache_count &&
unknown's avatar
unknown committed
159 160 161 162 163 164
	     (cur_link=cur_link->next) != start_link);
    if (cur_link != start_link)
    {
      DBUG_PRINT("error",("Unused_links aren't connected")); /* purecov: inspected */
    }
  }
165
  for (idx=0 ; idx < table_def_cache.records ; idx++)
unknown's avatar
unknown committed
166
  {
167 168 169 170 171
    share= (TABLE_SHARE*) my_hash_element(&table_def_cache, idx);

    I_P_List_iterator<TABLE, TABLE_share> it(share->free_tables);
    while ((entry= it++))
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
172 173 174 175 176
      /* We must not have TABLEs in the free list that have their file closed. */
      DBUG_ASSERT(entry->db_stat && entry->file);
      /* Merge children should be detached from a merge parent */
      DBUG_ASSERT(! entry->file->extra(HA_EXTRA_IS_ATTACHED_CHILDREN));

177 178 179 180
      if (entry->in_use)
      {
        DBUG_PRINT("error",("Used table is in share's list of unused tables")); /* purecov: inspected */
      }
unknown's avatar
unknown committed
181
      count--;
unknown's avatar
unknown committed
182
      open_files++;
183 184 185 186 187 188 189 190 191 192
    }
    it.init(share->used_tables);
    while ((entry= it++))
    {
      if (!entry->in_use)
      {
        DBUG_PRINT("error",("Unused table is in share's list of used tables")); /* purecov: inspected */
      }
      open_files++;
    }
unknown's avatar
unknown committed
193 194 195
  }
  if (count != 0)
  {
196
    DBUG_PRINT("error",("Unused_links doesn't match open_cache: diff: %d", /* purecov: inspected */
unknown's avatar
unknown committed
197 198 199 200 201 202 203
			count)); /* purecov: inspected */
  }
}
#else
#define check_unused()
#endif

unknown's avatar
unknown committed
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229

/*
  Create a table cache key

  SYNOPSIS
    create_table_def_key()
    thd			Thread handler
    key			Create key here (must be of size MAX_DBKEY_LENGTH)
    table_list		Table definition
    tmp_table		Set if table is a tmp table

 IMPLEMENTATION
    The table cache_key is created from:
    db_name + \0
    table_name + \0

    if the table is a tmp table, we add the following to make each tmp table
    unique on the slave:

    4 bytes for master thread id
    4 bytes pseudo thread id

  RETURN
    Length of key
*/

230
uint create_table_def_key(THD *thd, char *key, TABLE_LIST *table_list,
unknown's avatar
unknown committed
231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
                          bool tmp_table)
{
  uint key_length= (uint) (strmov(strmov(key, table_list->db)+1,
                                  table_list->table_name)-key)+1;
  if (tmp_table)
  {
    int4store(key + key_length, thd->server_id);
    int4store(key + key_length + 4, thd->variables.pseudo_thread_id);
    key_length+= TMP_TABLE_KEY_EXTRA;
  }
  return key_length;
}



/*****************************************************************************
  Functions to handle table definition cach (TABLE_SHARE)
*****************************************************************************/

250
extern "C" uchar *table_def_key(const uchar *record, size_t *length,
unknown's avatar
unknown committed
251 252 253 254
                               my_bool not_used __attribute__((unused)))
{
  TABLE_SHARE *entry=(TABLE_SHARE*) record;
  *length= entry->table_cache_key.length;
255
  return (uchar*) entry->table_cache_key.str;
unknown's avatar
unknown committed
256 257 258 259 260 261
}


static void table_def_free_entry(TABLE_SHARE *share)
{
  DBUG_ENTER("table_def_free_entry");
Konstantin Osipov's avatar
Konstantin Osipov committed
262
  safe_mutex_assert_owner(&LOCK_open);
unknown's avatar
unknown committed
263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
  if (share->prev)
  {
    /* remove from old_unused_share list */
    *share->prev= share->next;
    share->next->prev= share->prev;
  }
  free_table_share(share);
  DBUG_VOID_RETURN;
}


bool table_def_init(void)
{
  table_def_inited= 1;
  oldest_unused_share= &end_of_unused_share;
  end_of_unused_share.prev= &oldest_unused_share;

Konstantin Osipov's avatar
Konstantin Osipov committed
280 281 282
  return my_hash_init(&table_def_cache, &my_charset_bin, table_def_size,
                      0, 0, table_def_key,
                      (my_hash_free_key) table_def_free_entry, 0) != 0;
unknown's avatar
unknown committed
283 284 285
}


Konstantin Osipov's avatar
Konstantin Osipov committed
286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310
/**
  Notify table definition cache that process of shutting down server
  has started so it has to keep number of TABLE and TABLE_SHARE objects
  minimal in order to reduce number of references to pluggable engines.
*/

void table_def_start_shutdown(void)
{
  if (table_def_inited)
  {
    pthread_mutex_lock(&LOCK_open);
    /* Free all cached but unused TABLEs and TABLE_SHAREs first. */
    close_cached_tables(NULL, NULL, TRUE, FALSE);
    /*
      Ensure that TABLE and TABLE_SHARE objects which are created for
      tables that are open during process of plugins' shutdown are
      immediately released. This keeps number of references to engine
      plugins minimal and allows shutdown to proceed smoothly.
    */
    table_def_shutdown_in_progress= TRUE;
    pthread_mutex_unlock(&LOCK_open);
  }
}


unknown's avatar
unknown committed
311 312 313 314 315 316
void table_def_free(void)
{
  DBUG_ENTER("table_def_free");
  if (table_def_inited)
  {
    table_def_inited= 0;
317
    /* Free table definitions. */
Konstantin Osipov's avatar
Konstantin Osipov committed
318
    my_hash_free(&table_def_cache);
unknown's avatar
unknown committed
319 320 321 322 323 324 325 326 327 328 329
  }
  DBUG_VOID_RETURN;
}


uint cached_table_definitions(void)
{
  return table_def_cache.records;
}


330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
/*
  Auxiliary routines for manipulating with per-share used/unused and
  global unused lists of TABLE objects and table_cache_count counter.
  Responsible for preserving invariants between those lists, counter
  and TABLE::in_use member.
  In fact those routines implement sort of implicit table cache as
  part of table definition cache.
*/


/**
   Add newly created TABLE object for table share which is going
   to be used right away.
*/

static void table_def_add_used_table(THD *thd, TABLE *table)
{
  DBUG_ASSERT(table->in_use == thd);
  table->s->used_tables.push_front(table);
  table_cache_count++;
}


/**
   Prepare used or unused TABLE instance for destruction by removing
   it from share's and global list.
*/

static void table_def_remove_table(TABLE *table)
{
  if (table->in_use)
  {
    /* Remove from per-share chain of used TABLE objects. */
    table->s->used_tables.remove(table);
  }
  else
  {
    /* Remove from per-share chain of unused TABLE objects. */
    table->s->free_tables.remove(table);

    /* And global unused chain. */
    table->next->prev=table->prev;
    table->prev->next=table->next;
    if (table == unused_tables)
    {
      unused_tables=unused_tables->next;
      if (table == unused_tables)
	unused_tables=0;
    }
    check_unused();
  }
  table_cache_count--;
}


/**
   Mark already existing TABLE instance as used.
*/

static void table_def_use_table(THD *thd, TABLE *table)
{
  DBUG_ASSERT(!table->in_use);

  /* Unlink table from list of unused tables for this share. */
  table->s->free_tables.remove(table);
  /* Unlink able from global unused tables list. */
  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;
  check_unused();
  /* Add table to list of used tables for this share. */
  table->s->used_tables.push_front(table);
  table->in_use= thd;
Konstantin Osipov's avatar
Konstantin Osipov committed
408 409 410 411
  /* The ex-unused table must be fully functional. */
  DBUG_ASSERT(table->db_stat && table->file);
  /* The children must be detached from the table. */
  DBUG_ASSERT(! table->file->extra(HA_EXTRA_IS_ATTACHED_CHILDREN));
412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441
}


/**
   Mark already existing used TABLE instance as unused.
*/

static void table_def_unuse_table(TABLE *table)
{
  DBUG_ASSERT(table->in_use);

  table->in_use= 0;
  /* Remove table from the list of tables used in this share. */
  table->s->used_tables.remove(table);
  /* Add table to the list of unused TABLE objects for this share. */
  table->s->free_tables.push_front(table);
  /* Also link it last in the global list of unused TABLE objects. */
  if (unused_tables)
  {
    table->next=unused_tables;
    table->prev=unused_tables->prev;
    unused_tables->prev=table;
    table->prev->next=table;
  }
  else
    unused_tables=table->next=table->prev=table;
  check_unused();
}


unknown's avatar
unknown committed
442 443 444 445
/*
  Get TABLE_SHARE for a table.

  get_table_share()
446
  thd			Thread handle
unknown's avatar
unknown committed
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466
  table_list		Table that should be opened
  key			Table cache key
  key_length		Length of key
  db_flags		Flags to open_table_def():
			OPEN_VIEW
  error			out: Error code from open_table_def()

  IMPLEMENTATION
    Get a table definition from the table definition cache.
    If it doesn't exist, create a new from the table definition file.

  NOTES
    We must have wrlock on LOCK_open when we come here
    (To be changed later)

  RETURN
   0  Error
   #  Share for table
*/

467
TABLE_SHARE *get_table_share(THD *thd, TABLE_LIST *table_list, char *key,
unknown's avatar
unknown committed
468 469 470 471 472 473 474
                             uint key_length, uint db_flags, int *error)
{
  TABLE_SHARE *share;
  DBUG_ENTER("get_table_share");

  *error= 0;

475 476 477 478
  /*
    To be able perform any operation on table we should own
    some kind of metadata lock on it.
  */
479
  DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_TABLE, table_list->db,
Konstantin Osipov's avatar
Konstantin Osipov committed
480
                                             table_list->table_name));
481

unknown's avatar
unknown committed
482
  /* Read table definition from cache */
Konstantin Osipov's avatar
Konstantin Osipov committed
483 484
  if ((share= (TABLE_SHARE*) my_hash_search(&table_def_cache,(uchar*) key,
                                            key_length)))
unknown's avatar
unknown committed
485 486 487 488 489 490 491
    goto found;

  if (!(share= alloc_table_share(table_list, key, key_length)))
  {
    DBUG_RETURN(0);
  }

492 493 494 495 496 497 498 499 500 501 502 503 504 505 506
  /*
    We assign a new table id under the protection of the LOCK_open and
    the share's own mutex.  We do this insted of creating a new mutex
    and using it for the sole purpose of serializing accesses to a
    static variable, we assign the table id here.  We assign it to the
    share before inserting it into the table_def_cache to be really
    sure that it cannot be read from the cache without having a table
    id assigned.

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

507
  if (my_hash_insert(&table_def_cache, (uchar*) share))
unknown's avatar
unknown committed
508 509 510 511 512 513 514
  {
    free_table_share(share);
    DBUG_RETURN(0);				// return error
  }
  if (open_table_def(thd, share, db_flags))
  {
    *error= share->error;
Konstantin Osipov's avatar
Konstantin Osipov committed
515
    (void) my_hash_delete(&table_def_cache, (uchar*) share);
unknown's avatar
unknown committed
516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
    DBUG_RETURN(0);
  }
  share->ref_count++;				// Mark in use
  DBUG_PRINT("exit", ("share: 0x%lx  ref_count: %u",
                      (ulong) share, share->ref_count));
  DBUG_RETURN(share);

found:
  /* 
     We found an existing table definition. Return it if we didn't get
     an error when reading the table definition from file.
  */
  if (share->error)
  {
    /* Table definition contained an error */
    open_table_error(share, share->error, share->open_errno, share->errarg);
    DBUG_RETURN(0);
  }
  if (share->is_view && !(db_flags & OPEN_VIEW))
  {
    open_table_error(share, 1, ENOENT, 0);
    DBUG_RETURN(0);
  }

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

   /* Free cache if too big */
  while (table_def_cache.records > table_def_size &&
         oldest_unused_share->next)
Konstantin Osipov's avatar
Konstantin Osipov committed
556
    my_hash_delete(&table_def_cache, (uchar*) oldest_unused_share);
unknown's avatar
unknown committed
557 558 559 560 561 562 563 564 565 566 567 568 569 570 571

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


/*
  Get a table share. If it didn't exist, try creating it from engine

  For arguments and return values, see get_table_from_share()
*/

static TABLE_SHARE
*get_table_share_with_create(THD *thd, TABLE_LIST *table_list,
572
                             char *key, uint key_length,
unknown's avatar
unknown committed
573 574 575 576 577 578
                             uint db_flags, int *error)
{
  TABLE_SHARE *share;
  int tmp;
  DBUG_ENTER("get_table_share_with_create");

579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598
  share= get_table_share(thd, table_list, key, key_length, db_flags, error);
  /*
    If share is not NULL, we found an existing share.

    If share is NULL, and there is no error, we're inside
    pre-locking, which silences 'ER_NO_SUCH_TABLE' errors
    with the intention to silently drop non-existing tables 
    from the pre-locking list. In this case we still need to try
    auto-discover before returning a NULL share.

    If share is NULL and the error is ER_NO_SUCH_TABLE, this is
    the same as above, only that the error was not silenced by 
    pre-locking. Once again, we need to try to auto-discover
    the share.

    Finally, if share is still NULL, it's a real error and we need
    to abort.

    @todo Rework alternative ways to deal with ER_NO_SUCH TABLE.
  */
Marc Alff's avatar
Marc Alff committed
599
  if (share || (thd->is_error() && thd->stmt_da->sql_errno() != ER_NO_SUCH_TABLE))
600

unknown's avatar
unknown committed
601 602 603
    DBUG_RETURN(share);

  /* Table didn't exist. Check if some engine can provide it */
Staale Smedseng's avatar
Staale Smedseng committed
604 605 606
  tmp= ha_create_table_from_engine(thd, table_list->db,
                                   table_list->table_name);
  if (tmp < 0)
unknown's avatar
unknown committed
607 608 609
  {
    /*
      No such table in any engine.
610 611 612 613 614
      Hide "Table doesn't exist" errors if the table belongs to a view.
      The check for thd->is_error() is necessary to not push an
      unwanted error in case of pre-locking, which silences
      "no such table" errors.
      @todo Rework the alternative ways to deal with ER_NO_SUCH TABLE.
unknown's avatar
unknown committed
615
    */
616
    if (thd->is_error())
unknown's avatar
unknown committed
617
    {
618 619 620 621 622 623 624 625 626 627 628 629
      if (table_list->parent_l)
      {
        thd->clear_error();
        my_error(ER_WRONG_MRG_TABLE, MYF(0));
      }
      else if (table_list->belong_to_view)
      {
        TABLE_LIST *view= table_list->belong_to_view;
        thd->clear_error();
        my_error(ER_VIEW_INVALID, MYF(0),
                 view->view_db.str, view->view_name.str);
      }
unknown's avatar
unknown committed
630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645
    }
    DBUG_RETURN(0);
  }
  if (tmp)
  {
    /* Give right error message */
    thd->clear_error();
    DBUG_PRINT("error", ("Discovery of %s/%s failed", table_list->db,
                         table_list->table_name));
    my_printf_error(ER_UNKNOWN_ERROR,
                    "Failed to open '%-.64s', error while "
                    "unpacking from engine",
                    MYF(0), table_list->table_name);
    DBUG_RETURN(0);
  }
  /* Table existed in engine. Let's open it */
Marc Alff's avatar
Marc Alff committed
646
  thd->warning_info->clear_warning_info(thd->query_id);
unknown's avatar
unknown committed
647 648 649 650 651
  thd->clear_error();                           // Clear error message
  DBUG_RETURN(get_table_share(thd, table_list, key, key_length,
                              db_flags, error));
}

Konstantin Osipov's avatar
Konstantin Osipov committed
652 653
/**
  Mark that we are not using table share anymore.
unknown's avatar
unknown committed
654

Konstantin Osipov's avatar
Konstantin Osipov committed
655
  @param  share   Table share
unknown's avatar
unknown committed
656

Konstantin Osipov's avatar
Konstantin Osipov committed
657 658 659
  If the share has no open tables and (we have done a refresh or
  if we have already too many open table shares) then delete the
  definition.
unknown's avatar
unknown committed
660 661
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
662
void release_table_share(TABLE_SHARE *share)
unknown's avatar
unknown committed
663 664 665 666 667 668 669 670 671 672
{
  bool to_be_deleted= 0;
  DBUG_ENTER("release_table_share");
  DBUG_PRINT("enter",
             ("share: 0x%lx  table: %s.%s  ref_count: %u  version: %lu",
              (ulong) share, share->db.str, share->table_name.str,
              share->ref_count, share->version));

  safe_mutex_assert_owner(&LOCK_open);

673
  DBUG_ASSERT(share->ref_count);
unknown's avatar
unknown committed
674 675
  if (!--share->ref_count)
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
676 677
    if (share->version != refresh_version ||
        table_def_shutdown_in_progress)
unknown's avatar
unknown committed
678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696
      to_be_deleted=1;
    else
    {
      /* Link share last in used_table_share list */
      DBUG_PRINT("info",("moving share to unused list"));

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

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

  if (to_be_deleted)
  {
    DBUG_PRINT("info", ("Deleting share"));
Konstantin Osipov's avatar
Konstantin Osipov committed
697
    my_hash_delete(&table_def_cache, (uchar*) share);
unknown's avatar
unknown committed
698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717
  }
  DBUG_VOID_RETURN;
}


/*
  Check if table definition exits in cache

  SYNOPSIS
    get_cached_table_share()
    db			Database name
    table_name		Table name

  RETURN
    0  Not cached
    #  TABLE_SHARE for table
*/

TABLE_SHARE *get_cached_table_share(const char *db, const char *table_name)
{
718
  char key[NAME_LEN*2+2];
unknown's avatar
unknown committed
719 720 721 722 723 724 725
  TABLE_LIST table_list;
  uint key_length;
  safe_mutex_assert_owner(&LOCK_open);

  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
  key_length= create_table_def_key((THD*) 0, key, &table_list, 0);
Konstantin Osipov's avatar
Konstantin Osipov committed
726 727
  return (TABLE_SHARE*) my_hash_search(&table_def_cache,
                                       (uchar*) key, key_length);
unknown's avatar
unknown committed
728 729 730
}  


731 732 733 734 735 736 737 738 739 740 741
/**
   @brief Mark table share as having one more user (increase its reference
          count).

   @param share Table share for which reference count should be increased.
*/

static void reference_table_share(TABLE_SHARE *share)
{
  DBUG_ENTER("reference_table_share");
  DBUG_ASSERT(share->ref_count);
Konstantin Osipov's avatar
Konstantin Osipov committed
742
  safe_mutex_assert_owner(&LOCK_open);
743 744 745 746 747 748 749
  share->ref_count++;
  DBUG_PRINT("exit", ("share: 0x%lx  ref_count: %u",
                     (ulong) share, share->ref_count));
  DBUG_VOID_RETURN;
}


unknown's avatar
unknown committed
750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767
/*
  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.
*/

768
OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *db, const char *wild)
769 770
{
  int result = 0;
771
  OPEN_TABLE_LIST **start_list, *open_list;
772 773
  TABLE_LIST table_list;
  DBUG_ENTER("list_open_tables");
774

Konstantin Osipov's avatar
Konstantin Osipov committed
775
  pthread_mutex_lock(&LOCK_open);
776
  bzero((char*) &table_list,sizeof(table_list));
777 778
  start_list= &open_list;
  open_list=0;
779

780
  for (uint idx=0 ; result == 0 && idx < table_def_cache.records; idx++)
781
  {
782
    TABLE_SHARE *share= (TABLE_SHARE *)my_hash_element(&table_def_cache, idx);
783

unknown's avatar
unknown committed
784
    if (db && my_strcasecmp(system_charset_info, db, share->db.str))
785
      continue;
unknown's avatar
unknown committed
786
    if (wild && wild_compare(share->table_name.str, wild, 0))
787
      continue;
788

789
    /* Check if user has SELECT privilege for any column in the table */
unknown's avatar
unknown committed
790 791
    table_list.db=         share->db.str;
    table_list.table_name= share->table_name.str;
792
    table_list.grant.privilege=0;
unknown's avatar
unknown committed
793

794
    if (check_table_access(thd,SELECT_ACL,&table_list, TRUE, 1, TRUE))
795
      continue;
796

797
    if (!(*start_list = (OPEN_TABLE_LIST *)
unknown's avatar
unknown committed
798
	  sql_alloc(sizeof(**start_list)+share->table_cache_key.length)))
799
    {
800
      open_list=0;				// Out of memory
801
      break;
802
    }
803 804
    strmov((*start_list)->table=
	   strmov(((*start_list)->db= (char*) ((*start_list)+1)),
unknown's avatar
unknown committed
805 806
		  share->db.str)+1,
	   share->table_name.str);
807 808 809 810 811
    (*start_list)->in_use= 0;
    I_P_List_iterator<TABLE, TABLE_share> it(share->used_tables);
    while (it++)
      ++(*start_list)->in_use;
    (*start_list)->locked= (share->version == 0) ? 1 : 0;
812
    start_list= &(*start_list)->next;
813
    *start_list=0;
814
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
815
  pthread_mutex_unlock(&LOCK_open);
816
  DBUG_RETURN(open_list);
817
}
unknown's avatar
unknown committed
818 819 820 821 822 823 824 825

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


void intern_close_table(TABLE *table)
{						// Free all structures
unknown's avatar
unknown committed
826
  DBUG_ENTER("intern_close_table");
827 828 829 830
  DBUG_PRINT("tcache", ("table: '%s'.'%s' 0x%lx",
                        table->s ? table->s->db.str : "?",
                        table->s ? table->s->table_name.str : "?",
                        (long) table));
unknown's avatar
unknown committed
831

unknown's avatar
unknown committed
832
  free_io_cache(table);
833
  delete table->triggers;
Konstantin Osipov's avatar
Konstantin Osipov committed
834
  if (table->file)                              // Not true if placeholder
Konstantin Osipov's avatar
Konstantin Osipov committed
835
    (void) closefrm(table, 1);			// close file
unknown's avatar
unknown committed
836
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
837 838
}

839 840 841 842 843 844 845 846 847 848
/*
  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
*/
unknown's avatar
unknown committed
849 850 851 852 853

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

854 855 856
  /* This should be done before releasing table share. */
  table_def_remove_table(table);

unknown's avatar
unknown committed
857
  intern_close_table(table);
858

859
  my_free((uchar*) table,MYF(0));
unknown's avatar
unknown committed
860 861 862
  DBUG_VOID_RETURN;
}

863
/* Free resources allocated by filesort() and read_record() */
unknown's avatar
unknown committed
864 865 866

void free_io_cache(TABLE *table)
{
867
  DBUG_ENTER("free_io_cache");
unknown's avatar
unknown committed
868
  if (table->sort.io_cache)
unknown's avatar
unknown committed
869
  {
unknown's avatar
unknown committed
870
    close_cached_file(table->sort.io_cache);
871
    my_free((uchar*) table->sort.io_cache,MYF(0));
unknown's avatar
unknown committed
872
    table->sort.io_cache=0;
unknown's avatar
unknown committed
873
  }
874
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
875 876
}

877

878 879 880 881 882
/**
   Auxiliary function which allows to kill delayed threads for
   particular table identified by its share.

   @param share Table share.
Konstantin Osipov's avatar
Konstantin Osipov committed
883 884

   @pre Caller should have LOCK_open mutex acquired.
885 886 887 888 889 890
*/

static void kill_delayed_threads_for_table(TABLE_SHARE *share)
{
  I_P_List_iterator<TABLE, TABLE_share> it(share->used_tables);
  TABLE *tab;
Konstantin Osipov's avatar
Konstantin Osipov committed
891 892 893

  safe_mutex_assert_owner(&LOCK_open);

894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914
  while ((tab= it++))
  {
    THD *in_use= tab->in_use;

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


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

918 919 920 921 922
  @param thd Thread context
  @param tables List of tables to remove from the cache
  @param have_lock If LOCK_open is locked
  @param wait_for_refresh Wait for a impending flush

923 924 925 926 927 928 929 930 931
  @note THD can be NULL, but then wait_for_refresh must be FALSE
        and tables must be NULL.

  @note When called as part of FLUSH TABLES WITH READ LOCK this function
        ignores metadata locks held by other threads. In order to avoid
        situation when FLUSH TABLES WITH READ LOCK sneaks in at the moment
        when some write-locked table is being reopened (by FLUSH TABLES or
        ALTER TABLE) we have to rely on additional global shared metadata
        lock taken by thread trying to obtain global read lock.
932
*/
unknown's avatar
unknown committed
933

934
bool close_cached_tables(THD *thd, TABLE_LIST *tables, bool have_lock,
935
                         bool wait_for_refresh)
unknown's avatar
unknown committed
936
{
937 938
  bool result= FALSE;
  bool found= TRUE;
unknown's avatar
unknown committed
939
  DBUG_ENTER("close_cached_tables");
940
  DBUG_ASSERT(thd || (!wait_for_refresh && !tables));
unknown's avatar
unknown committed
941

unknown's avatar
unknown committed
942
  if (!have_lock)
Konstantin Osipov's avatar
Konstantin Osipov committed
943
    pthread_mutex_lock(&LOCK_open);
unknown's avatar
unknown committed
944
  if (!tables)
unknown's avatar
unknown committed
945
  {
unknown's avatar
unknown committed
946
    refresh_version++;				// Force close of open tables
947 948
    DBUG_PRINT("tcache", ("incremented global refresh_version to: %lu",
                          refresh_version));
949
    kill_delayed_threads();
Konstantin Osipov's avatar
Konstantin Osipov committed
950 951 952 953 954 955 956 957 958
    /*
      Get rid of all unused TABLE and TABLE_SHARE instances. By doing
      this we automatically close all tables which were marked as "old".
    */
    while (unused_tables)
      free_cache_entry(unused_tables);
    /* Free table shares which were not freed implicitly by loop above. */
    while (oldest_unused_share->next)
      (void) my_hash_delete(&table_def_cache, (uchar*) oldest_unused_share);
unknown's avatar
unknown committed
959
  }
unknown's avatar
unknown committed
960
  else
unknown's avatar
unknown committed
961
  {
unknown's avatar
unknown committed
962
    bool found=0;
unknown's avatar
VIEW  
unknown committed
963
    for (TABLE_LIST *table= tables; table; table= table->next_local)
unknown's avatar
unknown committed
964
    {
965 966 967 968 969
      TABLE_SHARE *share= get_cached_table_share(table->db, table->table_name);

      if (share)
      {
        kill_delayed_threads_for_table(share);
Konstantin Osipov's avatar
Konstantin Osipov committed
970 971 972
        /* tdc_remove_table() also sets TABLE_SHARE::version to 0. */
        tdc_remove_table(thd, TDC_RT_REMOVE_UNUSED, table->db,
                         table->table_name);
unknown's avatar
unknown committed
973
	found=1;
974
      }
unknown's avatar
unknown committed
975 976
    }
    if (!found)
977
      wait_for_refresh=0;			// Nothing to wait for
unknown's avatar
unknown committed
978
  }
979

Konstantin Osipov's avatar
Konstantin Osipov committed
980 981
  if (!have_lock)
    pthread_mutex_unlock(&LOCK_open);
982 983 984 985

  if (!wait_for_refresh)
    DBUG_RETURN(result);

Konstantin Osipov's avatar
Konstantin Osipov committed
986
  /* Code below assume that LOCK_open is released. */
987 988
  DBUG_ASSERT(!have_lock);

Konstantin Osipov's avatar
Konstantin Osipov committed
989
  if (thd->locked_tables_mode)
unknown's avatar
unknown committed
990 991
  {
    /*
Konstantin Osipov's avatar
Konstantin Osipov committed
992
      If we are under LOCK TABLES, we need to reopen the tables without
993 994 995
      opening a door for any concurrent threads to sneak in and get
      lock on our tables. To achieve this we use exclusive metadata
      locks.
unknown's avatar
unknown committed
996
    */
Konstantin Osipov's avatar
Konstantin Osipov committed
997 998 999 1000 1001
    TABLE_LIST *tables_to_reopen= (tables ? tables :
                                  thd->locked_tables_list.locked_tables());

    for (TABLE_LIST *table_list= tables_to_reopen; table_list;
         table_list= table_list->next_global)
1002
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
1003
      /* A check that the table was locked for write is done by the caller. */
1004 1005
      TABLE *table= find_table_for_mdl_upgrade(thd->open_tables, table_list->db,
                                               table_list->table_name);
Konstantin Osipov's avatar
Konstantin Osipov committed
1006 1007 1008 1009 1010 1011

      /* May return NULL if this table has already been closed via an alias. */
      if (! table)
        continue;

      if (wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN))
1012
      {
Konstantin Osipov's avatar
Konstantin Osipov committed
1013 1014
        result= TRUE;
        goto err_with_reopen;
1015
      }
Konstantin Osipov's avatar
Konstantin Osipov committed
1016
      close_all_tables_for_name(thd, table->s, FALSE);
1017 1018 1019 1020 1021
    }
  }

  /* Wait until all threads have closed all the tables we are flushing. */
  DBUG_PRINT("info", ("Waiting for other threads to close their open tables"));
unknown's avatar
unknown committed
1022

1023 1024 1025 1026 1027 1028
  while (found && ! thd->killed)
  {
    found= FALSE;
    /*
      To avoid self and other kinds of deadlock we have to flush open HANDLERs.
    */
1029
    mysql_ha_flush(thd);
1030
    DEBUG_SYNC(thd, "after_flush_unlock");
1031

1032 1033 1034 1035 1036
    pthread_mutex_lock(&LOCK_open);

    thd->enter_cond(&COND_refresh, &LOCK_open, "Flushing tables");

    if (!tables)
unknown's avatar
unknown committed
1037
    {
1038
      for (uint idx=0 ; idx < table_def_cache.records ; idx++)
unknown's avatar
unknown committed
1039
      {
1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
        TABLE_SHARE *share=(TABLE_SHARE*) my_hash_element(&table_def_cache,
                                                          idx);
        if (share->version != refresh_version)
        {
          found= TRUE;
          break;
        }
      }
    }
    else
    {
      for (TABLE_LIST *table= tables; table; table= table->next_local)
      {
        TABLE_SHARE *share= get_cached_table_share(table->db, table->table_name);
        if (share && share->version != refresh_version)
        {
	  found= TRUE;
          break;
        }
unknown's avatar
unknown committed
1059 1060
      }
    }
1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071

    if (found)
    {
      DBUG_PRINT("signal", ("Waiting for COND_refresh"));
      pthread_cond_wait(&COND_refresh,&LOCK_open);
    }

    thd->exit_cond(NULL);
  }

err_with_reopen:
Konstantin Osipov's avatar
Konstantin Osipov committed
1072
  if (thd->locked_tables_mode)
1073
  {
unknown's avatar
unknown committed
1074 1075 1076 1077 1078
    /*
      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)
    */
Konstantin Osipov's avatar
Konstantin Osipov committed
1079
    thd->locked_tables_list.reopen_tables(thd);
Konstantin Osipov's avatar
Konstantin Osipov committed
1080
    /*
Konstantin Osipov's avatar
Konstantin Osipov committed
1081 1082
      Since downgrade_exclusive_lock() won't do anything with shared
      metadata lock it is much simpler to go through all open tables rather
Konstantin Osipov's avatar
Konstantin Osipov committed
1083 1084 1085
      than picking only those tables that were flushed.
    */
    for (TABLE *tab= thd->open_tables; tab; tab= tab->next)
Konstantin Osipov's avatar
Konstantin Osipov committed
1086
      tab->mdl_ticket->downgrade_exclusive_lock();
unknown's avatar
unknown committed
1087 1088 1089 1090 1091
  }
  DBUG_RETURN(result);
}


1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106
/*
  Close all tables which match specified connection string or
  if specified string is NULL, then any table with a connection string.
*/

bool close_cached_connection_tables(THD *thd, bool if_wait_for_refresh,
                                    LEX_STRING *connection, bool have_lock)
{
  uint idx;
  TABLE_LIST tmp, *tables= NULL;
  bool result= FALSE;
  DBUG_ENTER("close_cached_connections");
  DBUG_ASSERT(thd);

  bzero(&tmp, sizeof(TABLE_LIST));
1107

1108
  if (!have_lock)
Konstantin Osipov's avatar
Konstantin Osipov committed
1109
    pthread_mutex_lock(&LOCK_open);
1110

1111 1112
  for (idx= 0; idx < table_def_cache.records; idx++)
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
1113
    TABLE_SHARE *share= (TABLE_SHARE *) my_hash_element(&table_def_cache, idx);
1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138

    /* Ignore if table is not open or does not have a connect_string */
    if (!share->connect_string.length || !share->ref_count)
      continue;

    /* Compare the connection string */
    if (connection &&
        (connection->length > share->connect_string.length ||
         (connection->length < share->connect_string.length &&
          (share->connect_string.str[connection->length] != '/' &&
           share->connect_string.str[connection->length] != '\\')) ||
         strncasecmp(connection->str, share->connect_string.str,
                     connection->length)))
      continue;

    /* close_cached_tables() only uses these elements */
    tmp.db= share->db.str;
    tmp.table_name= share->table_name.str;
    tmp.next_local= tables;

    tables= (TABLE_LIST *) memdup_root(thd->mem_root, (char*)&tmp, 
                                       sizeof(TABLE_LIST));
  }

  if (tables)
1139
    result= close_cached_tables(thd, tables, TRUE, FALSE);
1140

1141
  if (!have_lock)
Konstantin Osipov's avatar
Konstantin Osipov committed
1142
    pthread_mutex_unlock(&LOCK_open);
1143

1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
  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);
}


1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174
/**
  Mark all temporary tables which were used by the current statement or
  substatement as free for reuse, but only if the query_id can be cleared.

  @param thd thread context

  @remark For temp tables associated with a open SQL HANDLER the query_id
          is not reset until the HANDLER is closed.
*/

static void mark_temp_tables_as_free_for_reuse(THD *thd)
{
  for (TABLE *table= thd->temporary_tables ; table ; table= table->next)
  {
    if ((table->query_id == thd->query_id) && ! table->open_by_handler)
    {
      table->query_id= 0;
      table->file->ha_reset();
Konstantin Osipov's avatar
Konstantin Osipov committed
1175 1176 1177 1178 1179

      /* Detach temporary MERGE children from temporary parent. */
      DBUG_ASSERT(table->file);
      table->file->extra(HA_EXTRA_DETACH_CHILDREN);

1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200
      /*
        Reset temporary table lock type to it's default value (TL_WRITE).

        Statements such as INSERT INTO .. SELECT FROM tmp, CREATE TABLE
        .. SELECT FROM tmp and UPDATE may under some circumstances modify
        the lock type of the tables participating in the statement. This
        isn't a problem for non-temporary tables since their lock type is
        reset at every open, but the same does not occur for temporary
        tables for historical reasons.

        Furthermore, the lock type of temporary tables is not really that
        important because they can only be used by one query at a time and
        not even twice in a query -- a temporary table is represented by
        only one TABLE object. Nonetheless, it's safer from a maintenance
        point of view to reset the lock type of this singleton TABLE object
        as to not cause problems when the table is reused.

        Even under LOCK TABLES mode its okay to reset the lock type as
        LOCK TABLES is allowed (but ignored) for a temporary table.
      */
      table->reginfo.lock_type= TL_WRITE;
1201 1202 1203 1204 1205
    }
  }
}


1206
/*
1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217
  Mark all tables in the list which were used by current substatement
  as free for reuse.

  SYNOPSIS
    mark_used_tables_as_free_for_reuse()
      thd   - thread context
      table - head of the list of tables

  DESCRIPTION
    Marks all tables in the list which were used by current substatement
    (they are marked by its query_id) as free for reuse.
1218 1219 1220 1221 1222 1223 1224 1225 1226

  NOTE
    The reason we reset query_id is that it's not enough to just test
    if table->query_id != thd->query_id to know if a table is in use.

    For example
    SELECT f1_that_uses_t1() FROM t1;
    In f1_that_uses_t1() we will see one instance of t1 where query_id is
    set to query_id of original query.
1227 1228 1229 1230 1231
*/

static void mark_used_tables_as_free_for_reuse(THD *thd, TABLE *table)
{
  for (; table ; table= table->next)
1232
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
1233 1234
    DBUG_ASSERT(table->pos_in_locked_tables == NULL ||
                table->pos_in_locked_tables->table == table);
1235
    if (table->query_id == thd->query_id)
1236
    {
1237
      table->query_id= 0;
1238 1239 1240
      table->file->ha_reset();
    }
  }
1241 1242 1243
}


1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257
/**
  Auxiliary function to close all tables in the open_tables list.

  @param thd Thread context.

  @remark It should not ordinarily be called directly.
*/

static void close_open_tables(THD *thd)
{
  bool found_old_table= 0;

  safe_mutex_assert_not_owner(&LOCK_open);

Konstantin Osipov's avatar
Konstantin Osipov committed
1258
  pthread_mutex_lock(&LOCK_open);
1259 1260 1261 1262 1263 1264 1265 1266

  DBUG_PRINT("info", ("thd->open_tables: 0x%lx", (long) thd->open_tables));

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

  /* Free tables to hold down open files */
1267 1268
  while (table_cache_count > table_cache_size && unused_tables)
    free_cache_entry(unused_tables);
1269 1270 1271 1272 1273 1274
  if (found_old_table)
  {
    /* Tell threads waiting for refresh that something has happened */
    broadcast_refresh();
  }

Konstantin Osipov's avatar
Konstantin Osipov committed
1275
  pthread_mutex_unlock(&LOCK_open);
1276 1277 1278
}


Konstantin Osipov's avatar
Konstantin Osipov committed
1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309
/**
  Close all open instances of the table but keep the MDL lock,
  if any.

  Works both under LOCK TABLES and in the normal mode.
  Removes all closed instances of the table from the table cache.

  @param     thd     thread handle
  @param[in] share   table share, but is just a handy way to
                     access the table cache key

  @param[in] remove_from_locked_tables
                     TRUE if the table is being dropped or renamed.
                     In that case the documented behaviour is to
                     implicitly remove the table from LOCK TABLES
                     list.
*/

void
close_all_tables_for_name(THD *thd, TABLE_SHARE *share,
                          bool remove_from_locked_tables)
{
  char key[MAX_DBKEY_LENGTH];
  uint key_length= share->table_cache_key.length;

  memcpy(key, share->table_cache_key.str, key_length);

  safe_mutex_assert_not_owner(&LOCK_open);
  /*
    We need to hold LOCK_open while changing the open_tables
    list, since another thread may work on it.
Konstantin Osipov's avatar
Konstantin Osipov committed
1310
    @sa mysql_notify_thread_having_shared_lock()
Konstantin Osipov's avatar
Konstantin Osipov committed
1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347
  */
  pthread_mutex_lock(&LOCK_open);

  for (TABLE **prev= &thd->open_tables; *prev; )
  {
    TABLE *table= *prev;

    if (table->s->table_cache_key.length == key_length &&
        !memcmp(table->s->table_cache_key.str, key, key_length))
    {
      /*
        Does nothing if the table is not locked.
        This allows one to use this function after a table
        has been unlocked, e.g. in partition management.
      */
      mysql_lock_remove(thd, thd->lock, table);

      thd->locked_tables_list.unlink_from_list(thd,
                                               table->pos_in_locked_tables,
                                               remove_from_locked_tables);

      /* Make sure the table is removed from the cache */
      table->s->version= 0;
      close_thread_table(thd, prev);
    }
    else
    {
      /* Step to next entry in open_tables list. */
      prev= &table->next;
    }
  }
  /* We have been removing tables from the table cache. */
  broadcast_refresh();
  pthread_mutex_unlock(&LOCK_open);
}


1348 1349 1350
/*
  Close all tables used by the current substatement, or all tables
  used by this thread if we are on the upper level.
unknown's avatar
unknown committed
1351

1352 1353 1354 1355 1356 1357 1358
  SYNOPSIS
    close_thread_tables()
    thd			Thread handler

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

1360 1361 1362 1363
    It will only close/mark as free for reuse tables opened by this
    substatement, it will also check if we are closing tables after
    execution of complete query (i.e. we are on upper level) and will
    leave prelocked mode if needed.
1364
*/
unknown's avatar
unknown committed
1365

Konstantin Osipov's avatar
Konstantin Osipov committed
1366
void close_thread_tables(THD *thd)
unknown's avatar
unknown committed
1367
{
1368
  TABLE *table;
unknown's avatar
unknown committed
1369 1370
  DBUG_ENTER("close_thread_tables");

1371 1372 1373 1374 1375 1376 1377
#ifdef EXTRA_DEBUG
  DBUG_PRINT("tcache", ("open tables:"));
  for (table= thd->open_tables; table; table= table->next)
    DBUG_PRINT("tcache", ("table: '%s'.'%s' 0x%lx", table->s->db.str,
                          table->s->table_name.str, (long) table));
#endif

Konstantin Osipov's avatar
Konstantin Osipov committed
1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391
  /* Detach MERGE children after every statement. Even under LOCK TABLES. */
  for (table= thd->open_tables; table; table= table->next)
  {
    /* Table might be in use by some outer statement. */
    DBUG_PRINT("tcache", ("table: '%s'  query_id: %lu",
                          table->s->table_name.str, (ulong) table->query_id));
    if (thd->locked_tables_mode <= LTM_LOCK_TABLES ||
        table->query_id == thd->query_id)
    {
      DBUG_ASSERT(table->file);
      table->file->extra(HA_EXTRA_DETACH_CHILDREN);
    }
  }

1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402
  /*
    We are assuming here that thd->derived_tables contains ONLY derived
    tables for this substatement. i.e. instead of approach which uses
    query_id matching for determining which of the derived tables belong
    to this substatement we rely on the ability of substatements to
    save/restore thd->derived_tables during their execution.

    TODO: Probably even better approach is to simply associate list of
          derived tables with (sub-)statement instead of thread and destroy
          them at the end of its execution.
  */
1403
  if (thd->derived_tables)
1404
  {
1405
    TABLE *next;
1406
    /*
1407 1408
      Close all derived tables generated in queries like
      SELECT * FROM (SELECT * FROM t1)
1409 1410 1411 1412 1413 1414 1415 1416
    */
    for (table= thd->derived_tables ; table ; table= next)
    {
      next= table->next;
      free_tmp_table(thd, table);
    }
    thd->derived_tables= 0;
  }
1417

1418 1419 1420 1421
  /*
    Mark all temporary tables used by this statement as free for reuse.
  */
  mark_temp_tables_as_free_for_reuse(thd);
1422 1423 1424 1425 1426 1427 1428 1429 1430
  /*
    Let us commit transaction for statement. Since in 5.0 we only have
    one statement transaction and don't allow several nested statement
    transactions this call will do nothing if we are inside of stored
    function or trigger (i.e. statement transaction is already active and
    does not belong to statement for which we do close_thread_tables()).
    TODO: This should be fixed in later releases.
   */
  if (!(thd->state_flags & Open_tables_state::BACKUPS_AVAIL))
1431
  {
Marc Alff's avatar
Marc Alff committed
1432
    thd->stmt_da->can_overwrite_status= TRUE;
Konstantin Osipov's avatar
Konstantin Osipov committed
1433
    thd->is_error() ? trans_rollback_stmt(thd) : trans_commit_stmt(thd);
Marc Alff's avatar
Marc Alff committed
1434
    thd->stmt_da->can_overwrite_status= FALSE;
1435

1436
    /*
1437 1438
      Reset transaction state, but only if we're not inside a
      sub-statement of a prelocked statement.
1439
    */
Konstantin Osipov's avatar
Konstantin Osipov committed
1440 1441
    if (thd->locked_tables_mode <= LTM_LOCK_TABLES ||
        thd->lex->requires_prelocking())
1442 1443 1444
      thd->transaction.stmt.reset();
  }

Konstantin Osipov's avatar
Konstantin Osipov committed
1445
  if (thd->locked_tables_mode)
1446
  {
1447

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

1451 1452 1453
    /*
      We are under simple LOCK TABLES or we're inside a sub-statement
      of a prelocked statement, so should not do anything else.
Konstantin Osipov's avatar
Konstantin Osipov committed
1454 1455 1456 1457 1458

      Note that even if we are in LTM_LOCK_TABLES mode and statement
      requires prelocking (e.g. when we are closing tables after
      failing ot "open" all tables required for statement execution)
      we will exit this function a few lines below.
1459
    */
Konstantin Osipov's avatar
Konstantin Osipov committed
1460
    if (! thd->lex->requires_prelocking())
1461 1462 1463
      DBUG_VOID_RETURN;

    /*
1464 1465 1466
      We are in the top-level statement of a prelocked statement,
      so we have to leave the prelocked mode now with doing implicit
      UNLOCK TABLES if needed.
1467
    */
Konstantin Osipov's avatar
Konstantin Osipov committed
1468 1469
    if (thd->locked_tables_mode == LTM_PRELOCKED_UNDER_LOCK_TABLES)
      thd->locked_tables_mode= LTM_LOCK_TABLES;
1470

Konstantin Osipov's avatar
Konstantin Osipov committed
1471
    if (thd->locked_tables_mode == LTM_LOCK_TABLES)
1472 1473
      DBUG_VOID_RETURN;

Konstantin Osipov's avatar
Konstantin Osipov committed
1474 1475
    thd->locked_tables_mode= LTM_NONE;

1476
    /* Fallthrough */
1477
  }
unknown's avatar
unknown committed
1478 1479 1480

  if (thd->lock)
  {
1481 1482 1483 1484 1485 1486 1487 1488 1489
    /*
      For RBR we flush the pending event just before we unlock all the
      tables.  This means that we are at the end of a topmost
      statement, so we ensure that the STMT_END_F flag is set on the
      pending event.  For statements that are *inside* stored
      functions, the pending event will not be flushed: that will be
      handled either before writing a query log event (inside
      binlog_query()) or when preparing a pending event.
     */
1490
    thd->binlog_flush_pending_rows_event(TRUE);
1491 1492
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;
unknown's avatar
unknown committed
1493
  }
1494 1495 1496
  /*
    Note that we need to hold LOCK_open while changing the
    open_tables list. Another thread may work on it.
Konstantin Osipov's avatar
Konstantin Osipov committed
1497
    (See: mysql_notify_thread_having_shared_lock())
1498 1499 1500
    Closing a MERGE child before the parent would be fatal if the
    other thread tries to abort the MERGE lock in between.
  */
1501 1502
  if (thd->open_tables)
    close_open_tables(thd);
1503

1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514
  /*
    Defer the release of metadata locks until the current transaction
    is either committed or rolled back. This prevents other statements
    from modifying the table for the entire duration of this transaction.
    This provides commitment ordering for guaranteeing serializability
    across multiple transactions.
  */
  if (!thd->in_multi_stmt_transaction() ||
      (thd->state_flags & Open_tables_state::BACKUPS_AVAIL))
    thd->mdl_context.release_all_locks();

unknown's avatar
unknown committed
1515 1516 1517
  DBUG_VOID_RETURN;
}

1518

1519 1520 1521 1522
/* move one table to free list */

bool close_thread_table(THD *thd, TABLE **table_ptr)
{
1523 1524
  bool found_old_table= 0;
  TABLE *table= *table_ptr;
1525
  DBUG_ENTER("close_thread_table");
1526
  DBUG_ASSERT(table->key_read == 0);
unknown's avatar
unknown committed
1527
  DBUG_ASSERT(!table->file || table->file->inited == handler::NONE);
1528
  safe_mutex_assert_owner(&LOCK_open);
1529 1530

  *table_ptr=table->next;
1531

Konstantin Osipov's avatar
Konstantin Osipov committed
1532
  table->mdl_ticket= NULL;
Konstantin Osipov's avatar
Konstantin Osipov committed
1533
  if (table->needs_reopen() ||
Konstantin Osipov's avatar
Konstantin Osipov committed
1534 1535
      thd->version != refresh_version || !table->db_stat ||
      table_def_shutdown_in_progress)
1536
  {
1537
    free_cache_entry(table);
1538 1539 1540 1541
    found_old_table=1;
  }
  else
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
1542 1543 1544
    /* Avoid to have MERGE tables with attached children in unused_tables. */
    DBUG_ASSERT(table->file);
    table->file->extra(HA_EXTRA_DETACH_CHILDREN);
1545

1546
    /* Free memory and reset for next loop */
1547 1548
    free_field_buffers_larger_than(table,MAX_TDC_BLOB_SIZE);
    
1549
    table->file->ha_reset();
1550
    table_def_unuse_table(table);
1551 1552 1553 1554
  }
  DBUG_RETURN(found_old_table);
}

unknown's avatar
unknown committed
1555

1556 1557 1558 1559 1560 1561 1562
/* close_temporary_tables' internal, 4 is due to uint4korr definition */
static inline uint  tmpkeyval(THD *thd, TABLE *table)
{
  return uint4korr(table->s->table_cache_key.str + table->s->table_cache_key.length - 4);
}


unknown's avatar
unknown committed
1563 1564
/*
  Close all temporary tables created by 'CREATE TEMPORARY TABLE' for thread
1565
  creates one DROP TEMPORARY TABLE binlog event for each pseudo-thread 
unknown's avatar
unknown committed
1566
*/
unknown's avatar
unknown committed
1567 1568 1569

void close_temporary_tables(THD *thd)
{
1570
  TABLE *table;
Staale Smedseng's avatar
Staale Smedseng committed
1571
  TABLE *next= NULL;
unknown's avatar
unknown committed
1572 1573 1574 1575
  TABLE *prev_table;
  /* Assume thd->options has OPTION_QUOTE_SHOW_CREATE */
  bool was_quote_show= TRUE;

1576 1577
  if (!thd->temporary_tables)
    return;
1578

1579 1580
  if (!mysql_bin_log.is_open() || 
      (thd->current_stmt_binlog_row_based && thd->variables.binlog_format == BINLOG_FORMAT_ROW))
1581
  {
1582 1583
    TABLE *tmp_next;
    for (table= thd->temporary_tables; table; table= tmp_next)
1584
    {
1585
      tmp_next= table->next;
1586 1587 1588 1589 1590 1591
      close_temporary(table, 1, 1);
    }
    thd->temporary_tables= 0;
    return;
  }

unknown's avatar
unknown committed
1592
  /* Better add "if exists", in case a RESET MASTER has been done */
1593 1594 1595 1596
  const char stub[]= "DROP /*!40005 TEMPORARY */ TABLE IF EXISTS ";
  uint stub_len= sizeof(stub) - 1;
  char buf[256];
  String s_query= String(buf, sizeof(buf), system_charset_info);
unknown's avatar
unknown committed
1597
  bool found_user_tables= FALSE;
1598

unknown's avatar
unknown committed
1599 1600
  memcpy(buf, stub, stub_len);

1601
  /*
1602 1603
    Insertion sort of temp tables by pseudo_thread_id to build ordered list
    of sublists of equal pseudo_thread_id
1604
  */
1605 1606

  for (prev_table= thd->temporary_tables, table= prev_table->next;
1607 1608
       table;
       prev_table= table, table= table->next)
unknown's avatar
unknown committed
1609
  {
1610 1611
    TABLE *prev_sorted /* same as for prev_table */, *sorted;
    if (is_user_table(table))
1612
    {
1613 1614 1615 1616
      if (!found_user_tables)
        found_user_tables= true;
      for (prev_sorted= NULL, sorted= thd->temporary_tables; sorted != table;
           prev_sorted= sorted, sorted= sorted->next)
1617
      {
1618 1619
        if (!is_user_table(sorted) ||
            tmpkeyval(thd, sorted) > tmpkeyval(thd, table))
1620
        {
1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633
          /* move into the sorted part of the list from the unsorted */
          prev_table->next= table->next;
          table->next= sorted;
          if (prev_sorted)
          {
            prev_sorted->next= table;
          }
          else
          {
            thd->temporary_tables= table;
          }
          table= prev_table;
          break;
1634 1635 1636
        }
      }
    }
unknown's avatar
unknown committed
1637
  }
1638 1639 1640

  /* We always quote db,table names though it is slight overkill */
  if (found_user_tables &&
1641
      !(was_quote_show= test(thd->options & OPTION_QUOTE_SHOW_CREATE)))
1642
  {
1643
    thd->options |= OPTION_QUOTE_SHOW_CREATE;
unknown's avatar
unknown committed
1644
  }
1645

1646
  /* scan sorted tmps to generate sequence of DROP */
1647
  for (table= thd->temporary_tables; table; table= next)
unknown's avatar
unknown committed
1648
  {
1649
    if (is_user_table(table))
1650
    {
unknown's avatar
unknown committed
1651
      my_thread_id save_pseudo_thread_id= thd->variables.pseudo_thread_id;
1652 1653
      /* Set pseudo_thread_id to be that of the processed table */
      thd->variables.pseudo_thread_id= tmpkeyval(thd, table);
1654
      String db;
1655
      db.append(table->s->db.str);
1656 1657 1658
      /* Loop forward through all tables that belong to a common database
         within the sublist of common pseudo_thread_id to create single
         DROP query 
unknown's avatar
unknown committed
1659
      */
1660 1661
      for (s_query.length(stub_len);
           table && is_user_table(table) &&
1662
             tmpkeyval(thd, table) == thd->variables.pseudo_thread_id &&
1663 1664
             table->s->db.length == db.length() &&
             strcmp(table->s->db.str, db.ptr()) == 0;
1665 1666
           table= next)
      {
1667
        /*
1668 1669
          We are going to add ` around the table names and possible more
          due to special characters
1670 1671 1672
        */
        append_identifier(thd, &s_query, table->s->table_name.str,
                          strlen(table->s->table_name.str));
1673
        s_query.append(',');
1674 1675 1676 1677
        next= table->next;
        close_temporary(table, 1, 1);
      }
      thd->clear_error();
1678 1679 1680 1681
      CHARSET_INFO *cs_save= thd->variables.character_set_client;
      thd->variables.character_set_client= system_charset_info;
      Query_log_event qinfo(thd, s_query.ptr(),
                            s_query.length() - 1 /* to remove trailing ',' */,
1682
                            0, FALSE, 0);
1683
      qinfo.db= db.ptr();
1684
      qinfo.db_len= db.length();
1685
      thd->variables.character_set_client= cs_save;
1686
      mysql_bin_log.write(&qinfo);
unknown's avatar
unknown committed
1687
      thd->variables.pseudo_thread_id= save_pseudo_thread_id;
1688
    }
1689
    else
1690 1691 1692
    {
      next= table->next;
      close_temporary(table, 1, 1);
1693
    }
unknown's avatar
unknown committed
1694
  }
1695
  if (!was_quote_show)
unknown's avatar
unknown committed
1696
    thd->options&= ~OPTION_QUOTE_SHOW_CREATE; /* restore option */
unknown's avatar
unknown committed
1697 1698 1699
  thd->temporary_tables=0;
}

1700
/*
1701
  Find table in list.
1702 1703

  SYNOPSIS
1704
    find_table_in_list()
1705
    table		Pointer to table list
1706
    offset		Offset to which list in table structure to use
1707 1708
    db_name		Data base name
    table_name		Table name
unknown's avatar
VIEW  
unknown committed
1709

1710 1711 1712
  NOTES:
    This is called by find_table_in_local_list() and
    find_table_in_global_list().
unknown's avatar
VIEW  
unknown committed
1713 1714 1715 1716 1717 1718

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

1719
TABLE_LIST *find_table_in_list(TABLE_LIST *table,
1720
                               TABLE_LIST *TABLE_LIST::*link,
1721 1722
                               const char *db_name,
                               const char *table_name)
unknown's avatar
VIEW  
unknown committed
1723
{
1724
  for (; table; table= table->*link )
1725
  {
1726 1727 1728 1729
    if ((table->table == 0 || table->table->s->tmp_table == NO_TMP_TABLE) &&
        strcmp(table->db, db_name) == 0 &&
        strcmp(table->table_name, table_name) == 0)
      break;
1730
  }
unknown's avatar
VIEW  
unknown committed
1731 1732 1733 1734
  return table;
}


1735
/*
1736
  Test that table is unique (It's only exists once in the table list)
1737 1738 1739

  SYNOPSIS
    unique_table()
1740
    thd                   thread handle
1741
    table                 table which should be checked
1742
    table_list            list of tables
1743
    check_alias           whether to check tables' aliases
1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758

  NOTE: to exclude derived tables from check we use following mechanism:
    a) during derived table processing set THD::derived_tables_processing
    b) JOIN::prepare set SELECT::exclude_from_table_unique_test if
       THD::derived_tables_processing set. (we can't use JOIN::execute
       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
       items (which mean JOIN::prepare for subqueries) before unique_table
       call to detect which tables should be locked for write).
    c) unique_table skip all tables which belong to SELECT with
       SELECT::exclude_from_table_unique_test set.
    Also SELECT::exclude_from_table_unique_test used to exclude from check
    tables of main SELECT of multi-delete and multi-update

1759 1760 1761 1762
    We also skip tables with TABLE_LIST::prelocking_placeholder set,
    because we want to allow SELECTs from them, and their modification
    will rise the error anyway.

1763 1764
    TODO: when we will have table/view change detection we can do this check
          only once for PS/SP
1765 1766

  RETURN
unknown's avatar
unknown committed
1767 1768
    found duplicate
    0 if table is unique
1769 1770
*/

1771 1772
TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list,
                         bool check_alias)
1773
{
unknown's avatar
unknown committed
1774
  TABLE_LIST *res;
1775
  const char *d_name, *t_name, *t_alias;
unknown's avatar
unknown committed
1776 1777
  DBUG_ENTER("unique_table");
  DBUG_PRINT("enter", ("table alias: %s", table->alias));
1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789

  /*
    If this function called for query which update table (INSERT/UPDATE/...)
    then we have in table->table pointer to TABLE object which we are
    updating even if it is VIEW so we need TABLE_LIST of this TABLE object
    to get right names (even if lower_case_table_names used).

    If this function called for CREATE command that we have not opened table
    (table->table equal to 0) and right names is in current TABLE_LIST
    object.
  */
  if (table->table)
1790
  {
1791 1792 1793 1794 1795 1796 1797 1798 1799
    /* temporary table is always unique */
    if (table->table && table->table->s->tmp_table != NO_TMP_TABLE)
      DBUG_RETURN(0);
    table= table->find_underlying_table(table->table);
    /*
      as far as we have table->table we have to find real TABLE_LIST of
      it in underlying tables
    */
    DBUG_ASSERT(table);
1800
  }
1801 1802
  d_name= table->db;
  t_name= table->table_name;
1803
  t_alias= table->alias;
1804 1805

  DBUG_PRINT("info", ("real table: %s.%s", d_name, t_name));
unknown's avatar
unknown committed
1806
  for (;;)
unknown's avatar
unknown committed
1807
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823
    /*
      Table is unique if it is present only once in the global list
      of tables and once in the list of table locks.
    */
    if (! (res= find_table_in_global_list(table_list, d_name, t_name)) &&
        ! (res= mysql_lock_have_duplicate(thd, table, table_list)))
      break;

    /* Skip if same underlying table. */
    if (res->table && (res->table == table->table))
      goto next;

    /* Skip if table alias does not match. */
    if (check_alias)
    {
      if (lower_case_table_names ?
unknown's avatar
unknown committed
1824
          my_strcasecmp(files_charset_info, t_alias, res->alias) :
Konstantin Osipov's avatar
Konstantin Osipov committed
1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835
          strcmp(t_alias, res->alias))
        goto next;
    }

    /*
      Skip if marked to be excluded (could be a derived table) or if
      entry is a prelocking placeholder.
    */
    if (res->select_lex &&
        !res->select_lex->exclude_from_table_unique_test &&
        !res->prelocking_placeholder)
1836
      break;
Konstantin Osipov's avatar
Konstantin Osipov committed
1837

1838
    /*
1839
      If we found entry of this table or table of SELECT which already
1840
      processed in derived table or top select of multi-update/multi-delete
1841
      (exclude_from_table_unique_test) or prelocking placeholder.
1842
    */
Konstantin Osipov's avatar
Konstantin Osipov committed
1843
next:
1844
    table_list= res->next_global;
1845 1846
    DBUG_PRINT("info",
               ("found same copy of table or table which we should skip"));
unknown's avatar
unknown committed
1847
  }
1848
  DBUG_RETURN(res);
1849 1850 1851
}


1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886
/*
  Issue correct error message in case we found 2 duplicate tables which
  prevent some update operation

  SYNOPSIS
    update_non_unique_table_error()
    update      table which we try to update
    operation   name of update operation
    duplicate   duplicate table which we found

  NOTE:
    here we hide view underlying tables if we have them
*/

void update_non_unique_table_error(TABLE_LIST *update,
                                   const char *operation,
                                   TABLE_LIST *duplicate)
{
  update= update->top_table();
  duplicate= duplicate->top_table();
  if (!update->view || !duplicate->view ||
      update->view == duplicate->view ||
      update->view_name.length != duplicate->view_name.length ||
      update->view_db.length != duplicate->view_db.length ||
      my_strcasecmp(table_alias_charset,
                    update->view_name.str, duplicate->view_name.str) != 0 ||
      my_strcasecmp(table_alias_charset,
                    update->view_db.str, duplicate->view_db.str) != 0)
  {
    /*
      it is not the same view repeated (but it can be parts of the same copy
      of view), so we have to hide underlying tables.
    */
    if (update->view)
    {
1887
      /* Issue the ER_NON_INSERTABLE_TABLE error for an INSERT */
1888
      if (update->view == duplicate->view)
1889 1890 1891
        my_error(!strncmp(operation, "INSERT", 6) ?
                 ER_NON_INSERTABLE_TABLE : ER_NON_UPDATABLE_TABLE, MYF(0),
                 update->alias, operation);
1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908
      else
        my_error(ER_VIEW_PREVENT_UPDATE, MYF(0),
                 (duplicate->view ? duplicate->alias : update->alias),
                 operation, update->alias);
      return;
    }
    if (duplicate->view)
    {
      my_error(ER_VIEW_PREVENT_UPDATE, MYF(0), duplicate->alias, operation,
               update->alias);
      return;
    }
  }
  my_error(ER_UPDATE_TABLE_USED, MYF(0), update->alias);
}


unknown's avatar
unknown committed
1909
TABLE *find_temporary_table(THD *thd, const char *db, const char *table_name)
unknown's avatar
unknown committed
1910
{
unknown's avatar
unknown committed
1911
  TABLE_LIST table_list;
unknown's avatar
unknown committed
1912

unknown's avatar
unknown committed
1913 1914 1915 1916
  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
  return find_temporary_table(thd, &table_list);
}
1917

unknown's avatar
unknown committed
1918 1919 1920 1921 1922 1923

TABLE *find_temporary_table(THD *thd, TABLE_LIST *table_list)
{
  char	key[MAX_DBKEY_LENGTH];
  uint	key_length;
  TABLE *table;
1924 1925 1926
  DBUG_ENTER("find_temporary_table");
  DBUG_PRINT("enter", ("table: '%s'.'%s'",
                       table_list->db, table_list->table_name));
unknown's avatar
unknown committed
1927 1928 1929

  key_length= create_table_def_key(thd, key, table_list, 1);
  for (table=thd->temporary_tables ; table ; table= table->next)
unknown's avatar
unknown committed
1930
  {
unknown's avatar
unknown committed
1931 1932
    if (table->s->table_cache_key.length == key_length &&
	!memcmp(table->s->table_cache_key.str, key, key_length))
unknown's avatar
unknown committed
1933 1934 1935 1936 1937
    {
      DBUG_PRINT("info",
                 ("Found table. server_id: %u  pseudo_thread_id: %lu",
                  (uint) thd->server_id,
                  (ulong) thd->variables.pseudo_thread_id));
1938
      DBUG_RETURN(table);
unknown's avatar
unknown committed
1939
    }
unknown's avatar
unknown committed
1940
  }
unknown's avatar
unknown committed
1941
  DBUG_RETURN(0);                               // Not a temporary table
unknown's avatar
unknown committed
1942 1943
}

unknown's avatar
unknown committed
1944

1945 1946 1947 1948 1949
/**
  Drop a temporary table.

  Try to locate the table in the list of thd->temporary_tables.
  If the table is found:
1950
   - if the table is being used by some outer statement, fail.
Konstantin Osipov's avatar
Konstantin Osipov committed
1951 1952 1953 1954
   - if the table is locked with LOCK TABLES or by prelocking,
   unlock it and remove it from the list of locked tables
   (THD::lock). Currently only transactional temporary tables
   are locked.
1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965
   - Close the temporary table, remove its .FRM
   - remove the table from the list of temporary tables

  This function is used to drop user temporary tables, as well as
  internal tables created in CREATE TEMPORARY TABLE ... SELECT
  or ALTER TABLE. Even though part of the work done by this function
  is redundant when the table is internal, as long as we
  link both internal and user temporary tables into the same
  thd->temporary_tables list, it's impossible to tell here whether
  we're dealing with an internal or a user temporary table.

1966 1967 1968 1969
  @retval  0  the table was found and dropped successfully.
  @retval  1  the table was not found in the list of temporary tables
              of this thread
  @retval -1  the table is in use by a outer query
unknown's avatar
unknown committed
1970 1971
*/

1972
int drop_temporary_table(THD *thd, TABLE_LIST *table_list)
unknown's avatar
unknown committed
1973
{
unknown's avatar
unknown committed
1974
  TABLE *table;
1975
  DBUG_ENTER("drop_temporary_table");
1976 1977
  DBUG_PRINT("tmptable", ("closing table: '%s'.'%s'",
                          table_list->db, table_list->table_name));
unknown's avatar
unknown committed
1978

unknown's avatar
unknown committed
1979
  if (!(table= find_temporary_table(thd, table_list)))
1980 1981 1982 1983 1984 1985 1986 1987 1988
    DBUG_RETURN(1);

  /* Table might be in use by some outer statement. */
  if (table->query_id && table->query_id != thd->query_id)
  {
    my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
    DBUG_RETURN(-1);
  }

1989 1990 1991 1992
  /*
    If LOCK TABLES list is not empty and contains this table,
    unlock the table and remove the table from this list.
  */
Konstantin Osipov's avatar
Konstantin Osipov committed
1993
  mysql_lock_remove(thd, thd->lock, table);
unknown's avatar
unknown committed
1994
  close_temporary_table(thd, table, 1, 1);
1995
  DBUG_RETURN(0);
unknown's avatar
unknown committed
1996 1997
}

unknown's avatar
unknown committed
1998
/*
1999
  unlink from thd->temporary tables and close temporary table
unknown's avatar
unknown committed
2000 2001 2002 2003 2004
*/

void close_temporary_table(THD *thd, TABLE *table,
                           bool free_share, bool delete_table)
{
2005 2006 2007 2008 2009
  DBUG_ENTER("close_temporary_table");
  DBUG_PRINT("tmptable", ("closing table: '%s'.'%s' 0x%lx  alias: '%s'",
                          table->s->db.str, table->s->table_name.str,
                          (long) table, table->alias));

2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028
  if (table->prev)
  {
    table->prev->next= table->next;
    if (table->prev->next)
      table->next->prev= table->prev;
  }
  else
  {
    /* removing the item from the list */
    DBUG_ASSERT(table == thd->temporary_tables);
    /*
      slave must reset its temporary list pointer to zero to exclude
      passing non-zero value to end_slave via rli->save_temporary_tables
      when no temp tables opened, see an invariant below.
    */
    thd->temporary_tables= table->next;
    if (thd->temporary_tables)
      table->next->prev= 0;
  }
unknown's avatar
unknown committed
2029
  if (thd->slave_thread)
2030 2031 2032
  {
    /* natural invariant of temporary_tables */
    DBUG_ASSERT(slave_open_temp_tables || !thd->temporary_tables);
unknown's avatar
unknown committed
2033
    slave_open_temp_tables--;
2034
  }
unknown's avatar
unknown committed
2035
  close_temporary(table, free_share, delete_table);
2036
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049
}


/*
  Close and delete a temporary table

  NOTE
    This dosn't unlink table from thd->temporary
    If this is needed, use close_temporary_table()
*/

void close_temporary(TABLE *table, bool free_share, bool delete_table)
{
unknown's avatar
unknown committed
2050
  handlerton *table_type= table->s->db_type();
unknown's avatar
unknown committed
2051
  DBUG_ENTER("close_temporary");
2052 2053
  DBUG_PRINT("tmptable", ("closing table: '%s'.'%s'",
                          table->s->db.str, table->s->table_name.str));
unknown's avatar
unknown committed
2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067

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


unknown's avatar
unknown committed
2068 2069 2070 2071 2072 2073 2074
/*
  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'.
*/
2075

2076
bool rename_temporary_table(THD* thd, TABLE *table, const char *db,
unknown's avatar
unknown committed
2077 2078 2079
			    const char *table_name)
{
  char *key;
2080
  uint key_length;
2081
  TABLE_SHARE *share= table->s;
unknown's avatar
unknown committed
2082 2083 2084
  TABLE_LIST table_list;
  DBUG_ENTER("rename_temporary_table");

2085
  if (!(key=(char*) alloc_root(&share->mem_root, MAX_DBKEY_LENGTH)))
unknown's avatar
unknown committed
2086 2087 2088 2089
    DBUG_RETURN(1);				/* purecov: inspected */

  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
2090 2091
  key_length= create_table_def_key(thd, key, &table_list, 1);
  share->set_table_cache_key(key, key_length);
unknown's avatar
unknown committed
2092
  DBUG_RETURN(0);
unknown's avatar
unknown committed
2093 2094 2095
}


Konstantin Osipov's avatar
Konstantin Osipov committed
2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127
/**
   Force all other threads to stop using the table by upgrading
   metadata lock on it and remove unused TABLE instances from cache.

   @param thd      Thread handler
   @param table    Table to remove from cache
   @param function HA_EXTRA_PREPARE_FOR_DROP if table is to be deleted
                   HA_EXTRA_FORCE_REOPEN if table is not be used
                   HA_EXTRA_PREPARE_FOR_RENAME if table is to be renamed

   @note When returning, the table will be unusable for other threads
         until metadata lock is downgraded.

   @retval FALSE Success.
   @retval TRUE  Failure (e.g. because thread was killed).
*/

bool wait_while_table_is_used(THD *thd, TABLE *table,
                              enum ha_extra_function function)
{
  enum thr_lock_type old_lock_type;

  DBUG_ENTER("wait_while_table_is_used");
  DBUG_PRINT("enter", ("table: '%s'  share: 0x%lx  db_stat: %u  version: %lu",
                       table->s->table_name.str, (ulong) table->s,
                       table->db_stat, table->s->version));

  (void) table->file->extra(function);

  old_lock_type= table->reginfo.lock_type;
  mysql_lock_abort(thd, table, TRUE);	/* end threads waiting on lock */

Konstantin Osipov's avatar
Konstantin Osipov committed
2128
  if (table->mdl_ticket->upgrade_shared_lock_to_exclusive())
Konstantin Osipov's avatar
Konstantin Osipov committed
2129 2130 2131 2132 2133 2134
  {
    mysql_lock_downgrade_write(thd, table, old_lock_type);
    DBUG_RETURN(TRUE);
  }

  pthread_mutex_lock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
2135 2136
  tdc_remove_table(thd, TDC_RT_REMOVE_NOT_OWN,
                   table->s->db.str, table->s->table_name.str);
Konstantin Osipov's avatar
Konstantin Osipov committed
2137 2138 2139 2140 2141 2142
  pthread_mutex_unlock(&LOCK_open);
  DBUG_RETURN(FALSE);
}


/**
Konstantin Osipov's avatar
Konstantin Osipov committed
2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158
  Close a and drop a just created table in CREATE TABLE ... SELECT.

  @param  thd         Thread handle
  @param  table       TABLE object for the table to be dropped
  @param  db_name     Name of database for this table
  @param  table_name  Name of this table

  This routine assumes that the table to be closed is open only
  by the calling thread, so we needn't wait until other threads
  close the table. It also assumes that the table is first
  in thd->open_ables and a data lock on it, if any, has been
  released. To sum up, it's tuned to work with
  CREATE TABLE ... SELECT and CREATE TABLE .. SELECT only.
  Note, that currently CREATE TABLE ... SELECT is not supported
  under LOCK TABLES. This function, still, can be called in
  prelocked mode, e.g. if we do CREATE TABLE .. SELECT f1();
unknown's avatar
unknown committed
2159 2160 2161 2162 2163 2164 2165 2166 2167
*/

void drop_open_table(THD *thd, TABLE *table, const char *db_name,
                     const char *table_name)
{
  if (table->s->tmp_table)
    close_temporary_table(thd, table, 1, 1);
  else
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
2168 2169
    DBUG_ASSERT(table == thd->open_tables);

unknown's avatar
unknown committed
2170
    handlerton *table_type= table->s->db_type();
Konstantin Osipov's avatar
Konstantin Osipov committed
2171 2172 2173
    /* Ensure the table is removed from the cache. */
    table->s->version= 0;

Konstantin Osipov's avatar
Konstantin Osipov committed
2174
    pthread_mutex_lock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
2175
    close_thread_table(thd, &thd->open_tables);
unknown's avatar
unknown committed
2176
    quick_rm_table(table_type, db_name, table_name, 0);
Konstantin Osipov's avatar
Konstantin Osipov committed
2177
    pthread_mutex_unlock(&LOCK_open);
unknown's avatar
unknown committed
2178
  }
unknown's avatar
unknown committed
2179 2180 2181
}


2182
/*
unknown's avatar
unknown committed
2183 2184 2185 2186 2187 2188 2189 2190
   Wait for condition but allow the user to send a kill to mysqld

   SYNOPSIS
     wait_for_condition()
     thd	Thread handler
     mutex	mutex that is currently hold that is associated with condition
	        Will be unlocked on return     
     cond	Condition to wait for
unknown's avatar
unknown committed
2191 2192
*/

unknown's avatar
unknown committed
2193
void wait_for_condition(THD *thd, pthread_mutex_t *mutex, pthread_cond_t *cond)
unknown's avatar
unknown committed
2194 2195 2196
{
  /* Wait until the current table is up to date */
  const char *proc_info;
unknown's avatar
unknown committed
2197 2198
  thd->mysys_var->current_mutex= mutex;
  thd->mysys_var->current_cond= cond;
unknown's avatar
unknown committed
2199
  proc_info=thd->proc_info;
2200
  thd_proc_info(thd, "Waiting for table");
2201
  DBUG_ENTER("wait_for_condition");
unknown's avatar
unknown committed
2202
  if (!thd->killed)
unknown's avatar
unknown committed
2203
    (void) pthread_cond_wait(cond, mutex);
unknown's avatar
unknown committed
2204

unknown's avatar
unknown committed
2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216
  /*
    We must unlock mutex first to avoid deadlock becasue conditions are
    sent to this thread by doing locks in the following order:
    lock(mysys_var->mutex)
    lock(mysys_var->current_mutex)

    One by effect of this that one can only use wait_for_condition with
    condition variables that are guranteed to not disapper (freed) even if this
    mutex is unlocked
  */
    
  pthread_mutex_unlock(mutex);
unknown's avatar
unknown committed
2217 2218 2219
  pthread_mutex_lock(&thd->mysys_var->mutex);
  thd->mysys_var->current_mutex= 0;
  thd->mysys_var->current_cond= 0;
2220
  thd_proc_info(thd, proc_info);
unknown's avatar
unknown committed
2221
  pthread_mutex_unlock(&thd->mysys_var->mutex);
unknown's avatar
unknown committed
2222
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2223 2224
}

2225

unknown's avatar
unknown committed
2226
/**
unknown's avatar
unknown committed
2227 2228
    Check that table exists in table definition cache, on disk
    or in some storage engine.
unknown's avatar
unknown committed
2229

unknown's avatar
unknown committed
2230 2231 2232
    @param       thd     Thread context
    @param       table   Table list element
    @param[out]  exists  Out parameter which is set to TRUE if table
unknown's avatar
unknown committed
2233 2234 2235
                         exists and to FALSE otherwise.

    @note This function assumes that caller owns LOCK_open mutex.
Konstantin Osipov's avatar
Konstantin Osipov committed
2236 2237
          It also assumes that the fact that there are no exclusive
          metadata locks on the table was checked beforehand.
unknown's avatar
unknown committed
2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248

    @note If there is no .FRM file for the table but it exists in one
          of engines (e.g. it was created on another node of NDB cluster)
          this function will fetch and create proper .FRM file for it.

    @retval  TRUE   Some error occured
    @retval  FALSE  No error. 'exists' out parameter set accordingly.
*/

bool check_if_table_exists(THD *thd, TABLE_LIST *table, bool *exists)
{
2249
  char path[FN_REFLEN + 1];
unknown's avatar
unknown committed
2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289
  int rc;
  DBUG_ENTER("check_if_table_exists");

  safe_mutex_assert_owner(&LOCK_open);

  *exists= TRUE;

  if (get_cached_table_share(table->db, table->table_name))
    DBUG_RETURN(FALSE);

  build_table_filename(path, sizeof(path) - 1, table->db, table->table_name,
                       reg_ext, 0);

  if (!access(path, F_OK))
    DBUG_RETURN(FALSE);

  /* .FRM file doesn't exist. Check if some engine can provide it. */

  rc= ha_create_table_from_engine(thd, table->db, table->table_name);

  if (rc < 0)
  {
    /* Table does not exists in engines as well. */
    *exists= FALSE;
    DBUG_RETURN(FALSE);
  }
  else if (!rc)
  {
    /* Table exists in some engine and .FRM for it was created. */
    DBUG_RETURN(FALSE);
  }
  else /* (rc > 0) */
  {
    my_printf_error(ER_UNKNOWN_ERROR, "Failed to open '%-.64s', error while "
                    "unpacking from engine", MYF(0), table->table_name);
    DBUG_RETURN(TRUE);
  }
}


2290 2291 2292 2293 2294 2295 2296 2297
/**
   @brief Helper function used by MDL subsystem for releasing TABLE_SHARE
          objects in cases when it no longer wants to cache reference to it.
*/

void table_share_release_hook(void *share)
{
  pthread_mutex_lock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
2298
  release_table_share((TABLE_SHARE*) share);
2299 2300 2301 2302 2303
  broadcast_refresh();
  pthread_mutex_unlock(&LOCK_open);
}


Konstantin Osipov's avatar
Konstantin Osipov committed
2304 2305 2306
/**
   A helper function that acquires an MDL lock for a table
   being opened.
Konstantin Osipov's avatar
Konstantin Osipov committed
2307 2308 2309 2310
*/

static bool
open_table_get_mdl_lock(THD *thd, TABLE_LIST *table_list,
Konstantin Osipov's avatar
Konstantin Osipov committed
2311
                        MDL_request *mdl_request,
Konstantin Osipov's avatar
Konstantin Osipov committed
2312 2313
                        Open_table_context *ot_ctx,
                        uint flags)
Konstantin Osipov's avatar
Konstantin Osipov committed
2314
{
Konstantin Osipov's avatar
Konstantin Osipov committed
2315
  ot_ctx->add_request(mdl_request);
Konstantin Osipov's avatar
Konstantin Osipov committed
2316

2317
  if (table_list->lock_strategy)
Konstantin Osipov's avatar
Konstantin Osipov committed
2318 2319 2320 2321 2322 2323 2324 2325 2326 2327
  {
    /*
      In case of CREATE TABLE .. If NOT EXISTS .. SELECT, the table
      may not yet exist. Let's acquire an exclusive lock for that
      case. If later it turns out the table existsed, we will
      downgrade the lock to shared. Note that, according to the
      locking protocol, all exclusive locks must be acquired before
      shared locks. This invariant is preserved here and is also
      enforced by asserts in metadata locking subsystem.
    */
Konstantin Osipov's avatar
Konstantin Osipov committed
2328
    mdl_request->set_type(MDL_EXCLUSIVE);
Konstantin Osipov's avatar
Konstantin Osipov committed
2329 2330 2331
    DBUG_ASSERT(! thd->mdl_context.has_locks());

    if (thd->mdl_context.acquire_exclusive_lock(mdl_request))
Konstantin Osipov's avatar
Konstantin Osipov committed
2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344
      return 1;
  }
  else
  {
    /*
      There is no MDL_SHARED_UPGRADABLE_HIGH_PRIO type of metadata lock so we
      want to be sure that caller doesn't pass us both flags simultaneously.
    */
    DBUG_ASSERT(!(flags & MYSQL_OPEN_TAKE_UPGRADABLE_MDL) ||
                !(flags & MYSQL_LOCK_IGNORE_FLUSH));

    if (flags & MYSQL_OPEN_TAKE_UPGRADABLE_MDL &&
        table_list->lock_type >= TL_WRITE_ALLOW_WRITE)
Konstantin Osipov's avatar
Konstantin Osipov committed
2345
      mdl_request->set_type(MDL_SHARED_UPGRADABLE);
Konstantin Osipov's avatar
Konstantin Osipov committed
2346
    if (flags & MYSQL_LOCK_IGNORE_FLUSH)
Konstantin Osipov's avatar
Konstantin Osipov committed
2347
      mdl_request->set_type(MDL_SHARED_HIGH_PRIO);
Konstantin Osipov's avatar
Konstantin Osipov committed
2348

Konstantin Osipov's avatar
Konstantin Osipov committed
2349 2350 2351
    if (thd->mdl_context.try_acquire_shared_lock(mdl_request))
      return 1;
    if (mdl_request->ticket == NULL)
Konstantin Osipov's avatar
Konstantin Osipov committed
2352
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
2353
      (void) ot_ctx->request_backoff_action(Open_table_context::OT_WAIT);
Konstantin Osipov's avatar
Konstantin Osipov committed
2354 2355 2356 2357 2358 2359 2360
      return 1;
    }
  }
  return 0;
}


2361 2362 2363 2364 2365
/*
  Open a table.

  SYNOPSIS
    open_table()
2366 2367
    thd                 Thread context.
    table_list          Open first table in list.
2368 2369 2370 2371
    action       INOUT  Pointer to variable of enum_open_table_action type
                        which will be set according to action which is
                        required to remedy problem appeared during attempt
                        to open table.
2372 2373
    flags               Bitmap of flags to modify how open works:
                          MYSQL_LOCK_IGNORE_FLUSH - Open table even if
2374 2375 2376
                          someone has done a flush or there is a pending
                          exclusive metadata lock requests against it
                          (i.e. request high priority metadata lock).
2377
                          No version number checking is done.
unknown's avatar
unknown committed
2378 2379
                          MYSQL_OPEN_TEMPORARY_ONLY - Open only temporary
                          table not the base table or view.
Konstantin Osipov's avatar
Konstantin Osipov committed
2380 2381 2382
                          MYSQL_OPEN_TAKE_UPGRADABLE_MDL - Obtain upgradable
                          metadata lock for tables on which we are going to
                          take some kind of write table-level lock.
2383 2384 2385 2386

  IMPLEMENTATION
    Uses a cache of open tables to find a table not in use.

2387 2388 2389 2390 2391 2392 2393 2394 2395 2396
    If TABLE_LIST::open_strategy is set to OPEN_IF_EXISTS, the table is opened
    only if it exists. If the open strategy is OPEN_STUB, the underlying table
    is never opened. In both cases, metadata locks are always taken according
    to the lock strategy.

    This function will take a exclusive metadata lock on the table if
    TABLE_LIST::lock_strategy is EXCLUSIVE_DOWNGRADABLE_MDL or EXCLUSIVE_MDL.
    If the lock strategy is EXCLUSIVE_DOWNGRADABLE_MDL and opening the table
    is successful, the exclusive metadata lock is downgraded to a shared
    lock.
unknown's avatar
unknown committed
2397

2398
  RETURN
Konstantin Osipov's avatar
Konstantin Osipov committed
2399 2400 2401 2402 2403
    TRUE  Open failed. "action" parameter may contain type of action
          needed to remedy problem before retrying again.
    FALSE Success. Members of TABLE_LIST structure are filled properly (e.g.
          TABLE_LIST::table is set for real tables and TABLE_LIST::view is
          set for views).
2404
*/
unknown's avatar
unknown committed
2405 2406


Konstantin Osipov's avatar
Konstantin Osipov committed
2407
bool open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
Konstantin Osipov's avatar
Konstantin Osipov committed
2408
                Open_table_context *ot_ctx, uint flags)
unknown's avatar
unknown committed
2409 2410 2411 2412
{
  reg1	TABLE *table;
  char	key[MAX_DBKEY_LENGTH];
  uint	key_length;
unknown's avatar
VIEW  
unknown committed
2413
  char	*alias= table_list->alias;
Konstantin Osipov's avatar
Konstantin Osipov committed
2414 2415
  MDL_request *mdl_request;
  MDL_ticket *mdl_ticket;
2416 2417
  int error;
  TABLE_SHARE *share;
unknown's avatar
unknown committed
2418 2419
  DBUG_ENTER("open_table");

2420
  /* an open table operation needs a lot of the stack space */
2421
  if (check_stack_overrun(thd, STACK_MIN_SIZE_FOR_OPEN, (uchar *)&alias))
Konstantin Osipov's avatar
Konstantin Osipov committed
2422
    DBUG_RETURN(TRUE);
2423

unknown's avatar
unknown committed
2424
  if (thd->killed)
Konstantin Osipov's avatar
Konstantin Osipov committed
2425
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
2426 2427 2428

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

2430 2431 2432 2433 2434 2435 2436
  /*
    Unless requested otherwise, try to resolve this table in the list
    of temporary tables of this thread. In MySQL temporary tables
    are always thread-local and "shadow" possible base tables with the
    same name. This block implements the behaviour.
    TODO: move this block into a separate function.
  */
Konstantin Osipov's avatar
Konstantin Osipov committed
2437
  if (!table_list->skip_temporary && ! (flags & MYSQL_OPEN_SKIP_TEMPORARY))
unknown's avatar
unknown committed
2438
  {
unknown's avatar
VIEW  
unknown committed
2439
    for (table= thd->temporary_tables; table ; table=table->next)
unknown's avatar
unknown committed
2440
    {
unknown's avatar
unknown committed
2441 2442 2443
      if (table->s->table_cache_key.length == key_length +
          TMP_TABLE_KEY_EXTRA &&
	  !memcmp(table->s->table_cache_key.str, key,
unknown's avatar
unknown committed
2444
		  key_length + TMP_TABLE_KEY_EXTRA))
unknown's avatar
unknown committed
2445
      {
2446 2447 2448 2449 2450 2451
        /*
          We're trying to use the same temporary table twice in a query.
          Right now we don't support this because a temporary table
          is always represented by only one TABLE object in THD, and
          it can not be cloned. Emit an error for an unsupported behaviour.
        */
2452
	if (table->query_id)
unknown's avatar
VIEW  
unknown committed
2453
	{
unknown's avatar
unknown committed
2454 2455 2456 2457
          DBUG_PRINT("error",
                     ("query_id: %lu  server_id: %u  pseudo_thread_id: %lu",
                      (ulong) table->query_id, (uint) thd->server_id,
                      (ulong) thd->variables.pseudo_thread_id));
2458
	  my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
Konstantin Osipov's avatar
Konstantin Osipov committed
2459
	  DBUG_RETURN(TRUE);
unknown's avatar
VIEW  
unknown committed
2460 2461
	}
	table->query_id= thd->query_id;
unknown's avatar
unknown committed
2462
	thd->thread_specific_used= TRUE;
unknown's avatar
unknown committed
2463 2464
        DBUG_PRINT("info",("Using temporary table"));
        goto reset;
unknown's avatar
unknown committed
2465 2466 2467 2468
      }
    }
  }

unknown's avatar
unknown committed
2469 2470 2471
  if (flags & MYSQL_OPEN_TEMPORARY_ONLY)
  {
    my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->db, table_list->table_name);
Konstantin Osipov's avatar
Konstantin Osipov committed
2472
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
2473 2474
  }

2475 2476 2477 2478 2479 2480 2481
  /*
    The table is not temporary - if we're in pre-locked or LOCK TABLES
    mode, let's try to find the requested table in the list of pre-opened
    and locked tables. If the table is not there, return an error - we can't
    open not pre-opened tables in pre-locked/LOCK TABLES mode.
    TODO: move this block into a separate function.
  */
Konstantin Osipov's avatar
Konstantin Osipov committed
2482 2483
  if (thd->locked_tables_mode &&
      ! (flags & MYSQL_OPEN_GET_NEW_TABLE))
unknown's avatar
unknown committed
2484
  {						// Using table locks
2485
    TABLE *best_table= 0;
unknown's avatar
unknown committed
2486
    int best_distance= INT_MIN;
unknown's avatar
unknown committed
2487 2488
    for (table=thd->open_tables; table ; table=table->next)
    {
unknown's avatar
unknown committed
2489 2490
      if (table->s->table_cache_key.length == key_length &&
	  !memcmp(table->s->table_cache_key.str, key, key_length))
unknown's avatar
unknown committed
2491
      {
2492 2493
        if (!my_strcasecmp(system_charset_info, table->alias, alias) &&
            table->query_id != thd->query_id && /* skip tables already used */
Konstantin Osipov's avatar
Konstantin Osipov committed
2494
            (thd->locked_tables_mode == LTM_LOCK_TABLES ||
Konstantin Osipov's avatar
Konstantin Osipov committed
2495
             table->query_id == 0))
2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510
        {
          int distance= ((int) table->reginfo.lock_type -
                         (int) table_list->lock_type);
          /*
            Find a table that either has the exact lock type requested,
            or has the best suitable lock. In case there is no locked
            table that has an equal or higher lock than requested,
            we us the closest matching lock to be able to produce an error
            message about wrong lock mode on the table. The best_table
            is changed if bd < 0 <= d or bd < d < 0 or 0 <= d < bd.

            distance <  0 - No suitable lock found
            distance >  0 - we have lock mode higher then we require
            distance == 0 - we have lock mode exactly which we need
          */
2511 2512
          if ((best_distance < 0 && distance > best_distance) ||
              (distance >= 0 && distance < best_distance))
2513 2514 2515
          {
            best_distance= distance;
            best_table= table;
2516
            if (best_distance == 0)
2517 2518
            {
              /*
2519 2520 2521 2522
                We have found a perfect match and can finish iterating
                through open tables list. Check for table use conflict
                between calling statement and SP/trigger is done in
                lock_tables().
2523 2524 2525 2526
              */
              break;
            }
          }
2527
        }
unknown's avatar
unknown committed
2528
      }
unknown's avatar
unknown committed
2529
    }
2530 2531 2532 2533 2534 2535 2536
    if (best_table)
    {
      table= best_table;
      table->query_id= thd->query_id;
      DBUG_PRINT("info",("Using locked table"));
      goto reset;
    }
unknown's avatar
unknown committed
2537
    /*
2538
      Is this table a view and not a base table?
unknown's avatar
unknown committed
2539 2540
      (it is work around to allow to open view with locked tables,
      real fix will be made after definition cache will be made)
2541 2542 2543 2544

      Since opening of view which was not explicitly locked by LOCK
      TABLES breaks metadata locking protocol (potentially can lead
      to deadlocks) it should be disallowed.
unknown's avatar
unknown committed
2545
    */
2546
    if (thd->mdl_context.is_lock_owner(MDL_TABLE, table_list->db,
Konstantin Osipov's avatar
Konstantin Osipov committed
2547
                                       table_list->table_name))
unknown's avatar
unknown committed
2548
    {
2549
      char path[FN_REFLEN + 1];
unknown's avatar
unknown committed
2550
      enum legacy_db_type not_used;
2551
      build_table_filename(path, sizeof(path) - 1,
2552
                           table_list->db, table_list->table_name, reg_ext, 0);
Konstantin Osipov's avatar
Konstantin Osipov committed
2553 2554 2555 2556 2557 2558 2559
      /*
        Note that we can't be 100% sure that it is a view since it's
        possible that we either simply have not found unused TABLE
        instance in THD::open_tables list or were unable to open table
        during prelocking process (in this case in theory we still
        should hold shared metadata lock on it).
      */
2560
      if (mysql_frm_type(thd, path, &not_used) == FRMTYPE_VIEW)
unknown's avatar
unknown committed
2561
      {
2562 2563
        if (!tdc_open_view(thd, table_list, alias, key, key_length,
                           mem_root, 0))
unknown's avatar
unknown committed
2564
        {
2565
          DBUG_ASSERT(table_list->view != 0);
Konstantin Osipov's avatar
Konstantin Osipov committed
2566
          DBUG_RETURN(FALSE); // VIEW
unknown's avatar
unknown committed
2567 2568 2569
        }
      }
    }
2570 2571 2572 2573 2574 2575 2576
    /*
      No table in the locked tables list. In case of explicit LOCK TABLES
      this can happen if a user did not include the able into the list.
      In case of pre-locked mode locked tables list is generated automatically,
      so we may only end up here if the table did not exist when
      locked tables list was created.
    */
Konstantin Osipov's avatar
Konstantin Osipov committed
2577
    if (thd->locked_tables_mode == LTM_PRELOCKED)
Konstantin Osipov's avatar
Konstantin Osipov committed
2578 2579 2580 2581 2582
      my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->db, table_list->alias);
    else
      my_error(ER_TABLE_NOT_LOCKED, MYF(0), alias);
    DBUG_RETURN(TRUE);
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
2583

Konstantin Osipov's avatar
Konstantin Osipov committed
2584 2585 2586 2587
  /*
    Non pre-locked/LOCK TABLES mode, and the table is not temporary.
    This is the normal use case.
  */
Konstantin Osipov's avatar
Konstantin Osipov committed
2588

Konstantin Osipov's avatar
Konstantin Osipov committed
2589
  mdl_request= &table_list->mdl_request;
Konstantin Osipov's avatar
Konstantin Osipov committed
2590 2591
  if (! (flags & MYSQL_OPEN_HAS_MDL_LOCK))
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
2592 2593 2594
    if (open_table_get_mdl_lock(thd, table_list, mdl_request, ot_ctx, flags))
    {
      DEBUG_SYNC(thd, "before_open_table_wait_refresh");
Konstantin Osipov's avatar
Konstantin Osipov committed
2595
      DBUG_RETURN(TRUE);
Konstantin Osipov's avatar
Konstantin Osipov committed
2596 2597
    }
    DEBUG_SYNC(thd, "after_open_table_mdl_shared");
2598 2599
  }

Konstantin Osipov's avatar
Konstantin Osipov committed
2600 2601 2602 2603 2604
  /*
    Grab reference to the granted MDL lock ticket. Must be done after
    open_table_get_mdl_lock as the lock on the table might have been
    acquired previously (MYSQL_OPEN_HAS_MDL_LOCK).
  */
Konstantin Osipov's avatar
Konstantin Osipov committed
2605
  mdl_ticket= mdl_request->ticket;
Konstantin Osipov's avatar
Konstantin Osipov committed
2606

Konstantin Osipov's avatar
Konstantin Osipov committed
2607
  pthread_mutex_lock(&LOCK_open);
unknown's avatar
unknown committed
2608

2609 2610 2611 2612 2613 2614 2615 2616
  /*
    If it's the first table from a list of tables used in a query,
    remember refresh_version (the version of open_cache state).
    If the version changes while we're opening the remaining tables,
    we will have to back off, close all the tables opened-so-far,
    and try to reopen them.
    Note: refresh_version is currently changed only during FLUSH TABLES.
  */
unknown's avatar
unknown committed
2617 2618
  if (!thd->open_tables)
    thd->version=refresh_version;
2619
  else if ((thd->version != refresh_version) &&
2620
           ! (flags & MYSQL_LOCK_IGNORE_FLUSH))
unknown's avatar
unknown committed
2621 2622
  {
    /* Someone did a refresh while thread was opening tables */
Konstantin Osipov's avatar
Konstantin Osipov committed
2623
    pthread_mutex_unlock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
2624
    (void) ot_ctx->request_backoff_action(Open_table_context::OT_WAIT);
Konstantin Osipov's avatar
Konstantin Osipov committed
2625
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
2626 2627
  }

2628
  if (table_list->open_strategy == TABLE_LIST::OPEN_IF_EXISTS)
unknown's avatar
unknown committed
2629
  {
2630
    bool exists;
2631

2632 2633
    if (check_if_table_exists(thd, table_list, &exists))
      goto err_unlock2;
2634

2635 2636 2637
    if (!exists)
    {
      pthread_mutex_unlock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
2638
      DBUG_RETURN(FALSE);
2639 2640 2641
    }
    /* Table exists. Let us try to open it. */
  }
2642
  else if (table_list->open_strategy == TABLE_LIST::OPEN_STUB)
2643 2644
  {
    pthread_mutex_unlock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
2645
    DBUG_RETURN(FALSE);
2646
  }
unknown's avatar
unknown committed
2647

Konstantin Osipov's avatar
Konstantin Osipov committed
2648
  if (!(share= (TABLE_SHARE *) mdl_ticket->get_cached_object()))
2649 2650 2651 2652 2653 2654 2655 2656
  {
    if (!(share= get_table_share_with_create(thd, table_list, key,
                                             key_length, OPEN_VIEW,
                                             &error)))
      goto err_unlock2;

    if (share->is_view)
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
2657 2658 2659 2660 2661 2662 2663 2664 2665 2666
      /*
        If parent_l of the table_list is non null then a merge table
        has this view as child table, which is not supported.
      */
      if (table_list->parent_l)
      {
        my_error(ER_WRONG_MRG_TABLE, MYF(0));
        goto err_unlock;
      }
      
unknown's avatar
unknown committed
2667
      /*
2668 2669
        This table is a view. Validate its metadata version: in particular,
        that it was a view when the statement was prepared.
2670
      */
2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685
      if (check_and_update_table_version(thd, table_list, share))
        goto err_unlock;
      if (table_list->i_s_requested_object &  OPEN_TABLE_ONLY)
        goto err_unlock;

      /* Open view */
      if (open_new_frm(thd, share, alias,
                       (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
                               HA_GET_INDEX | HA_TRY_READ_ONLY),
                       READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD |
                       (flags & OPEN_VIEW_NO_PARSE), thd->open_options,
                       0, table_list, mem_root))
        goto err_unlock;

      /* TODO: Don't free this */
Konstantin Osipov's avatar
Konstantin Osipov committed
2686
      release_table_share(share);
2687 2688

      if (flags & OPEN_VIEW_NO_PARSE)
2689
      {
2690 2691 2692 2693 2694
        /*
          VIEW not really opened, only frm were read.
          Set 1 as a flag here
        */
        table_list->view= (LEX*)1;
2695
      }
unknown's avatar
unknown committed
2696
      else
unknown's avatar
VIEW  
unknown committed
2697
      {
2698
        DBUG_ASSERT(table_list->view);
unknown's avatar
VIEW  
unknown committed
2699
      }
2700 2701

      pthread_mutex_unlock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
2702
      DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
2703
    }
Konstantin Osipov's avatar
Konstantin Osipov committed
2704 2705 2706 2707 2708 2709
    /*
      Note that situation when we are trying to open a table for what
      was a view during previous execution of PS will be handled in by
      the caller. Here we should simply open our table even if
      TABLE_LIST::view is true.
    */
2710 2711 2712 2713 2714 2715 2716 2717 2718

    if (table_list->i_s_requested_object &  OPEN_VIEW_ONLY)
      goto err_unlock;

    /*
      We are going to to store extra reference to the share in MDL-subsystem
      so we need to increase reference counter;
    */
    reference_table_share(share);
Konstantin Osipov's avatar
Konstantin Osipov committed
2719
    mdl_ticket->set_cached_object(share, table_share_release_hook);
unknown's avatar
unknown committed
2720
  }
2721
  else
unknown's avatar
unknown committed
2722
  {
2723 2724 2725 2726 2727 2728 2729
    if (table_list->view)
    {
      DBUG_ASSERT(thd->m_reprepare_observer);
      check_and_update_table_version(thd, table_list, share);
      /* Always an error. */
      DBUG_ASSERT(thd->is_error());
      goto err_unlock;
unknown's avatar
unknown committed
2730
    }
2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745
    /* When we have cached TABLE_SHARE we know that is not a view. */
    if (table_list->i_s_requested_object &  OPEN_VIEW_ONLY)
      goto err_unlock;

    /*
      We are going to use this share for construction of new TABLE object
      so reference counter should be increased.
    */
    reference_table_share(share);
  }

  if (share->version != refresh_version)
  {
    if (!(flags & MYSQL_LOCK_IGNORE_FLUSH))
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
2746 2747 2748 2749 2750 2751 2752 2753 2754 2755
       /*
         We already have an MDL lock. But we have encountered an old
         version of table in the table definition cache which is possible
         when someone changes the table version directly in the cache
         without acquiring a metadata lock (e.g. this can happen during
         "rolling" FLUSH TABLE(S)).
         Note, that to avoid a "busywait" in this case, we have to wait
         separately in the caller for old table versions to go away
         (see tdc_wait_for_old_versions()).
       */
Konstantin Osipov's avatar
Konstantin Osipov committed
2756
      release_table_share(share);
2757
      pthread_mutex_unlock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
2758
      (void) ot_ctx->request_backoff_action(Open_table_context::OT_WAIT);
Konstantin Osipov's avatar
Konstantin Osipov committed
2759
      DBUG_RETURN(TRUE);
2760 2761 2762 2763 2764 2765 2766 2767 2768 2769
    }
    /* Force close at once after usage */
    thd->version= share->version;
  }

  if (!share->free_tables.is_empty())
  {
    table= share->free_tables.head();
    table_def_use_table(thd, table);
    /* We need to release share as we have EXTRA reference to it in our hands. */
Konstantin Osipov's avatar
Konstantin Osipov committed
2770
    release_table_share(share);
unknown's avatar
unknown committed
2771 2772 2773
  }
  else
  {
2774 2775 2776
    /* We have too many TABLE instances around let us try to get rid of them. */
    while (table_cache_count > table_cache_size && unused_tables)
      free_cache_entry(unused_tables);
unknown's avatar
unknown committed
2777

2778 2779 2780
    /* make a new table */
    if (!(table=(TABLE*) my_malloc(sizeof(*table),MYF(MY_WME))))
      goto err_unlock;
unknown's avatar
unknown committed
2781

2782 2783 2784 2785 2786 2787 2788 2789
    error= open_table_from_share(thd, share, alias,
                                 (uint) (HA_OPEN_KEYFILE |
                                         HA_OPEN_RNDFILE |
                                         HA_GET_INDEX |
                                         HA_TRY_READ_ONLY),
                                 (READ_KEYINFO | COMPUTE_TYPES |
                                  EXTRA_RECORD),
                                 thd->open_options, table, FALSE);
unknown's avatar
unknown committed
2790

2791 2792 2793 2794
    if (error)
    {
      my_free(table, MYF(0));

Konstantin Osipov's avatar
Konstantin Osipov committed
2795
      if (error == 7)
unknown's avatar
unknown committed
2796
      {
Konstantin Osipov's avatar
Konstantin Osipov committed
2797
        share->version= 0;
Konstantin Osipov's avatar
Konstantin Osipov committed
2798
        (void) ot_ctx->request_backoff_action(Open_table_context::OT_DISCOVER);
Konstantin Osipov's avatar
Konstantin Osipov committed
2799 2800 2801 2802
      }
      else if (share->crashed)
      {
        share->version= 0;
Konstantin Osipov's avatar
Konstantin Osipov committed
2803
        (void) ot_ctx->request_backoff_action(Open_table_context::OT_REPAIR);
unknown's avatar
unknown committed
2804
      }
unknown's avatar
unknown committed
2805

2806
      goto err_unlock;
2807
    }
unknown's avatar
unknown committed
2808

2809
    if (open_table_entry_fini(thd, share, table))
unknown's avatar
unknown committed
2810
    {
2811
      closefrm(table, 0);
2812
      my_free((uchar*)table, MYF(0));
2813
      goto err_unlock;
unknown's avatar
unknown committed
2814
    }
2815

2816 2817
    /* Add table to the share's used tables list. */
    table_def_add_used_table(thd, table);
unknown's avatar
unknown committed
2818 2819
  }

Konstantin Osipov's avatar
Konstantin Osipov committed
2820
  pthread_mutex_unlock(&LOCK_open);
2821

Konstantin Osipov's avatar
Konstantin Osipov committed
2822 2823 2824 2825 2826
  /*
    In CREATE TABLE .. If NOT EXISTS .. SELECT we have found that
    table exists now we should downgrade our exclusive metadata
    lock on this table to shared metadata lock.
  */
2827
  if (table_list->lock_strategy == TABLE_LIST::EXCLUSIVE_DOWNGRADABLE_MDL)
Konstantin Osipov's avatar
Konstantin Osipov committed
2828
    mdl_ticket->downgrade_exclusive_lock();
2829

Konstantin Osipov's avatar
Konstantin Osipov committed
2830
  table->mdl_ticket= mdl_ticket;
Konstantin Osipov's avatar
Konstantin Osipov committed
2831 2832 2833 2834

  table->next=thd->open_tables;		/* Link into simple list */
  thd->open_tables=table;

unknown's avatar
unknown committed
2835 2836 2837
  table->reginfo.lock_type=TL_READ;		/* Assume read */

 reset:
unknown's avatar
unknown committed
2838 2839
  DBUG_ASSERT(table->s->ref_count > 0 || table->s->tmp_table != NO_TMP_TABLE);

unknown's avatar
unknown committed
2840 2841
  if (thd->lex->need_correct_ident())
    table->alias_name_used= my_strcasecmp(table_alias_charset,
unknown's avatar
unknown committed
2842
                                          table->s->table_name.str, alias);
unknown's avatar
unknown committed
2843
  /* Fix alias if table name changes */
2844
  if (strcmp(table->alias, alias))
unknown's avatar
unknown committed
2845
  {
unknown's avatar
unknown committed
2846
    uint length=(uint) strlen(alias)+1;
2847 2848 2849
    table->alias= (char*) my_realloc((char*) table->alias, length,
                                     MYF(MY_WME));
    memcpy((char*) table->alias, alias, length);
unknown's avatar
unknown committed
2850 2851 2852 2853
  }
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
2854 2855
  table->null_row= table->maybe_null= 0;
  table->force_index= table->force_index_order= table->force_index_group= 0;
unknown's avatar
unknown committed
2856
  table->status=STATUS_NO_RECORD;
2857
  table->insert_values= 0;
unknown's avatar
unknown committed
2858 2859
  table->fulltext_searched= 0;
  table->file->ft_handler= 0;
2860
  table->reginfo.impossible_range= 0;
2861 2862 2863
  /* Catch wrong handling of the auto_increment_field_not_null. */
  DBUG_ASSERT(!table->auto_increment_field_not_null);
  table->auto_increment_field_not_null= FALSE;
unknown's avatar
unknown committed
2864
  if (table->timestamp_field)
2865
    table->timestamp_field_type= table->timestamp_field->get_auto_set_type();
unknown's avatar
unknown committed
2866
  table->pos_in_table_list= table_list;
unknown's avatar
VIEW  
unknown committed
2867
  table_list->updatable= 1; // It is not derived table nor non-updatable VIEW
2868
  table->clear_column_bitmaps();
Konstantin Osipov's avatar
Konstantin Osipov committed
2869
  table_list->table= table;
unknown's avatar
unknown committed
2870
  DBUG_ASSERT(table->key_read == 0);
Konstantin Osipov's avatar
Konstantin Osipov committed
2871 2872 2873
  /* Tables may be reused in a sub statement. */
  if (table->file->extra(HA_EXTRA_IS_ATTACHED_CHILDREN))
    table->file->extra(HA_EXTRA_DETACH_CHILDREN);
Konstantin Osipov's avatar
Konstantin Osipov committed
2874
  DBUG_RETURN(FALSE);
2875 2876

err_unlock:
Konstantin Osipov's avatar
Konstantin Osipov committed
2877
  release_table_share(share);
2878 2879
err_unlock2:
  pthread_mutex_unlock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
2880
  if (! (flags & MYSQL_OPEN_HAS_MDL_LOCK))
Konstantin Osipov's avatar
Konstantin Osipov committed
2881
    thd->mdl_context.release_lock(mdl_ticket);
Konstantin Osipov's avatar
Konstantin Osipov committed
2882

Konstantin Osipov's avatar
Konstantin Osipov committed
2883
  DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
2884 2885 2886
}


2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897
/**
   Find table in the list of open tables.

   @param list       List of TABLE objects to be inspected.
   @param db         Database name
   @param table_name Table name

   @return Pointer to the TABLE object found, 0 if no table found.
*/

TABLE *find_locked_table(TABLE *list, const char *db, const char *table_name)
unknown's avatar
unknown committed
2898 2899 2900 2901
{
  char	key[MAX_DBKEY_LENGTH];
  uint key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;

2902
  for (TABLE *table= list; table ; table=table->next)
unknown's avatar
unknown committed
2903
  {
unknown's avatar
unknown committed
2904 2905
    if (table->s->table_cache_key.length == key_length &&
	!memcmp(table->s->table_cache_key.str, key, key_length))
unknown's avatar
unknown committed
2906 2907 2908 2909 2910 2911
      return table;
  }
  return(0);
}


2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946
/**
   Find write locked instance of table in the list of open tables,
   emit error if no such instance found.

   @param thd        List of TABLE objects to be searched
   @param db         Database name.
   @param table_name Name of table.

   @return Pointer to write-locked TABLE instance, 0 - otherwise.
*/

TABLE *find_write_locked_table(TABLE *list, const char *db, const char *table_name)
{
  TABLE *tab= find_locked_table(list, db, table_name);

  if (!tab)
  {
    my_error(ER_TABLE_NOT_LOCKED, MYF(0), table_name);
    return 0;
  }
  else
  {
    while (tab->reginfo.lock_type < TL_WRITE_LOW_PRIORITY &&
           (tab= find_locked_table(tab->next, db, table_name)))
      continue;
    if (!tab)
    {
      my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0), table_name);
      return 0;
    }
  }
  return tab;
}


2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974
/**
   Find instance of TABLE with MDL_SHARED_UPGRADABLE or
   MDL_EXCLUSIVE lock from the list of open tables.

   @param list       List of TABLE objects to be searched
   @param db         Database name.
   @param table_name Name of table.

   @return Pointer to MDL_SHARED_UPGRADABLE or MDL_EXCLUSIVE
           TABLE instance, NULL otherwise.
*/

TABLE *find_table_for_mdl_upgrade(TABLE *list, const char *db,
                                  const char *table_name)
{
  TABLE *tab= find_locked_table(list, db, table_name);

  while (tab != NULL)
  {
    if (tab->mdl_ticket != NULL &&
        tab->mdl_ticket->is_upgradable_or_exclusive())
      return tab;
    tab= find_locked_table(tab->next, db, table_name);
  }
  return NULL;
}


Konstantin Osipov's avatar
Konstantin Osipov committed
2975 2976 2977
/***********************************************************************
  class Locked_tables_list implementation. Declared in sql_class.h
************************************************************************/
unknown's avatar
unknown committed
2978

Konstantin Osipov's avatar
Konstantin Osipov committed
2979 2980
/**
  Enter LTM_LOCK_TABLES mode.
unknown's avatar
unknown committed
2981

Konstantin Osipov's avatar
Konstantin Osipov committed
2982 2983 2984
  Enter the LOCK TABLES mode using all the tables that are
  currently open and locked in this connection.
  Initializes a TABLE_LIST instance for every locked table.
unknown's avatar
unknown committed
2985

Konstantin Osipov's avatar
Konstantin Osipov committed
2986 2987 2988
  @param  thd  thread handle

  @return TRUE if out of memory.
unknown's avatar
unknown committed
2989 2990
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
2991 2992
bool
Locked_tables_list::init_locked_tables(THD *thd)
unknown's avatar
unknown committed
2993
{
Konstantin Osipov's avatar
Konstantin Osipov committed
2994 2995
  DBUG_ASSERT(thd->locked_tables_mode == LTM_NONE);
  DBUG_ASSERT(m_locked_tables == NULL);
Konstantin Osipov's avatar
Konstantin Osipov committed
2996 2997
  DBUG_ASSERT(m_reopen_array == NULL);
  DBUG_ASSERT(m_locked_tables_count == 0);
Konstantin Osipov's avatar
Konstantin Osipov committed
2998

Konstantin Osipov's avatar
Konstantin Osipov committed
2999 3000
  for (TABLE *table= thd->open_tables; table;
       table= table->next, m_locked_tables_count++)
Konstantin Osipov's avatar
Konstantin Osipov committed
3001 3002 3003
  {
    TABLE_LIST *src_table_list= table->pos_in_table_list;
    char *db, *table_name, *alias;
Konstantin Osipov's avatar
Konstantin Osipov committed
3004 3005 3006
    size_t db_len= src_table_list->db_length;
    size_t table_name_len= src_table_list->table_name_length;
    size_t alias_len= strlen(src_table_list->alias);
Konstantin Osipov's avatar
Konstantin Osipov committed
3007 3008 3009 3010
    TABLE_LIST *dst_table_list;

    if (! multi_alloc_root(&m_locked_tables_root,
                           &dst_table_list, sizeof(*dst_table_list),
Konstantin Osipov's avatar
Konstantin Osipov committed
3011 3012 3013
                           &db, db_len + 1,
                           &table_name, table_name_len + 1,
                           &alias, alias_len + 1,
Konstantin Osipov's avatar
Konstantin Osipov committed
3014
                           NullS))
Konstantin Osipov's avatar
Konstantin Osipov committed
3015 3016 3017 3018 3019
    {
      unlock_locked_tables(0);
      return TRUE;
    }

Konstantin Osipov's avatar
Konstantin Osipov committed
3020 3021 3022
    memcpy(db, src_table_list->db, db_len + 1);
    memcpy(table_name, src_table_list->table_name, table_name_len + 1);
    memcpy(alias, src_table_list->alias, alias_len + 1);
Konstantin Osipov's avatar
Konstantin Osipov committed
3023 3024 3025 3026 3027 3028 3029
    /**
      Sic: remember the *actual* table level lock type taken, to
      acquire the exact same type in reopen_tables().
      E.g. if the table was locked for write, src_table_list->lock_type is
      TL_WRITE_DEFAULT, whereas reginfo.lock_type has been updated from
      thd->update_lock_default.
    */
Konstantin Osipov's avatar
Konstantin Osipov committed
3030 3031
    dst_table_list->init_one_table(db, db_len, table_name, table_name_len,
                                   alias,
Konstantin Osipov's avatar
Konstantin Osipov committed
3032 3033
                                   src_table_list->table->reginfo.lock_type);
    dst_table_list->table= table;
Konstantin Osipov's avatar
Konstantin Osipov committed
3034 3035
    dst_table_list->mdl_request.ticket= src_table_list->mdl_request.ticket;

Konstantin Osipov's avatar
Konstantin Osipov committed
3036 3037 3038 3039 3040
    /* Link last into the list of tables */
    *(dst_table_list->prev_global= m_locked_tables_last)= dst_table_list;
    m_locked_tables_last= &dst_table_list->next_global;
    table->pos_in_locked_tables= dst_table_list;
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056
  if (m_locked_tables_count)
  {
    /**
      Allocate an auxiliary array to pass to mysql_lock_tables()
      in reopen_tables(). reopen_tables() is a critical
      path and we don't want to complicate it with extra allocations.
    */
    m_reopen_array= (TABLE**)alloc_root(&m_locked_tables_root,
                                        sizeof(TABLE*) *
                                        (m_locked_tables_count+1));
    if (m_reopen_array == NULL)
    {
      unlock_locked_tables(0);
      return TRUE;
    }
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
3057
  thd->locked_tables_mode= LTM_LOCK_TABLES;
Konstantin Osipov's avatar
Konstantin Osipov committed
3058

Konstantin Osipov's avatar
Konstantin Osipov committed
3059 3060
  return FALSE;
}
unknown's avatar
unknown committed
3061

Konstantin Osipov's avatar
Konstantin Osipov committed
3062 3063
/**
  Leave LTM_LOCK_TABLES mode if it's been entered.
unknown's avatar
unknown committed
3064

Konstantin Osipov's avatar
Konstantin Osipov committed
3065
  Close all locked tables, free memory, and leave the mode.
3066

Konstantin Osipov's avatar
Konstantin Osipov committed
3067 3068
  @note This function is a no-op if we're not in LOCK TABLES.
*/
unknown's avatar
unknown committed
3069

Konstantin Osipov's avatar
Konstantin Osipov committed
3070 3071
void
Locked_tables_list::unlock_locked_tables(THD *thd)
unknown's avatar
unknown committed
3072

Konstantin Osipov's avatar
Konstantin Osipov committed
3073 3074
{
  if (thd)
3075
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088
    DBUG_ASSERT(!thd->in_sub_stmt &&
                !(thd->state_flags & Open_tables_state::BACKUPS_AVAIL));
    /*
      Sic: we must be careful to not close open tables if
      we're not in LOCK TABLES mode: unlock_locked_tables() is
      sometimes called implicitly, expecting no effect on
      open tables, e.g. from begin_trans().
    */
    if (thd->locked_tables_mode != LTM_LOCK_TABLES)
      return;

    for (TABLE_LIST *table_list= m_locked_tables;
         table_list; table_list= table_list->next_global)
3089
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
3090 3091 3092 3093 3094
      /*
        Clear the position in the list, the TABLE object will be
        returned to the table cache.
      */
      table_list->table->pos_in_locked_tables= NULL;
3095
    }
Konstantin Osipov's avatar
Konstantin Osipov committed
3096 3097 3098
    thd->locked_tables_mode= LTM_NONE;

    close_thread_tables(thd);
3099
  }
3100
  /*
Konstantin Osipov's avatar
Konstantin Osipov committed
3101 3102
    After closing tables we can free memory used for storing lock
    request for metadata locks and TABLE_LIST elements.
3103
  */
Konstantin Osipov's avatar
Konstantin Osipov committed
3104 3105 3106
  free_root(&m_locked_tables_root, MYF(0));
  m_locked_tables= NULL;
  m_locked_tables_last= &m_locked_tables;
Konstantin Osipov's avatar
Konstantin Osipov committed
3107 3108
  m_reopen_array= NULL;
  m_locked_tables_count= 0;
unknown's avatar
unknown committed
3109 3110 3111
}


3112
/**
Konstantin Osipov's avatar
Konstantin Osipov committed
3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129
  Unlink a locked table from the locked tables list, either
  temporarily or permanently.

  @param  thd        thread handle
  @param  table_list the element of locked tables list.
                     The implementation assumes that this argument
                     points to a TABLE_LIST element linked into
                     the locked tables list. Passing a TABLE_LIST
                     instance that is not part of locked tables
                     list will lead to a crash.
  @parma  remove_from_locked_tables
                      TRUE if the table is removed from the list
                      permanently.

  This function is a no-op if we're not under LOCK TABLES.

  @sa Locked_tables_list::reopen_tables()
unknown's avatar
unknown committed
3130
*/
unknown's avatar
unknown committed
3131

Konstantin Osipov's avatar
Konstantin Osipov committed
3132 3133 3134 3135

void Locked_tables_list::unlink_from_list(THD *thd,
                                          TABLE_LIST *table_list,
                                          bool remove_from_locked_tables)
unknown's avatar
unknown committed
3136
{
Konstantin Osipov's avatar
Konstantin Osipov committed
3137 3138 3139 3140 3141 3142
  /*
    If mode is not LTM_LOCK_TABLES, we needn't do anything. Moreover,
    outside this mode pos_in_locked_tables value is not trustworthy.
  */
  if (thd->locked_tables_mode != LTM_LOCK_TABLES)
    return;
3143

Konstantin Osipov's avatar
Konstantin Osipov committed
3144 3145 3146 3147 3148
  /*
    table_list must be set and point to pos_in_locked_tables of some
    table.
  */
  DBUG_ASSERT(table_list->table->pos_in_locked_tables == table_list);
3149

Konstantin Osipov's avatar
Konstantin Osipov committed
3150 3151 3152 3153 3154
  /* Clear the pointer, the table will be returned to the table cache. */
  table_list->table->pos_in_locked_tables= NULL;

  /* Mark the table as closed in the locked tables list. */
  table_list->table= NULL;
unknown's avatar
unknown committed
3155

Konstantin Osipov's avatar
Konstantin Osipov committed
3156 3157 3158 3159 3160 3161
  /*
    If the table is being dropped or renamed, remove it from
    the locked tables list (implicitly drop the LOCK TABLES lock
    on it).
  */
  if (remove_from_locked_tables)
unknown's avatar
unknown committed
3162
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
3163 3164 3165 3166 3167
    *table_list->prev_global= table_list->next_global;
    if (table_list->next_global == NULL)
      m_locked_tables_last= table_list->prev_global;
    else
      table_list->next_global->prev_global= table_list->prev_global;
unknown's avatar
unknown committed
3168 3169 3170
  }
}

unknown's avatar
unknown committed
3171
/**
Konstantin Osipov's avatar
Konstantin Osipov committed
3172 3173 3174 3175
  This is an attempt to recover (somewhat) in case of an error.
  If we failed to reopen a closed table, let's unlink it from the
  list and forget about it. From a user perspective that would look
  as if the server "lost" the lock on one of the locked tables.
3176

Konstantin Osipov's avatar
Konstantin Osipov committed
3177
  @note This function is a no-op if we're not under LOCK TABLES.
3178 3179
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
3180 3181
void Locked_tables_list::
unlink_all_closed_tables(THD *thd, MYSQL_LOCK *lock, size_t reopen_count)
3182
{
Konstantin Osipov's avatar
Konstantin Osipov committed
3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212
  /* If we managed to take a lock, unlock tables and free the lock. */
  if (lock)
    mysql_unlock_tables(thd, lock);
  /*
    If a failure happened in reopen_tables(), we may have succeeded
    reopening some tables, but not all.
    This works when the connection was killed in mysql_lock_tables().
  */
  if (reopen_count)
  {
    pthread_mutex_lock(&LOCK_open);
    while (reopen_count--)
    {
      /*
        When closing the table, we must remove it
        from thd->open_tables list.
        We rely on the fact that open_table() that was used
        in reopen_tables() always links the opened table
        to the beginning of the open_tables list.
      */
      DBUG_ASSERT(thd->open_tables == m_reopen_array[reopen_count]);

      thd->open_tables->pos_in_locked_tables->table= NULL;

      close_thread_table(thd, &thd->open_tables);
    }
    broadcast_refresh();
    pthread_mutex_unlock(&LOCK_open);
  }
  /* Exclude all closed tables from the LOCK TABLES list. */
Konstantin Osipov's avatar
Konstantin Osipov committed
3213 3214
  for (TABLE_LIST *table_list= m_locked_tables; table_list; table_list=
       table_list->next_global)
3215
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
3216
    if (table_list->table == NULL)
3217
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
3218 3219 3220 3221
      /* Unlink from list. */
      *table_list->prev_global= table_list->next_global;
      if (table_list->next_global == NULL)
        m_locked_tables_last= table_list->prev_global;
3222
      else
Konstantin Osipov's avatar
Konstantin Osipov committed
3223
        table_list->next_global->prev_global= table_list->prev_global;
3224 3225 3226 3227 3228
    }
  }
}


unknown's avatar
unknown committed
3229
/**
Konstantin Osipov's avatar
Konstantin Osipov committed
3230 3231
  Reopen the tables locked with LOCK TABLES and temporarily closed
  by a DDL statement or FLUSH TABLES.
unknown's avatar
unknown committed
3232

Konstantin Osipov's avatar
Konstantin Osipov committed
3233
  @note This function is a no-op if we're not under LOCK TABLES.
unknown's avatar
unknown committed
3234

Konstantin Osipov's avatar
Konstantin Osipov committed
3235 3236 3237 3238
  @return TRUE if an error reopening the tables. May happen in
               case of some fatal system error only, e.g. a disk
               corruption, out of memory or a serious bug in the
               locking.
unknown's avatar
unknown committed
3239 3240
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
3241 3242
bool
Locked_tables_list::reopen_tables(THD *thd)
unknown's avatar
unknown committed
3243
{
Konstantin Osipov's avatar
Konstantin Osipov committed
3244
  Open_table_context ot_ctx_unused(thd);
Konstantin Osipov's avatar
Konstantin Osipov committed
3245
  bool lt_refresh_unused;
Konstantin Osipov's avatar
Konstantin Osipov committed
3246 3247 3248
  size_t reopen_count= 0;
  MYSQL_LOCK *lock;
  MYSQL_LOCK *merged_lock;
unknown's avatar
unknown committed
3249

Konstantin Osipov's avatar
Konstantin Osipov committed
3250 3251
  for (TABLE_LIST *table_list= m_locked_tables;
       table_list; table_list= table_list->next_global)
unknown's avatar
unknown committed
3252
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
3253 3254 3255 3256
    if (table_list->table)                      /* The table was not closed */
      continue;

    /* Links into thd->open_tables upon success */
Konstantin Osipov's avatar
Konstantin Osipov committed
3257
    if (open_table(thd, table_list, thd->mem_root, &ot_ctx_unused,
Konstantin Osipov's avatar
Konstantin Osipov committed
3258
                   MYSQL_OPEN_REOPEN))
unknown's avatar
unknown committed
3259
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
3260
      unlink_all_closed_tables(thd, 0, reopen_count);
Konstantin Osipov's avatar
Konstantin Osipov committed
3261
      return TRUE;
unknown's avatar
unknown committed
3262
    }
Konstantin Osipov's avatar
Konstantin Osipov committed
3263 3264 3265
    table_list->table->pos_in_locked_tables= table_list;
    /* See also the comment on lock type in init_locked_tables(). */
    table_list->table->reginfo.lock_type= table_list->lock_type;
Konstantin Osipov's avatar
Konstantin Osipov committed
3266 3267 3268 3269 3270 3271

    DBUG_ASSERT(reopen_count < m_locked_tables_count);
    m_reopen_array[reopen_count++]= table_list->table;
  }
  if (reopen_count)
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
3272
    thd->in_lock_tables= 1;
Konstantin Osipov's avatar
Konstantin Osipov committed
3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284
    /*
      We re-lock all tables with mysql_lock_tables() at once rather
      than locking one table at a time because of the case
      reported in Bug#45035: when the same table is present
      in the list many times, thr_lock.c fails to grant READ lock
      on a table that is already locked by WRITE lock, even if
      WRITE lock is taken by the same thread. If READ and WRITE
      lock are passed to thr_lock.c in the same list, everything
      works fine. Patching legacy code of thr_lock.c is risking to
      break something else.
    */
    lock= mysql_lock_tables(thd, m_reopen_array, reopen_count,
Konstantin Osipov's avatar
Konstantin Osipov committed
3285 3286
                            MYSQL_OPEN_REOPEN, &lt_refresh_unused);
    thd->in_lock_tables= 0;
Konstantin Osipov's avatar
Konstantin Osipov committed
3287 3288
    if (lock == NULL || (merged_lock=
                         mysql_lock_merge(thd->lock, lock)) == NULL)
3289
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
3290 3291 3292
      unlink_all_closed_tables(thd, lock, reopen_count);
      if (! thd->killed)
        my_error(ER_LOCK_DEADLOCK, MYF(0));
Konstantin Osipov's avatar
Konstantin Osipov committed
3293
      return TRUE;
3294
    }
Konstantin Osipov's avatar
Konstantin Osipov committed
3295
    thd->lock= merged_lock;
unknown's avatar
unknown committed
3296
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
3297
  return FALSE;
unknown's avatar
unknown committed
3298 3299
}

3300

3301
/*
3302
  Function to assign a new table map id to a table share.
3303 3304 3305

  PARAMETERS

3306
    share - Pointer to table share structure
3307

unknown's avatar
unknown committed
3308 3309 3310 3311 3312 3313 3314
  DESCRIPTION

    We are intentionally not checking that share->mutex is locked
    since this function should only be called when opening a table
    share and before it is entered into the table_def_cache (meaning
    that it cannot be fetched by another thread, even accidentally).

3315 3316
  PRE-CONDITION(S)

3317
    share is non-NULL
3318 3319 3320 3321
    The LOCK_open mutex is locked

  POST-CONDITION(S)

3322 3323 3324
    share->table_map_id is given a value that with a high certainty is
    not used by any other table (the only case where a table id can be
    reused is on wrap-around, which means more than 4 billion table
3325 3326
    share opens have been executed while one table was open all the
    time).
3327

3328
    share->table_map_id is not ~0UL.
3329
 */
3330 3331
static ulong last_table_id= ~0UL;

3332
void assign_new_table_id(TABLE_SHARE *share)
3333 3334
{

3335
  DBUG_ENTER("assign_new_table_id");
3336 3337

  /* Preconditions */
3338
  DBUG_ASSERT(share != NULL);
3339 3340 3341
  safe_mutex_assert_owner(&LOCK_open);

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

  /* Post conditions */
3352
  DBUG_ASSERT(share->table_map_id != ~0UL);
3353 3354 3355 3356

  DBUG_VOID_RETURN;
}

3357
#ifndef DBUG_OFF
3358
/* Cause a spurious statement reprepare for debug purposes. */
3359
static bool inject_reprepare(THD *thd)
3360 3361 3362 3363 3364 3365 3366 3367 3368
{
  if (thd->m_reprepare_observer && thd->stmt_arena->is_reprepared == FALSE)
  {
    thd->m_reprepare_observer->report_error(thd);
    return TRUE;
  }

  return FALSE;
}
3369
#endif
3370

unknown's avatar
unknown committed
3371 3372 3373 3374
/**
  Compare metadata versions of an element obtained from the table
  definition cache and its corresponding node in the parse tree.

3375
  @details If the new and the old values mismatch, invoke
unknown's avatar
unknown committed
3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389
  Metadata_version_observer.
  At prepared statement prepare, all TABLE_LIST version values are
  NULL and we always have a mismatch. But there is no observer set
  in THD, and therefore no error is reported. Instead, we update
  the value in the parse tree, effectively recording the original
  version.
  At prepared statement execute, an observer may be installed.  If
  there is a version mismatch, we push an error and return TRUE.

  For conventional execution (no prepared statements), the
  observer is never installed.

  @sa Execute_observer
  @sa check_prepared_statement() to see cases when an observer is installed
3390 3391
  @sa TABLE_LIST::is_table_ref_id_equal()
  @sa TABLE_SHARE::get_table_ref_id()
unknown's avatar
unknown committed
3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402

  @param[in]      thd         used to report errors
  @param[in,out]  tables      TABLE_LIST instance created by the parser
                              Metadata version information in this object
                              is updated upon success.
  @param[in]      table_share an element from the table definition cache

  @retval  TRUE  an error, which has been reported
  @retval  FALSE success, version in TABLE_LIST has been updated
*/

3403
static bool
unknown's avatar
unknown committed
3404 3405 3406
check_and_update_table_version(THD *thd,
                               TABLE_LIST *tables, TABLE_SHARE *table_share)
{
3407
  if (! tables->is_table_ref_id_equal(table_share))
unknown's avatar
unknown committed
3408
  {
3409 3410
    if (thd->m_reprepare_observer &&
        thd->m_reprepare_observer->report_error(thd))
unknown's avatar
unknown committed
3411 3412 3413 3414 3415 3416
    {
      /*
        Version of the table share is different from the
        previous execution of the prepared statement, and it is
        unacceptable for this SQLCOM. Error has been reported.
      */
3417
      DBUG_ASSERT(thd->is_error());
unknown's avatar
unknown committed
3418 3419
      return TRUE;
    }
3420
    /* Always maintain the latest version and type */
3421
    tables->set_table_ref_id(table_share);
unknown's avatar
unknown committed
3422
  }
3423

3424
  DBUG_EXECUTE_IF("reprepare_each_statement", return inject_reprepare(thd););
3425

unknown's avatar
unknown committed
3426 3427 3428
  return FALSE;
}

3429

3430 3431
/**
   Open view by getting its definition from disk (and table cache in future).
3432

3433 3434 3435 3436 3437 3438 3439
   @param thd               Thread handle
   @param table_list        TABLE_LIST with db, table_name & belong_to_view
   @param alias             Alias name
   @param cache_key         Key for table definition cache
   @param cache_key_length  Length of cache_key
   @param mem_root          Memory to be used for .frm parsing.
   @param flags             Flags which modify how we open the view
3440

3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469
   @todo This function is needed for special handling of views under
         LOCK TABLES. We probably should get rid of it in long term.

   @return FALSE if success, TRUE - otherwise.
*/

bool tdc_open_view(THD *thd, TABLE_LIST *table_list, const char *alias,
                   char *cache_key, uint cache_key_length,
                   MEM_ROOT *mem_root, uint flags)
{
  TABLE not_used;
  int error;
  TABLE_SHARE *share;

  pthread_mutex_lock(&LOCK_open);

  if (!(share= get_table_share_with_create(thd, table_list, cache_key,
                                           cache_key_length, 
                                           OPEN_VIEW, &error)))
    goto err;

  if (share->is_view &&
      !open_new_frm(thd, share, alias,
                    (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
                            HA_GET_INDEX | HA_TRY_READ_ONLY),
                    READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD |
                    flags, thd->open_options, &not_used, table_list,
                    mem_root))
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
3470
    release_table_share(share);
3471 3472 3473 3474 3475
    pthread_mutex_unlock(&LOCK_open);
    return FALSE;
  }

  my_error(ER_WRONG_OBJECT, MYF(0), share->db.str, share->table_name.str, "VIEW");
Konstantin Osipov's avatar
Konstantin Osipov committed
3476
  release_table_share(share);
3477 3478 3479 3480 3481 3482 3483
err:
  pthread_mutex_unlock(&LOCK_open);
  return TRUE;
}


/**
Konstantin Osipov's avatar
Konstantin Osipov committed
3484 3485
   Finalize the process of TABLE creation by loading table triggers
   and taking action if a HEAP table content was emptied implicitly.
3486 3487 3488 3489 3490 3491 3492 3493 3494
*/

static bool open_table_entry_fini(THD *thd, TABLE_SHARE *share, TABLE *entry)
{

  if (Table_triggers_list::check_n_load(thd, share->db.str,
                                        share->table_name.str, entry, 0))
    return TRUE;

unknown's avatar
unknown committed
3495 3496 3497 3498 3499 3500 3501 3502 3503 3504
  /*
    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;
unknown's avatar
unknown committed
3505 3506
      uint query_buf_size= 20 + share->db.length + share->table_name.length +1;
      if ((query= (char*) my_malloc(query_buf_size,MYF(MY_WME))))
unknown's avatar
unknown committed
3507
      {
3508
        /* this DELETE FROM is needed even with row-based binlogging */
unknown's avatar
unknown committed
3509
        end = strxmov(strmov(query, "DELETE FROM `"),
unknown's avatar
unknown committed
3510
                      share->db.str,"`.`",share->table_name.str,"`", NullS);
3511
        int errcode= query_error_code(thd, TRUE);
3512
        thd->binlog_query(THD::STMT_QUERY_TYPE,
3513
                          query, (ulong)(end-query),
3514
                          FALSE, FALSE, errcode);
unknown's avatar
unknown committed
3515 3516 3517 3518 3519 3520 3521 3522 3523
        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).
        */
unknown's avatar
unknown committed
3524 3525
        sql_print_error("When opening HEAP table, could not allocate memory "
                        "to write 'DELETE FROM `%s`.`%s`' to the binary log",
3526
                        share->db.str, share->table_name.str);
3527
        delete entry->triggers;
3528
        return TRUE;
unknown's avatar
unknown committed
3529 3530
      }
    }
unknown's avatar
unknown committed
3531
  }
3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572
  return FALSE;
}


/**
   Auxiliary routine which is used for performing automatical table repair.
*/

static bool auto_repair_table(THD *thd, TABLE_LIST *table_list)
{
  char	cache_key[MAX_DBKEY_LENGTH];
  uint	cache_key_length;
  TABLE_SHARE *share;
  TABLE *entry;
  int not_used;
  bool result= FALSE;

  cache_key_length= create_table_def_key(thd, cache_key, table_list, 0);

  thd->clear_error();

  pthread_mutex_lock(&LOCK_open);

  if (!(share= get_table_share_with_create(thd, table_list, cache_key,
                                           cache_key_length,
                                           OPEN_VIEW, &not_used)))
  {
    pthread_mutex_unlock(&LOCK_open);
    return TRUE;
  }

  if (share->is_view)
    goto end_with_lock_open;

  if (!(entry= (TABLE*)my_malloc(sizeof(TABLE), MYF(MY_WME))))
  {
    result= TRUE;
    goto end_with_lock_open;
  }
  share->version= 0;
  pthread_mutex_unlock(&LOCK_open);
unknown's avatar
unknown committed
3573

3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601
  if (open_table_from_share(thd, share, table_list->alias,
                            (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
                                    HA_GET_INDEX |
                                    HA_TRY_READ_ONLY),
                            READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
                            ha_open_options | HA_OPEN_FOR_REPAIR,
                            entry, FALSE) || ! entry->file ||
      (entry->file->is_crashed() && entry->file->ha_check_and_repair(thd)))
  {
    /* Give right error message */
    thd->clear_error();
    my_error(ER_NOT_KEYFILE, MYF(0), share->table_name.str, my_errno);
    sql_print_error("Couldn't repair table: %s.%s", share->db.str,
                    share->table_name.str);
    if (entry->file)
      closefrm(entry, 0);
    result= TRUE;
  }
  else
  {
    thd->clear_error();			// Clear error message
    closefrm(entry, 0);
  }
  my_free(entry, MYF(0));

  pthread_mutex_lock(&LOCK_open);

end_with_lock_open:
Konstantin Osipov's avatar
Konstantin Osipov committed
3602
  release_table_share(share);
3603 3604 3605 3606 3607
  pthread_mutex_unlock(&LOCK_open);
  return result;
}


Konstantin Osipov's avatar
Konstantin Osipov committed
3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644
/** Open_table_context */

Open_table_context::Open_table_context(THD *thd)
  :m_action(OT_NO_ACTION),
  m_can_deadlock(thd->in_multi_stmt_transaction() &&
                 thd->mdl_context.has_locks())
{}


/**
  Check if we can back-off and set back off action if we can.
  Otherwise report and return error.

  @retval  TRUE if back-off is impossible.
  @retval  FALSE if we can back off. Back off action has been set.
*/

bool
Open_table_context::
request_backoff_action(enum_open_table_action action_arg)
{
  /*
    We have met a exclusive metadata lock or a old version of
    table and we are inside a transaction that already hold locks.
    We can't follow the locking protocol in this scenario as it
    might lead to deadlocks.
  */
  if (m_can_deadlock)
  {
    my_error(ER_LOCK_DEADLOCK, MYF(0));
    return TRUE;
  }
  m_action= action_arg;
  return FALSE;
}


3645
/**
Konstantin Osipov's avatar
Konstantin Osipov committed
3646
   Recover from failed attempt ot open table by performing requested action.
3647 3648 3649 3650 3651

   @param  thd     Thread context
   @param  table   Table list element for table that caused problem
   @param  action  Type of action requested by failed open_table() call

Konstantin Osipov's avatar
Konstantin Osipov committed
3652 3653
   @pre This function should be called only with "action" != OT_NO_ACTION.

3654 3655 3656 3657
   @retval FALSE - Success. One should try to open tables once again.
   @retval TRUE  - Error
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
3658 3659 3660
bool
Open_table_context::
recover_from_failed_open_table_attempt(THD *thd, TABLE_LIST *table)
3661 3662
{
  bool result= FALSE;
Konstantin Osipov's avatar
Konstantin Osipov committed
3663 3664
  /* Execute the action. */
  switch (m_action)
3665
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
3666 3667 3668
    case OT_WAIT:
      result= (thd->mdl_context.wait_for_locks(&m_mdl_requests) ||
               tdc_wait_for_old_versions(thd, &m_mdl_requests));
3669 3670
      break;
    case OT_DISCOVER:
Konstantin Osipov's avatar
Konstantin Osipov committed
3671
      {
Konstantin Osipov's avatar
Konstantin Osipov committed
3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685
        MDL_request mdl_xlock_request(&table->mdl_request);
        mdl_xlock_request.set_type(MDL_EXCLUSIVE);
        if ((result=
             thd->mdl_context.acquire_exclusive_lock(&mdl_xlock_request)))
          break;
        pthread_mutex_lock(&LOCK_open);
        tdc_remove_table(thd, TDC_RT_REMOVE_ALL, table->db, table->table_name);
        ha_create_table_from_engine(thd, table->db, table->table_name);
        pthread_mutex_unlock(&LOCK_open);

        thd->warning_info->clear_warning_info(thd->query_id);
        thd->clear_error();                 // Clear error message
        thd->mdl_context.release_lock(mdl_xlock_request.ticket);
        break;
Konstantin Osipov's avatar
Konstantin Osipov committed
3686
      }
3687
    case OT_REPAIR:
Konstantin Osipov's avatar
Konstantin Osipov committed
3688
      {
Konstantin Osipov's avatar
Konstantin Osipov committed
3689 3690 3691 3692 3693
        MDL_request mdl_xlock_request(&table->mdl_request);
        mdl_xlock_request.set_type(MDL_EXCLUSIVE);
        if ((result=
             thd->mdl_context.acquire_exclusive_lock(&mdl_xlock_request)))
          break;
3694

Konstantin Osipov's avatar
Konstantin Osipov committed
3695 3696 3697 3698 3699 3700 3701 3702
        pthread_mutex_lock(&LOCK_open);
        tdc_remove_table(thd, TDC_RT_REMOVE_ALL, table->db, table->table_name);
        pthread_mutex_unlock(&LOCK_open);

        result= auto_repair_table(thd, table);
        thd->mdl_context.release_lock(mdl_xlock_request.ticket);
        break;
      }
3703 3704 3705
    default:
      DBUG_ASSERT(0);
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
3706 3707 3708 3709
  /* Remove all old requests, they will be re-added. */
  m_mdl_requests.empty();
  /* Prepare for possible another back-off. */
  m_action= OT_NO_ACTION;
3710
  return result;
unknown's avatar
unknown committed
3711 3712
}

3713

3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745
/*
  Return a appropriate read lock type given a table object.

  @param thd Thread context
  @param table TABLE object for table to be locked

  @remark Due to a statement-based replication limitation, statements such as
          INSERT INTO .. SELECT FROM .. and CREATE TABLE .. SELECT FROM need
          to grab a TL_READ_NO_INSERT lock on the source table in order to
          prevent the replication of a concurrent statement that modifies the
          source table. If such a statement gets applied on the slave before
          the INSERT .. SELECT statement finishes, data on the master could
          differ from data on the slave and end-up with a discrepancy between
          the binary log and table state. Furthermore, this does not apply to
          I_S and log tables as it's always unsafe to replicate such tables
          under statement-based replication as the table on the slave might
          contain other data (ie: general_log is enabled on the slave). The
          statement will be marked as unsafe for SBR in decide_logging_format().
*/

thr_lock_type read_lock_type_for_table(THD *thd, TABLE *table)
{
  bool log_on= mysql_bin_log.is_open() && (thd->options & OPTION_BIN_LOG);
  ulong binlog_format= thd->variables.binlog_format;
  if ((log_on == FALSE) || (binlog_format == BINLOG_FORMAT_ROW) ||
      (table->s->table_category == TABLE_CATEGORY_PERFORMANCE))
    return TL_READ;
  else
    return TL_READ_NO_INSERT;
}


unknown's avatar
unknown committed
3746
/*
Konstantin Osipov's avatar
Konstantin Osipov committed
3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809
  Perform steps of prelocking algorithm for elements of the
  prelocking set other than tables. E.g. cache routines and, if
  prelocking strategy prescribes so, extend the prelocking set with
  tables and routines used by them.

  @param[in]  thd                  Thread context.
  @param[in]  prelocking_ctx       Prelocking context.
  @param[in]  start                First element in the list representing
                                   subset of the prelocking set to be
                                   processed.
  @param[in]  prelocking_strategy  Strategy which specifies how the
                                   prelocking set should be extended when
                                   one of its elements is processed.
  @param[out] need_prelocking      Set to TRUE  if it was detected that this
                                   statement will require prelocked mode for
                                   its execution, not touched otherwise.

  @retval FALSE  Success.
  @retval TRUE   Failure (Conflicting metadata lock, OOM, other errors).
*/

static bool
open_routines(THD *thd, Query_tables_list *prelocking_ctx,
              Sroutine_hash_entry *start,
              Prelocking_strategy *prelocking_strategy,
              bool *need_prelocking)
{
  DBUG_ENTER("open_routines");

  for (Sroutine_hash_entry *rt= start; rt; rt= rt->next)
  {
    int type= rt->key.str[0];

    switch (type)
    {
    case TYPE_ENUM_FUNCTION:
    case TYPE_ENUM_PROCEDURE:
      {
        sp_name name(thd, rt->key.str, rt->key.length);
        sp_head *sp;

        if (sp_cache_routine(thd, type, &name, &sp))
          DBUG_RETURN(TRUE);

        if (sp)
        {
          prelocking_strategy->handle_routine(thd, prelocking_ctx, rt, sp,
                                              need_prelocking);
        }
      }
      break;
    case TYPE_ENUM_TRIGGER:
      break;
    default:
      /* Impossible type value. */
      DBUG_ASSERT(0);
    }
  }
  DBUG_RETURN(FALSE);
}


/**
unknown's avatar
unknown committed
3810 3811
  Open all tables in list

Konstantin Osipov's avatar
Konstantin Osipov committed
3812 3813 3814 3815 3816 3817 3818 3819 3820
  @param[in]     thd      Thread context.
  @param[in,out] start    List of tables to be open (it can be adjusted for
                          statement that uses tables only implicitly, e.g.
                          for "SELECT f1()").
  @param[out]    counter  Number of tables which were open.
  @param[in]     flags    Bitmap of flags to modify how the tables will be
                          open, see open_table() description for details.
  @param[in]     prelocking_strategy  Strategy which specifies how prelocking
                                      algorithm should work for this statement.
unknown's avatar
unknown committed
3821

Konstantin Osipov's avatar
Konstantin Osipov committed
3822 3823 3824 3825 3826 3827
  @note
    Unless we are already in prelocked mode and prelocking strategy prescribes
    so this function will also precache all SP/SFs explicitly or implicitly
    (via views and triggers) used by the query and add tables needed for their
    execution to table list. Statement that uses SFs, invokes triggers or
    requires foreign key checks will be marked as requiring prelocking.
3828 3829 3830 3831 3832 3833
    Prelocked mode will be enabled for such query during lock_tables() call.

    If query for which we are opening tables is already marked as requiring
    prelocking it won't do such precaching and will simply reuse table list
    which is already built.

Konstantin Osipov's avatar
Konstantin Osipov committed
3834 3835
  @retval  FALSE  Success.
  @retval  TRUE   Error, reported.
unknown's avatar
unknown committed
3836 3837
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
3838
bool open_tables(THD *thd, TABLE_LIST **start, uint *counter, uint flags,
Konstantin Osipov's avatar
Konstantin Osipov committed
3839
                Prelocking_strategy *prelocking_strategy)
unknown's avatar
unknown committed
3840
{
3841
  TABLE_LIST *tables= NULL;
Konstantin Osipov's avatar
Konstantin Osipov committed
3842
  Open_table_context ot_ctx(thd);
Konstantin Osipov's avatar
Konstantin Osipov committed
3843
  bool error= FALSE;
unknown's avatar
VIEW  
unknown committed
3844
  MEM_ROOT new_frm_mem;
3845 3846
  /* Also used for indicating that prelocking is need */
  TABLE_LIST **query_tables_last_own;
3847
  bool safe_to_ignore_table;
3848
  DBUG_ENTER("open_tables");
unknown's avatar
VIEW  
unknown committed
3849 3850 3851 3852
  /*
    temporary mem_root for new .frm parsing.
    TODO: variables for size
  */
3853
  init_sql_alloc(&new_frm_mem, 8024, 8024);
unknown's avatar
unknown committed
3854

3855
  thd->current_tablenr= 0;
unknown's avatar
unknown committed
3856
 restart:
unknown's avatar
unknown committed
3857
  *counter= 0;
3858
  query_tables_last_own= 0;
3859
  thd_proc_info(thd, "Opening tables");
3860

3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872
  /*
    Close HANDLER tables which are marked for flush or against which there
    are pending exclusive metadata locks. Note that we do this not to avoid
    deadlocks (calls to mysql_ha_flush() in mdl_wait_for_locks() and
    tdc_wait_for_old_version() are enough for this) but in order to have
    a point during statement execution at which such HANDLERs are closed
    even if they don't create problems for current thread (i.e. to avoid
    having DDL blocked by HANDLERs opened for long time).
  */
  if (thd->handler_tables)
    mysql_ha_flush(thd);

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

Konstantin Osipov's avatar
Konstantin Osipov committed
3879 3880
  if (thd->locked_tables_mode <= LTM_LOCK_TABLES &&
      !thd->lex->requires_prelocking() &&
unknown's avatar
unknown committed
3881
      thd->lex->uses_stored_routines())
3882
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
3883
    bool need_prelocking= FALSE;
3884
    TABLE_LIST **save_query_tables_last= thd->lex->query_tables_last;
3885 3886 3887

    DBUG_ASSERT(thd->lex->query_tables == *start);

Konstantin Osipov's avatar
Konstantin Osipov committed
3888 3889 3890 3891
    error= open_routines(thd, thd->lex,
                         (Sroutine_hash_entry *)thd->lex->sroutines_list.first,
                         prelocking_strategy, &need_prelocking);
    if (error)
3892
    {
3893 3894 3895 3896 3897
      /*
        Serious error during reading stored routines from mysql.proc table.
        Something's wrong with the table or its contents, and an error has
        been emitted; we must abort.
      */
3898 3899
      goto err;
    }
3900
    else if (need_prelocking)
3901 3902 3903 3904 3905 3906
    {
      query_tables_last_own= save_query_tables_last;
      *start= thd->lex->query_tables;
    }
  }

3907 3908 3909 3910
  /*
    For every table in the list of tables to open, try to find or open
    a table.
  */
3911
  for (tables= *start; tables ;tables= tables->next_global)
unknown's avatar
unknown committed
3912
  {
unknown's avatar
unknown committed
3913
    safe_to_ignore_table= FALSE;
3914

unknown's avatar
unknown committed
3915 3916 3917
    /*
      Ignore placeholders for derived tables. After derived tables
      processing, link to created temporary table will be put here.
3918 3919
      If this is derived table for view then we still want to process
      routines used by this view.
unknown's avatar
unknown committed
3920 3921
     */
    if (tables->derived)
3922
    {
3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934
      if (!tables->view)
        continue;
      /*
        We restore view's name and database wiped out by derived tables
        processing and fall back to standard open process in order to
        obtain proper metadata locks and do other necessary steps like
        stored routine processing.
      */
      tables->db= tables->view_db.str;
      tables->db_length= tables->view_db.length;
      tables->table_name= tables->view_name.str;
      tables->table_name_length= tables->view_name.length;
3935
    }
3936 3937 3938 3939 3940 3941
    /*
      If this TABLE_LIST object is a placeholder for an information_schema
      table, create a temporary table to represent the information_schema
      table in the query. Do not fill it yet - will be filled during
      execution.
    */
3942 3943
    if (tables->schema_table)
    {
unknown's avatar
unknown committed
3944 3945 3946 3947 3948 3949 3950 3951 3952 3953
      /*
        If this information_schema table is merged into a mergeable
        view, ignore it for now -- it will be filled when its respective
        TABLE_LIST is processed. This code works only during re-execution.
      */
      if (tables->view)
        goto process_view_routines;
      if (!mysql_schema_table(thd, thd->lex, tables) &&
          !check_and_update_table_version(thd, tables, tables->table->s))
      {
3954
        continue;
unknown's avatar
unknown committed
3955
      }
Konstantin Osipov's avatar
Konstantin Osipov committed
3956
      DBUG_RETURN(TRUE);
3957
    }
3958 3959
    DBUG_PRINT("tcache", ("opening table: '%s'.'%s'  item: 0x%lx",
                          tables->db, tables->table_name, (long) tables));
unknown's avatar
unknown committed
3960
    (*counter)++;
3961

Konstantin Osipov's avatar
Konstantin Osipov committed
3962 3963 3964 3965
    /* Not a placeholder: must be a base table or a view. Let us open it. */
    DBUG_ASSERT(!tables->table);

    if (tables->prelocking_placeholder)
3966
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
3967 3968 3969 3970 3971 3972 3973 3974
      /*
        For the tables added by the pre-locking code, attempt to open
        the table but fail silently if the table does not exist.
        The real failure will occur when/if a statement attempts to use
        that table.
      */
      Prelock_error_handler prelock_handler;
      thd->push_internal_handler(& prelock_handler);
Konstantin Osipov's avatar
Konstantin Osipov committed
3975
      error= open_table(thd, tables, &new_frm_mem, &ot_ctx, flags);
Konstantin Osipov's avatar
Konstantin Osipov committed
3976 3977
      thd->pop_internal_handler();
      safe_to_ignore_table= prelock_handler.safely_trapped_errors();
3978
    }
3979
    else
Konstantin Osipov's avatar
Konstantin Osipov committed
3980
      error= open_table(thd, tables, &new_frm_mem, &ot_ctx, flags);
3981

Konstantin Osipov's avatar
Konstantin Osipov committed
3982
    free_root(&new_frm_mem, MYF(MY_KEEP_PREALLOC));
unknown's avatar
VIEW  
unknown committed
3983

Konstantin Osipov's avatar
Konstantin Osipov committed
3984 3985
    if (error)
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
3986
      if (ot_ctx.can_recover_from_failed_open_table())
unknown's avatar
unknown committed
3987
      {
3988
        /*
Konstantin Osipov's avatar
Konstantin Osipov committed
3989 3990 3991 3992 3993
          We have met exclusive metadata lock or old version of table. Now we
          have to close all tables which are not up to date/release metadata
          locks. We also have to throw away set of prelocked tables (and thus
          close tables from this set that were open by now) since it possible
          that one of tables which determined its content was changed.
3994 3995 3996 3997 3998 3999 4000

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

          In order to prepare for recalculation of set of prelocked tables
          we pretend that we have finished calculation which we were doing
          currently.
4001 4002 4003
        */
        if (query_tables_last_own)
          thd->lex->mark_as_requiring_prelocking(query_tables_last_own);
Konstantin Osipov's avatar
Konstantin Osipov committed
4004
        close_tables_for_reopen(thd, start);
4005 4006 4007 4008 4009
        /*
          Here we rely on the fact that 'tables' still points to the valid
          TABLE_LIST element. Altough currently this assumption is valid
          it may change in future.
        */
Konstantin Osipov's avatar
Konstantin Osipov committed
4010
        if (ot_ctx.recover_from_failed_open_table_attempt(thd, tables))
4011
          goto err;
Konstantin Osipov's avatar
Konstantin Osipov committed
4012 4013

        error= FALSE;
unknown's avatar
unknown committed
4014 4015
	goto restart;
      }
4016 4017 4018 4019 4020

      if (safe_to_ignore_table)
      {
        DBUG_PRINT("info", ("open_table: ignoring table '%s'.'%s'",
                            tables->db, tables->alias));
Konstantin Osipov's avatar
Konstantin Osipov committed
4021
        error= FALSE;
4022 4023
        continue;
      }
Konstantin Osipov's avatar
Konstantin Osipov committed
4024
      goto err;
unknown's avatar
unknown committed
4025
    }
Konstantin Osipov's avatar
Konstantin Osipov committed
4026 4027 4028 4029 4030 4031 4032 4033 4034

    /*
      We can't rely on simple check for TABLE_LIST::view to determine
      that this is a view since during re-execution we might reopen
      ordinary table in place of view and thus have TABLE_LIST::view
      set from repvious execution and TABLE_LIST::table set from
      current.
    */
    if (!tables->table && tables->view)
4035
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
4036 4037 4038
      /* VIEW placeholder */
      (*counter)--;

4039
      /*
Konstantin Osipov's avatar
Konstantin Osipov committed
4040 4041 4042 4043 4044 4045 4046 4047
        tables->next_global list consists of two parts:
        1) Query tables and underlying tables of views.
        2) Tables used by all stored routines that this statement invokes on
           execution.
        We need to know where the bound between these two parts is. If we've
        just opened a view, which was the last table in part #1, and it
        has added its base tables after itself, adjust the boundary pointer
        accordingly.
4048
      */
Konstantin Osipov's avatar
Konstantin Osipov committed
4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063
      if (query_tables_last_own == &(tables->next_global) &&
          tables->view->query_tables)
        query_tables_last_own= tables->view->query_tables_last;
      /*
        Let us free memory used by 'sroutines' hash here since we never
        call destructor for this LEX.
      */
      my_hash_free(&tables->view->sroutines);
      goto process_view_routines;
    }

    /*
      Special types of open can succeed but still don't set
      TABLE_LIST::table to anything.
    */
4064
    if (tables->open_strategy && !tables->table)
Konstantin Osipov's avatar
Konstantin Osipov committed
4065 4066 4067 4068
      continue;

    /*
      If we are not already in prelocked mode and extended table list is not
Konstantin Osipov's avatar
Konstantin Osipov committed
4069 4070 4071 4072 4073
      yet built we might have to build the prelocking set for this statement.

      Since currently no prelocking strategy prescribes doing anything for
      tables which are only read, we do below checks only if table is going
      to be changed.
Konstantin Osipov's avatar
Konstantin Osipov committed
4074 4075 4076 4077 4078
    */
    if (thd->locked_tables_mode <= LTM_LOCK_TABLES &&
        !thd->lex->requires_prelocking() &&
        tables->lock_type >= TL_WRITE_ALLOW_WRITE)
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110
      bool need_prelocking= FALSE;
      bool not_used;
      TABLE_LIST **save_query_tables_last= thd->lex->query_tables_last;
      Sroutine_hash_entry **sroutines_next= 
        (Sroutine_hash_entry **)thd->lex->sroutines_list.next;

      /*
        Extend statement's table list and the prelocking set with
        tables and routines according to the current prelocking
        strategy.

        For example, for DML statements we need to add tables and routines
        used by triggers which are going to be invoked for this element of
        table list and also add tables required for handling of foreign keys.
      */
      error= prelocking_strategy->handle_table(thd, thd->lex, tables,
                                               &need_prelocking);

      if (need_prelocking && ! query_tables_last_own)
        query_tables_last_own= save_query_tables_last;

      if (error)
        goto err;

      /*
        Process elements of the prelocking set which were added
        by the above invocation of Prelocking_strategy method.

        For example, if new element is a routine, cache it and then, if
        prelocking strategy prescribes so, add tables it uses to the table
        list and routines it might invoke to the prelocking set.
      */
Konstantin Osipov's avatar
Konstantin Osipov committed
4111 4112 4113
      error= open_routines(thd, thd->lex, *sroutines_next, prelocking_strategy,
                           &not_used);
      if (error)
Konstantin Osipov's avatar
Konstantin Osipov committed
4114
        goto err;
4115
    }
unknown's avatar
VIEW  
unknown committed
4116

Konstantin Osipov's avatar
Konstantin Osipov committed
4117
    if (tables->lock_type != TL_UNLOCK && ! thd->locked_tables_mode)
4118 4119 4120
    {
      if (tables->lock_type == TL_WRITE_DEFAULT)
        tables->table->reginfo.lock_type= thd->update_lock_default;
4121 4122 4123
      else if (tables->lock_type == TL_READ_DEFAULT)
        tables->table->reginfo.lock_type=
          read_lock_type_for_table(thd, tables->table);
4124
      else
4125 4126
        tables->table->reginfo.lock_type= tables->lock_type;
    }
unknown's avatar
unknown committed
4127
    tables->table->grant= tables->grant;
4128

4129
    /* Check and update metadata version of a base table. */
Konstantin Osipov's avatar
Konstantin Osipov committed
4130
    error= check_and_update_table_version(thd, tables, tables->table->s);
unknown's avatar
unknown committed
4131

Konstantin Osipov's avatar
Konstantin Osipov committed
4132 4133
    if (error)
      goto err;
Konstantin Osipov's avatar
Konstantin Osipov committed
4134 4135 4136 4137 4138 4139 4140 4141 4142
    /*
      After opening a MERGE table add the children to the query list of
      tables, so that they are opened too.
      Note that placeholders don't have the handler open.
    */
    /* MERGE tables need to access parent and child TABLE_LISTs. */
    DBUG_ASSERT(tables->table->pos_in_table_list == tables);
    /* Non-MERGE tables ignore this call. */
    if (tables->table->file->extra(HA_EXTRA_ADD_CHILDREN_LIST))
4143
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
4144
      error= TRUE;
4145 4146 4147
      goto err;
    }

4148 4149 4150 4151 4152
process_view_routines:
    /*
      Again we may need cache all routines used by this view and add
      tables used by them to table list.
    */
Konstantin Osipov's avatar
Konstantin Osipov committed
4153 4154
    if (tables->view &&
        thd->locked_tables_mode <= LTM_LOCK_TABLES &&
Konstantin Osipov's avatar
Konstantin Osipov committed
4155
        !thd->lex->requires_prelocking())
4156
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170
      bool need_prelocking= FALSE;
      bool not_used;
      TABLE_LIST **save_query_tables_last= thd->lex->query_tables_last;
      Sroutine_hash_entry **sroutines_next= 
        (Sroutine_hash_entry **)thd->lex->sroutines_list.next;

      error= prelocking_strategy->handle_view(thd, thd->lex, tables,
                                              &need_prelocking);

      if (need_prelocking && ! query_tables_last_own)
        query_tables_last_own= save_query_tables_last;

      if (error)
        goto err;
Konstantin Osipov's avatar
Konstantin Osipov committed
4171 4172 4173 4174 4175

      error= open_routines(thd, thd->lex, *sroutines_next, prelocking_strategy,
                           &not_used);

      if (error)
4176
      {
4177 4178
        /*
          Serious error during reading stored routines from mysql.proc table.
4179
          Something is wrong with the table or its contents, and an error has
4180 4181
          been emitted; we must abort.
        */
4182 4183
        goto err;
      }
4184
    }
unknown's avatar
unknown committed
4185
  }
4186

Konstantin Osipov's avatar
Konstantin Osipov committed
4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203
  /*
    After successful open of all tables, including MERGE parents and
    children, attach the children to their parents. At end of statement,
    the children are detached. Attaching and detaching are always done,
    even under LOCK TABLES.
  */
  for (tables= *start; tables; tables= tables->next_global)
  {
    TABLE *tbl= tables->table;

    /* Schema tables may not have a TABLE object here. */
    if (tbl && tbl->file->ht->db_type == DB_TYPE_MRG_MYISAM)
    {
      /* MERGE tables need to access parent and child TABLE_LISTs. */
      DBUG_ASSERT(tbl->pos_in_table_list == tables);
      if (tbl->file->extra(HA_EXTRA_ATTACH_CHILDREN))
      {
Konstantin Osipov's avatar
Konstantin Osipov committed
4204
        error= TRUE;
Konstantin Osipov's avatar
Konstantin Osipov committed
4205 4206 4207 4208 4209
        goto err;
      }
    }
  }

Konstantin Osipov's avatar
Konstantin Osipov committed
4210
err:
4211
  thd_proc_info(thd, 0);
4212
  free_root(&new_frm_mem, MYF(0));              // Free pre-alloced block
4213 4214 4215 4216

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

Konstantin Osipov's avatar
Konstantin Osipov committed
4217
  if (error && tables)
4218 4219 4220
  {
    tables->table= NULL;
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
4221 4222
  DBUG_PRINT("open_tables", ("returning: %d", (int) error));
  DBUG_RETURN(error);
unknown's avatar
unknown committed
4223 4224 4225
}


Konstantin Osipov's avatar
Konstantin Osipov committed
4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439
/**
  Defines how prelocking algorithm for DML statements should handle routines:
  - For CALL statements we do unrolling (i.e. open and lock tables for each
    sub-statement individually). So for such statements prelocking is enabled
    only if stored functions are used in parameter list and only for period
    during which we calculate values of parameters. Thus in this strategy we
    ignore procedure which is directly called by such statement and extend
    the prelocking set only with tables/functions used by SF called from the
    parameter list.
  - For any other statement any routine which is directly or indirectly called
    by statement is going to be executed in prelocked mode. So in this case we
    simply add all tables and routines used by it to the prelocking set.

  @param[in]  thd              Thread context.
  @param[in]  prelocking_ctx   Prelocking context of the statement.
  @param[in]  rt               Prelocking set element describing routine.
  @param[in]  sp               Routine body.
  @param[out] need_prelocking  Set to TRUE if method detects that prelocking
                               required, not changed otherwise.

  @retval FALSE  Success.
  @retval TRUE   Failure (OOM).
*/

bool DML_prelocking_strategy::
handle_routine(THD *thd, Query_tables_list *prelocking_ctx,
               Sroutine_hash_entry *rt, sp_head *sp, bool *need_prelocking)
{
  /*
    We assume that for any "CALL proc(...)" statement sroutines_list will
    have 'proc' as first element (it may have several, consider e.g.
    "proc(sp_func(...)))". This property is currently guaranted by the
    parser.
  */

  if (rt != (Sroutine_hash_entry*)prelocking_ctx->sroutines_list.first ||
      rt->key.str[0] != TYPE_ENUM_PROCEDURE)
  {
    *need_prelocking= TRUE;
    sp_update_stmt_used_routines(thd, prelocking_ctx, &sp->m_sroutines,
                                 rt->belong_to_view);
    (void)sp->add_used_tables_to_table_list(thd,
                                            &prelocking_ctx->query_tables_last,
                                            rt->belong_to_view);
  }
  sp->propagate_attributes(prelocking_ctx);
  return FALSE;
}


/**
  Defines how prelocking algorithm for DML statements should handle table list
  elements:
  - If table has triggers we should add all tables and routines
    used by them to the prelocking set.

  We do not need to acquire metadata locks on trigger names
  in DML statements, since all DDL statements
  that change trigger metadata always lock their
  subject tables.

  @param[in]  thd              Thread context.
  @param[in]  prelocking_ctx   Prelocking context of the statement.
  @param[in]  table_list       Table list element for table.
  @param[in]  sp               Routine body.
  @param[out] need_prelocking  Set to TRUE if method detects that prelocking
                               required, not changed otherwise.

  @retval FALSE  Success.
  @retval TRUE   Failure (OOM).
*/

bool DML_prelocking_strategy::
handle_table(THD *thd, Query_tables_list *prelocking_ctx,
             TABLE_LIST *table_list, bool *need_prelocking)
{
  /* We rely on a caller to check that table is going to be changed. */
  DBUG_ASSERT(table_list->lock_type >= TL_WRITE_ALLOW_WRITE);

  if (table_list->trg_event_map)
  {
    if (table_list->table->triggers)
    {
      *need_prelocking= TRUE;

      if (table_list->table->triggers->
          add_tables_and_routines_for_triggers(thd, prelocking_ctx, table_list))
        return TRUE;
    }
  }

  return FALSE;
}


/**
  Defines how prelocking algorithm for DML statements should handle view -
  all view routines should be added to the prelocking set.

  @param[in]  thd              Thread context.
  @param[in]  prelocking_ctx   Prelocking context of the statement.
  @param[in]  table_list       Table list element for view.
  @param[in]  sp               Routine body.
  @param[out] need_prelocking  Set to TRUE if method detects that prelocking
                               required, not changed otherwise.

  @retval FALSE  Success.
  @retval TRUE   Failure (OOM).
*/

bool DML_prelocking_strategy::
handle_view(THD *thd, Query_tables_list *prelocking_ctx,
            TABLE_LIST *table_list, bool *need_prelocking)
{
  if (table_list->view->uses_stored_routines())
  {
    *need_prelocking= TRUE;

    sp_update_stmt_used_routines(thd, prelocking_ctx,
                                 &table_list->view->sroutines_list,
                                 table_list->top_table());
  }
  return FALSE;
}


/**
  Defines how prelocking algorithm for LOCK TABLES statement should handle
  table list elements.

  @param[in]  thd              Thread context.
  @param[in]  prelocking_ctx   Prelocking context of the statement.
  @param[in]  table_list       Table list element for table.
  @param[in]  sp               Routine body.
  @param[out] need_prelocking  Set to TRUE if method detects that prelocking
                               required, not changed otherwise.

  @retval FALSE  Success.
  @retval TRUE   Failure (OOM).
*/

bool Lock_tables_prelocking_strategy::
handle_table(THD *thd, Query_tables_list *prelocking_ctx,
             TABLE_LIST *table_list, bool *need_prelocking)
{
  if (DML_prelocking_strategy::handle_table(thd, prelocking_ctx, table_list,
                                            need_prelocking))
    return TRUE;

  /* We rely on a caller to check that table is going to be changed. */
  DBUG_ASSERT(table_list->lock_type >= TL_WRITE_ALLOW_WRITE);

  return FALSE;
}


/**
  Defines how prelocking algorithm for ALTER TABLE statement should handle
  routines - do nothing as this statement is not supposed to call routines.

  We still can end up in this method when someone tries
  to define a foreign key referencing a view, and not just
  a simple view, but one that uses stored routines.
*/

bool Alter_table_prelocking_strategy::
handle_routine(THD *thd, Query_tables_list *prelocking_ctx,
               Sroutine_hash_entry *rt, sp_head *sp, bool *need_prelocking)
{
  return FALSE;
}


/**
  Defines how prelocking algorithm for ALTER TABLE statement should handle
  table list elements.

  Unlike in DML, we do not process triggers here.

  @param[in]  thd              Thread context.
  @param[in]  prelocking_ctx   Prelocking context of the statement.
  @param[in]  table_list       Table list element for table.
  @param[in]  sp               Routine body.
  @param[out] need_prelocking  Set to TRUE if method detects that prelocking
                               required, not changed otherwise.


  @retval FALSE  Success.
  @retval TRUE   Failure (OOM).
*/

bool Alter_table_prelocking_strategy::
handle_table(THD *thd, Query_tables_list *prelocking_ctx,
             TABLE_LIST *table_list, bool *need_prelocking)
{
  return FALSE;
}


/**
  Defines how prelocking algorithm for ALTER TABLE statement
  should handle view - do nothing. We don't need to add view
  routines to the prelocking set in this case as view is not going
  to be materialized.
*/

bool Alter_table_prelocking_strategy::
handle_view(THD *thd, Query_tables_list *prelocking_ctx,
            TABLE_LIST *table_list, bool *need_prelocking)
{
  return FALSE;
}


unknown's avatar
unknown committed
4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462
/*
  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)
  {
4463
    my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),table->alias);
unknown's avatar
unknown committed
4464 4465
    DBUG_RETURN(1);
  }
unknown's avatar
unknown committed
4466
  if ((error=table->file->start_stmt(thd, lock_type)))
unknown's avatar
unknown committed
4467 4468 4469 4470 4471 4472 4473 4474
  {
    table->file->print_error(error,MYF(0));
    DBUG_RETURN(1);
  }
  DBUG_RETURN(0);
}


4475 4476 4477 4478 4479 4480
/**
  @brief Open and lock one table

  @param[in]    thd             thread handle
  @param[in]    table_l         table to open is first table in this list
  @param[in]    lock_type       lock to use for table
Konstantin Osipov's avatar
Konstantin Osipov committed
4481 4482
  @param[in]    flags           options to be used while opening and locking
                                table (see open_table(), mysql_lock_tables())
4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507

  @return       table
    @retval     != NULL         OK, opened table returned
    @retval     NULL            Error

  @note
    If ok, the following are also set:
      table_list->lock_type 	lock_type
      table_list->table		table

  @note
    If table_l is a list, not a single table, the list is temporarily
    broken.

  @detail
    This function is meant as a replacement for open_ltable() when
    MERGE tables can be opened. open_ltable() cannot open MERGE tables.

    There may be more differences between open_n_lock_single_table() and
    open_ltable(). One known difference is that open_ltable() does
    neither call decide_logging_format() nor handle some other logging
    and locking issues because it does not call lock_tables().
*/

TABLE *open_n_lock_single_table(THD *thd, TABLE_LIST *table_l,
Konstantin Osipov's avatar
Konstantin Osipov committed
4508
                                thr_lock_type lock_type, uint flags)
4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523
{
  TABLE_LIST *save_next_global;
  DBUG_ENTER("open_n_lock_single_table");

  /* Remember old 'next' pointer. */
  save_next_global= table_l->next_global;
  /* Break list. */
  table_l->next_global= NULL;

  /* Set requested lock type. */
  table_l->lock_type= lock_type;
  /* Allow to open real tables only. */
  table_l->required_type= FRMTYPE_TABLE;

  /* Open the table. */
Konstantin Osipov's avatar
Konstantin Osipov committed
4524
  if (open_and_lock_tables_derived(thd, table_l, FALSE, flags))
4525 4526 4527 4528 4529 4530 4531 4532 4533
    table_l->table= NULL; /* Just to be sure. */

  /* Restore list. */
  table_l->next_global= save_next_global;

  DBUG_RETURN(table_l->table);
}


unknown's avatar
unknown committed
4534 4535 4536 4537 4538 4539 4540 4541
/*
  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
4542
    lock_flags          Flags passed to mysql_lock_table
unknown's avatar
unknown committed
4543

4544
  NOTE
4545
    This function doesn't do anything like SP/SF/views/triggers analysis done 
Staale Smedseng's avatar
Staale Smedseng committed
4546
    in open_table()/lock_tables(). It is intended for opening of only one
4547
    concrete table. And used only in special contexts.
4548

unknown's avatar
unknown committed
4549 4550 4551 4552 4553 4554 4555 4556 4557
  RETURN VALUES
    table		Opened table
    0			Error
  
    If ok, the following are also set:
      table_list->lock_type 	lock_type
      table_list->table		table
*/

4558 4559
TABLE *open_ltable(THD *thd, TABLE_LIST *table_list, thr_lock_type lock_type,
                   uint lock_flags)
unknown's avatar
unknown committed
4560 4561
{
  TABLE *table;
Konstantin Osipov's avatar
Konstantin Osipov committed
4562
  Open_table_context ot_ctx(thd);
unknown's avatar
unknown committed
4563
  bool refresh;
Konstantin Osipov's avatar
Konstantin Osipov committed
4564
  bool error;
unknown's avatar
unknown committed
4565 4566
  DBUG_ENTER("open_ltable");

Staale Smedseng's avatar
Staale Smedseng committed
4567
  /* should not be used in a prelocked_mode context, see NOTE above */
Konstantin Osipov's avatar
Konstantin Osipov committed
4568
  DBUG_ASSERT(thd->locked_tables_mode < LTM_PRELOCKED);
Staale Smedseng's avatar
Staale Smedseng committed
4569

4570
  thd_proc_info(thd, "Opening table");
4571
  thd->current_tablenr= 0;
4572 4573
  /* open_ltable can be used only for BASIC TABLEs */
  table_list->required_type= FRMTYPE_TABLE;
4574 4575

retry:
Konstantin Osipov's avatar
Konstantin Osipov committed
4576 4577
  while ((error= open_table(thd, table_list, thd->mem_root, &ot_ctx, 0)) &&
         ot_ctx.can_recover_from_failed_open_table())
4578 4579
  {
    /*
Konstantin Osipov's avatar
Konstantin Osipov committed
4580 4581
      Even though we have failed to open table we still need to
      call release_all_locks() to release metadata locks which
4582 4583
      might have been acquired successfully.
    */
Konstantin Osipov's avatar
Konstantin Osipov committed
4584 4585 4586 4587
    if (! thd->locked_tables_mode)
      thd->mdl_context.release_all_locks();
    table_list->mdl_request.ticket= 0;
    if (ot_ctx.recover_from_failed_open_table_attempt(thd, table_list))
4588 4589
      break;
  }
unknown's avatar
unknown committed
4590

Konstantin Osipov's avatar
Konstantin Osipov committed
4591
  if (!error)
unknown's avatar
unknown committed
4592
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
4593
    /*
4594
      We can't have a view or some special "open_strategy" in this function
Konstantin Osipov's avatar
Konstantin Osipov committed
4595 4596 4597 4598
      so there should be a TABLE instance.
    */
    DBUG_ASSERT(table_list->table);
    table= table_list->table;
Konstantin Osipov's avatar
Konstantin Osipov committed
4599
    if (table->file->ht->db_type == DB_TYPE_MRG_MYISAM)
4600 4601 4602 4603 4604 4605 4606 4607 4608 4609
    {
      /* A MERGE table must not come here. */
      /* purecov: begin tested */
      my_error(ER_WRONG_OBJECT, MYF(0), table->s->db.str,
               table->s->table_name.str, "BASE TABLE");
      table= 0;
      goto end;
      /* purecov: end */
    }

unknown's avatar
unknown committed
4610
    table_list->lock_type= lock_type;
unknown's avatar
unknown committed
4611
    table->grant= table_list->grant;
Konstantin Osipov's avatar
Konstantin Osipov committed
4612
    if (thd->locked_tables_mode)
unknown's avatar
unknown committed
4613
    {
unknown's avatar
unknown committed
4614 4615 4616 4617 4618
      if (check_lock_and_start_stmt(thd, table, lock_type))
	table= 0;
    }
    else
    {
4619
      DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
unknown's avatar
unknown committed
4620
      if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)
4621
	if (! (thd->lock= mysql_lock_tables(thd, &table_list->table, 1,
Konstantin Osipov's avatar
Konstantin Osipov committed
4622
                                            lock_flags, &refresh)))
4623 4624 4625
        {
          if (refresh)
          {
Konstantin Osipov's avatar
Konstantin Osipov committed
4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639
            if (ot_ctx.can_deadlock())
            {
              my_error(ER_LOCK_DEADLOCK, MYF(0));
              table= 0;
            }
            else
            {
              close_thread_tables(thd);
              table_list->table= NULL;
              table_list->mdl_request.ticket= NULL;
              if (! thd->locked_tables_mode)
                thd->mdl_context.release_all_locks();
              goto retry;
            }
4640 4641 4642 4643
          }
          else
            table= 0;
        }
unknown's avatar
unknown committed
4644 4645
    }
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
4646 4647
  else
    table= 0;
4648

Konstantin Osipov's avatar
Konstantin Osipov committed
4649
end:
4650
  thd_proc_info(thd, 0);
unknown's avatar
unknown committed
4651 4652 4653
  DBUG_RETURN(table);
}

unknown's avatar
unknown committed
4654

Konstantin Osipov's avatar
Konstantin Osipov committed
4655
/**
4656
  Open all tables in list, locks them and optionally process derived tables.
unknown's avatar
unknown committed
4657

Konstantin Osipov's avatar
Konstantin Osipov committed
4658 4659 4660 4661 4662 4663 4664 4665
  @param thd		      Thread context.
  @param tables	              List of tables for open and locking.
  @param derived              If to handle derived tables.
  @param flags                Bitmap of options to be used to open and lock
                              tables (see open_tables() and mysql_lock_tables()
                              for details).
  @param prelocking_strategy  Strategy which specifies how prelocking algorithm
                              should work for this statement.
unknown's avatar
unknown committed
4666

Konstantin Osipov's avatar
Konstantin Osipov committed
4667
  @note
4668
    The lock will automaticaly be freed by close_thread_tables()
4669

Konstantin Osipov's avatar
Konstantin Osipov committed
4670 4671
  @note
    There are several convenience functions, e.g. :
4672 4673 4674 4675
    - simple_open_n_lock_tables(thd, tables)  without derived handling
    - open_and_lock_tables(thd, tables)       with derived handling
    Both inline functions call open_and_lock_tables_derived() with
    the third argument set appropriately.
Konstantin Osipov's avatar
Konstantin Osipov committed
4676 4677 4678

  @retval FALSE  OK.
  @retval TRUE   Error
unknown's avatar
unknown committed
4679 4680
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
4681 4682 4683
bool open_and_lock_tables_derived(THD *thd, TABLE_LIST *tables,
                                  bool derived, uint flags,
                                  Prelocking_strategy *prelocking_strategy)
unknown's avatar
unknown committed
4684 4685
{
  uint counter;
4686
  bool need_reopen;
Konstantin Osipov's avatar
Konstantin Osipov committed
4687
  bool has_locks= thd->mdl_context.has_locks();
4688 4689
  DBUG_ENTER("open_and_lock_tables_derived");
  DBUG_PRINT("enter", ("derived handling: %d", derived));
4690 4691 4692

  for ( ; ; ) 
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
4693
    if (open_tables(thd, &tables, &counter, flags, prelocking_strategy))
Konstantin Osipov's avatar
Konstantin Osipov committed
4694
      DBUG_RETURN(TRUE);
4695 4696 4697 4698 4699 4700
    DBUG_EXECUTE_IF("sleep_open_and_lock_after_open", {
      const char *old_proc_info= thd->proc_info;
      thd->proc_info= "DBUG sleep";
      my_sleep(6000000);
      thd->proc_info= old_proc_info;});

Konstantin Osipov's avatar
Konstantin Osipov committed
4701 4702
    if (!lock_tables(thd, tables, counter, flags,
                     &need_reopen))
4703 4704
      break;
    if (!need_reopen)
Konstantin Osipov's avatar
Konstantin Osipov committed
4705
      DBUG_RETURN(TRUE);
Konstantin Osipov's avatar
Konstantin Osipov committed
4706 4707 4708
    if (thd->in_multi_stmt_transaction() && has_locks)
    {
      my_error(ER_LOCK_DEADLOCK, MYF(0));
Konstantin Osipov's avatar
Konstantin Osipov committed
4709
      DBUG_RETURN(TRUE);
Konstantin Osipov's avatar
Konstantin Osipov committed
4710 4711
    }
    close_tables_for_reopen(thd, &tables);
4712
  }
4713 4714 4715 4716
  if (derived &&
      (mysql_handle_derived(thd->lex, &mysql_derived_prepare) ||
       (thd->fill_derived_tables() &&
        mysql_handle_derived(thd->lex, &mysql_derived_filling))))
unknown's avatar
unknown committed
4717
    DBUG_RETURN(TRUE); /* purecov: inspected */
Konstantin Osipov's avatar
Konstantin Osipov committed
4718
  DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
4719 4720 4721
}


4722 4723 4724 4725 4726 4727
/*
  Open all tables in list and process derived tables

  SYNOPSIS
    open_normal_and_derived_tables
    thd		- thread handler
4728
    tables	- list of tables for open
4729 4730 4731
    flags       - bitmap of flags to modify how the tables will be open:
                  MYSQL_LOCK_IGNORE_FLUSH - open table even if someone has
                  done a flush or namelock on it.
4732 4733 4734 4735 4736 4737 4738 4739 4740 4741

  RETURN
    FALSE - ok
    TRUE  - error

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

4742
bool open_normal_and_derived_tables(THD *thd, TABLE_LIST *tables, uint flags)
4743 4744 4745
{
  uint counter;
  DBUG_ENTER("open_normal_and_derived_tables");
unknown's avatar
unknown committed
4746
  DBUG_ASSERT(!thd->fill_derived_tables());
4747
  if (open_tables(thd, &tables, &counter, flags) ||
unknown's avatar
unknown committed
4748 4749 4750
      mysql_handle_derived(thd->lex, &mysql_derived_prepare))
    DBUG_RETURN(TRUE); /* purecov: inspected */
  DBUG_RETURN(0);
4751 4752 4753
}


4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769
/*
  Mark all real tables in the list as free for reuse.

  SYNOPSIS
    mark_real_tables_as_free_for_reuse()
      thd   - thread context
      table - head of the list of tables

  DESCRIPTION
    Marks all real tables in the list (i.e. not views, derived
    or schema tables) as free for reuse.
*/

static void mark_real_tables_as_free_for_reuse(TABLE_LIST *table)
{
  for (; table; table= table->next_global)
4770
    if (!table->placeholder())
4771 4772 4773 4774
      table->table->query_id= 0;
}


4775 4776
/**
   Decide on logging format to use for the statement.
unknown's avatar
unknown committed
4777

4778 4779 4780 4781
   Compute the capabilities vector for the involved storage engines
   and mask out the flags for the binary log. Right now, the binlog
   flags only include the capabilities of the storage engines, so this
   is safe.
unknown's avatar
unknown committed
4782

4783 4784
   We now have three alternatives that prevent the statement from
   being loggable:
4785

4786 4787 4788
   1. If there are no capabilities left (all flags are clear) it is
      not possible to log the statement at all, so we roll back the
      statement and report an error.
4789

4790 4791
   2. Statement mode is set, but the capabilities indicate that
      statement format is not possible.
unknown's avatar
unknown committed
4792

4793 4794
   3. Row mode is set, but the capabilities indicate that row
      format is not possible.
4795

4796 4797 4798 4799 4800 4801
   4. Statement is unsafe, but the capabilities indicate that row
      format is not possible.

   If we are in MIXED mode, we then decide what logging format to use:

   1. If the statement is unsafe, row-based logging is used.
4802

4803 4804 4805 4806 4807 4808 4809 4810 4811
   2. If statement-based logging is not possible, row-based logging is
      used.

   3. Otherwise, statement-based logging is used.

   @param thd    Client thread
   @param tables Tables involved in the query
 */

Konstantin Osipov's avatar
Konstantin Osipov committed
4812
bool decide_logging_format(THD *thd, TABLE_LIST *tables)
4813
{
4814 4815 4816 4817 4818 4819 4820 4821 4822 4823
  /*
    In SBR mode, we are only proceeding if we are binlogging this
    statement, ie, the filtering rules won't later filter this out.

    This check here is needed to prevent some spurious error to be
    raised in some cases (See BUG#42829).
   */
  if (mysql_bin_log.is_open() && (thd->options & OPTION_BIN_LOG) &&
      (thd->variables.binlog_format != BINLOG_FORMAT_STMT ||
       binlog_filter->db_ok(thd->db)))
4824
  {
Mats Kindahl's avatar
Mats Kindahl committed
4825 4826 4827 4828 4829 4830 4831 4832 4833
    /*
      Compute the starting vectors for the computations by creating a
      set with all the capabilities bits set and one with no
      capabilities bits set.
     */
    handler::Table_flags flags_some_set= 0;
    handler::Table_flags flags_all_set=
      HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE;

4834 4835
    my_bool multi_engine= FALSE;
    void* prev_ht= NULL;
4836
    for (TABLE_LIST *table= tables; table; table= table->next_global)
4837
    {
4838 4839 4840 4841 4842
      if (table->placeholder())
        continue;
      if (table->table->s->table_category == TABLE_CATEGORY_PERFORMANCE)
        thd->lex->set_stmt_unsafe();
      if (table->lock_type >= TL_WRITE_ALLOW_WRITE)
4843
      {
4844
        ulonglong const flags= table->table->file->ha_table_flags();
4845
        DBUG_PRINT("info", ("table: %s; ha_table_flags: %s%s",
4846
                            table->table_name,
4847 4848
                            FLAGSTR(flags, HA_BINLOG_STMT_CAPABLE),
                            FLAGSTR(flags, HA_BINLOG_ROW_CAPABLE)));
4849 4850 4851 4852 4853
        if (prev_ht && prev_ht != table->table->file->ht)
          multi_engine= TRUE;
        prev_ht= table->table->file->ht;
        flags_all_set &= flags;
        flags_some_set |= flags;
4854
      }
4855 4856 4857 4858 4859 4860 4861 4862
    }

    DBUG_PRINT("info", ("flags_all_set: %s%s",
                        FLAGSTR(flags_all_set, HA_BINLOG_STMT_CAPABLE),
                        FLAGSTR(flags_all_set, HA_BINLOG_ROW_CAPABLE)));
    DBUG_PRINT("info", ("flags_some_set: %s%s",
                        FLAGSTR(flags_some_set, HA_BINLOG_STMT_CAPABLE),
                        FLAGSTR(flags_some_set, HA_BINLOG_ROW_CAPABLE)));
4863 4864
    DBUG_PRINT("info", ("thd->variables.binlog_format: %ld",
                        thd->variables.binlog_format));
4865 4866
    DBUG_PRINT("info", ("multi_engine: %s",
                        multi_engine ? "TRUE" : "FALSE"));
4867 4868

    int error= 0;
4869
    if (flags_all_set == 0)
4870
    {
4871 4872 4873
      my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
               "Statement cannot be logged to the binary log in"
               " row-based nor statement-based format");
4874 4875
    }
    else if (thd->variables.binlog_format == BINLOG_FORMAT_STMT &&
4876
             (flags_all_set & HA_BINLOG_STMT_CAPABLE) == 0)
4877
    {
4878 4879 4880
      my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
                "Statement-based format required for this statement,"
                " but not allowed by this combination of engines");
4881 4882 4883
    }
    else if ((thd->variables.binlog_format == BINLOG_FORMAT_ROW ||
              thd->lex->is_stmt_unsafe()) &&
4884
             (flags_all_set & HA_BINLOG_ROW_CAPABLE) == 0)
4885
    {
4886 4887 4888
      my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
                "Row-based format required for this statement,"
                " but not allowed by this combination of engines");
4889 4890
    }

4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906
    /*
      If more than one engine is involved in the statement and at
      least one is doing it's own logging (is *self-logging*), the
      statement cannot be logged atomically, so we generate an error
      rather than allowing the binlog to become corrupt.
     */
    if (multi_engine &&
        (flags_some_set & HA_HAS_OWN_BINLOGGING))
    {
      error= ER_BINLOG_LOGGING_IMPOSSIBLE;
      my_error(error, MYF(0),
               "Statement cannot be written atomically since more"
               " than one engine involved and at least one engine"
               " is self-logging");
    }

4907 4908 4909
    DBUG_PRINT("info", ("error: %d", error));

    if (error)
Konstantin Osipov's avatar
Konstantin Osipov committed
4910
      return TRUE;
4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922

    /*
      We switch to row-based format if we are in mixed mode and one of
      the following are true:

      1. If the statement is unsafe
      2. If statement format cannot be used

      Observe that point to cannot be decided before the tables
      involved in a statement has been checked, i.e., we cannot put
      this code in reset_current_stmt_binlog_row_based(), it has to be
      here.
4923
    */
4924
    if (thd->lex->is_stmt_unsafe() ||
4925
        (flags_all_set & HA_BINLOG_STMT_CAPABLE) == 0)
4926 4927 4928 4929
    {
      thd->set_current_stmt_binlog_row_based_if_mixed();
    }
  }
unknown's avatar
unknown committed
4930

Konstantin Osipov's avatar
Konstantin Osipov committed
4931
  return FALSE;
4932 4933
}

unknown's avatar
unknown committed
4934 4935 4936 4937 4938 4939 4940
/*
  Lock all tables in list

  SYNOPSIS
    lock_tables()
    thd			Thread handler
    tables		Tables to lock
4941
    count		Number of opened tables
Konstantin Osipov's avatar
Konstantin Osipov committed
4942
    flags               Options (see mysql_lock_tables() for details)
4943 4944 4945 4946 4947
    need_reopen         Out parameter which if TRUE indicates that some
                        tables were dropped or altered during this call
                        and therefore invoker should reopen tables and
                        try to lock them once again (in this case
                        lock_tables() will also return error).
unknown's avatar
unknown committed
4948

4949 4950 4951 4952 4953
  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.

Konstantin Osipov's avatar
Konstantin Osipov committed
4954 4955 4956
    If query for which we are calling this function marked as requiring
    prelocking, this function will change locked_tables_mode to
    LTM_PRELOCKED.
4957

unknown's avatar
unknown committed
4958 4959 4960 4961 4962
  RETURN VALUES
   0	ok
   -1	Error
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
4963 4964
bool lock_tables(THD *thd, TABLE_LIST *tables, uint count,
                 uint flags, bool *need_reopen)
unknown's avatar
unknown committed
4965
{
unknown's avatar
unknown committed
4966
  TABLE_LIST *table;
4967 4968 4969 4970 4971 4972

  DBUG_ENTER("lock_tables");
  /*
    We can't meet statement requiring prelocking if we already
    in prelocked mode.
  */
Konstantin Osipov's avatar
Konstantin Osipov committed
4973 4974
  DBUG_ASSERT(thd->locked_tables_mode <= LTM_LOCK_TABLES ||
              !thd->lex->requires_prelocking());
4975 4976
  *need_reopen= FALSE;

4977
  if (!tables && !thd->lex->requires_prelocking())
4978
    DBUG_RETURN(decide_logging_format(thd, tables));
unknown's avatar
unknown committed
4979

4980
  /*
Konstantin Osipov's avatar
Konstantin Osipov committed
4981 4982 4983 4984
    Check for thd->locked_tables_mode to avoid a redundant
    and harmful attempt to lock the already locked tables again.
    Checking for thd->lock is not enough in some situations. For example,
    if a stored function contains
4985
    "drop table t3; create temporary t3 ..; insert into t3 ...;"
Konstantin Osipov's avatar
Konstantin Osipov committed
4986 4987 4988
    thd->lock may be 0 after drop tables, whereas locked_tables_mode
    is still on. In this situation an attempt to lock temporary
    table t3 will lead to a memory leak.
4989
  */
Konstantin Osipov's avatar
Konstantin Osipov committed
4990
  if (! thd->locked_tables_mode)
unknown's avatar
unknown committed
4991
  {
4992
    DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
unknown's avatar
unknown committed
4993
    TABLE **start,**ptr;
4994

4995
    if (!(ptr=start=(TABLE**) thd->alloc(sizeof(TABLE*)*count)))
Konstantin Osipov's avatar
Konstantin Osipov committed
4996
      DBUG_RETURN(TRUE);
unknown's avatar
VIEW  
unknown committed
4997
    for (table= tables; table; table= table->next_global)
unknown's avatar
unknown committed
4998
    {
4999
      if (!table->placeholder())
unknown's avatar
unknown committed
5000 5001
	*(ptr++)= table->table;
    }
5002 5003 5004 5005

    /* We have to emulate LOCK TABLES if we are statement needs prelocking. */
    if (thd->lex->requires_prelocking())
    {
unknown's avatar
unknown committed
5006
      /*
5007 5008 5009 5010
        A query that modifies autoinc column in sub-statement can make the 
        master and slave inconsistent.
        We can solve these problems in mixed mode by switching to binlogging 
        if at least one updated table is used by sub-statement
unknown's avatar
unknown committed
5011
      */
5012
      if (thd->variables.binlog_format != BINLOG_FORMAT_ROW && tables && 
5013
          has_write_table_with_auto_increment(thd->lex->first_not_own_table()))
unknown's avatar
unknown committed
5014
      {
5015
        thd->lex->set_stmt_unsafe();
unknown's avatar
unknown committed
5016
      }
5017 5018
    }

5019 5020
    DEBUG_SYNC(thd, "before_lock_tables_takes_lock");

5021
    if (! (thd->lock= mysql_lock_tables(thd, start, (uint) (ptr - start),
Konstantin Osipov's avatar
Konstantin Osipov committed
5022
                                        flags, need_reopen)))
Konstantin Osipov's avatar
Konstantin Osipov committed
5023
      DBUG_RETURN(TRUE);
5024

5025 5026 5027 5028 5029 5030 5031 5032
    if (thd->lex->requires_prelocking() &&
        thd->lex->sql_command != SQLCOM_LOCK_TABLES)
    {
      TABLE_LIST *first_not_own= thd->lex->first_not_own_table();
      /*
        We just have done implicit LOCK TABLES, and now we have
        to emulate first open_and_lock_tables() after it.

5033 5034 5035 5036 5037 5038 5039 5040 5041 5042
        When open_and_lock_tables() is called for a single table out of
        a table list, the 'next_global' chain is temporarily broken. We
        may not find 'first_not_own' before the end of the "list".
        Look for example at those places where open_n_lock_single_table()
        is called. That function implements the temporary breaking of
        a table list for opening a single table.
      */
      for (table= tables;
           table && table != first_not_own;
           table= table->next_global)
5043
      {
5044
        if (!table->placeholder())
5045 5046 5047 5048
        {
          table->table->query_id= thd->query_id;
          if (check_lock_and_start_stmt(thd, table->table, table->lock_type))
          {
Konstantin Osipov's avatar
Konstantin Osipov committed
5049
            mysql_unlock_tables(thd, thd->lock);
Konstantin Osipov's avatar
Konstantin Osipov committed
5050
            thd->lock= 0;
Konstantin Osipov's avatar
Konstantin Osipov committed
5051
            DBUG_RETURN(TRUE);
5052 5053 5054 5055 5056 5057 5058 5059
          }
        }
      }
      /*
        Let us mark all tables which don't belong to the statement itself,
        and was marked as occupied during open_tables() as free for reuse.
      */
      mark_real_tables_as_free_for_reuse(first_not_own);
Konstantin Osipov's avatar
Konstantin Osipov committed
5060
      DBUG_PRINT("info",("locked_tables_mode= LTM_PRELOCKED"));
Konstantin Osipov's avatar
Konstantin Osipov committed
5061
      thd->locked_tables_mode= LTM_PRELOCKED;
5062
    }
unknown's avatar
unknown committed
5063
  }
unknown's avatar
unknown committed
5064 5065
  else
  {
5066
    TABLE_LIST *first_not_own= thd->lex->first_not_own_table();
5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077
    /*
      When open_and_lock_tables() is called for a single table out of
      a table list, the 'next_global' chain is temporarily broken. We
      may not find 'first_not_own' before the end of the "list".
      Look for example at those places where open_n_lock_single_table()
      is called. That function implements the temporary breaking of
      a table list for opening a single table.
    */
    for (table= tables;
         table && table != first_not_own;
         table= table->next_global)
unknown's avatar
unknown committed
5078
    {
5079 5080 5081 5082 5083 5084 5085
      if (table->placeholder())
        continue;

      /*
        In a stored function or trigger we should ensure that we won't change
        a table that is already used by the calling statement.
      */
Konstantin Osipov's avatar
Konstantin Osipov committed
5086
      if (thd->locked_tables_mode >= LTM_PRELOCKED &&
5087 5088 5089 5090
          table->lock_type >= TL_WRITE_ALLOW_WRITE)
      {
        for (TABLE* opentab= thd->open_tables; opentab; opentab= opentab->next)
        {
Staale Smedseng's avatar
Staale Smedseng committed
5091 5092
          if (table->table->s == opentab->s && opentab->query_id &&
              table->table->query_id != opentab->query_id)
5093 5094
          {
            my_error(ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG, MYF(0),
Staale Smedseng's avatar
Staale Smedseng committed
5095
                     table->table->s->table_name.str);
Konstantin Osipov's avatar
Konstantin Osipov committed
5096
            DBUG_RETURN(TRUE);
5097 5098 5099 5100 5101
          }
        }
      }

      if (check_lock_and_start_stmt(thd, table->table, table->lock_type))
unknown's avatar
unknown committed
5102
      {
Konstantin Osipov's avatar
Konstantin Osipov committed
5103
	DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
5104 5105
      }
    }
5106 5107 5108 5109 5110 5111 5112 5113
    /*
      If we are under explicit LOCK TABLES and our statement requires
      prelocking, we should mark all "additional" tables as free for use
      and enter prelocked mode.
    */
    if (thd->lex->requires_prelocking())
    {
      mark_real_tables_as_free_for_reuse(first_not_own);
Konstantin Osipov's avatar
Konstantin Osipov committed
5114 5115 5116
      DBUG_PRINT("info",
                 ("thd->locked_tables_mode= LTM_PRELOCKED_UNDER_LOCK_TABLES"));
      thd->locked_tables_mode= LTM_PRELOCKED_UNDER_LOCK_TABLES;
5117
    }
unknown's avatar
unknown committed
5118
  }
5119 5120

  DBUG_RETURN(decide_logging_format(thd, tables));
unknown's avatar
unknown committed
5121 5122
}

unknown's avatar
unknown committed
5123

5124 5125 5126 5127 5128 5129
/*
  Prepare statement for reopening of tables and recalculation of set of
  prelocked tables.

  SYNOPSIS
    close_tables_for_reopen()
5130 5131
      thd    in     Thread context
      tables in/out List of tables which we were trying to open and lock
5132 5133 5134

*/

Konstantin Osipov's avatar
Konstantin Osipov committed
5135
void close_tables_for_reopen(THD *thd, TABLE_LIST **tables)
5136
{
Konstantin Osipov's avatar
Konstantin Osipov committed
5137 5138 5139
  TABLE_LIST *first_not_own_table= thd->lex->first_not_own_table();
  TABLE_LIST *tmp;

5140 5141 5142 5143
  /*
    If table list consists only from tables from prelocking set, table list
    for new attempt should be empty, so we have to update list's root pointer.
  */
Konstantin Osipov's avatar
Konstantin Osipov committed
5144
  if (first_not_own_table == *tables)
5145
    *tables= 0;
5146 5147
  thd->lex->chop_off_not_own_tables();
  sp_remove_not_own_routines(thd->lex);
Konstantin Osipov's avatar
Konstantin Osipov committed
5148
  for (tmp= *tables; tmp; tmp= tmp->next_global)
Konstantin Osipov's avatar
Konstantin Osipov committed
5149
  {
5150
    tmp->table= 0;
Konstantin Osipov's avatar
Konstantin Osipov committed
5151 5152
    tmp->mdl_request.ticket= NULL;
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
5153 5154 5155 5156 5157 5158 5159 5160 5161
  /*
    Metadata lock requests for tables from extended part of prelocking set
    are part of list of requests to be waited for in Open_table_context.
    So to satisfy assumptions in MDL_context::wait_for_locks(), which will
    performs the waiting, we have to reset MDL_request::ticket values for
    them as well.
  */
  for (tmp= first_not_own_table; tmp; tmp= tmp->next_global)
    tmp->mdl_request.ticket= NULL;
Konstantin Osipov's avatar
Konstantin Osipov committed
5162
  close_thread_tables(thd);
5163 5164
  if (!thd->locked_tables_mode)
    thd->mdl_context.release_all_locks();
5165 5166 5167
}


unknown's avatar
unknown committed
5168
/*
unknown's avatar
unknown committed
5169
  Open a single table without table caching and don't set it in open_list
unknown's avatar
unknown committed
5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185

  SYNPOSIS
    open_temporary_table()
    thd		  Thread object
    path	  Path (without .frm)
    db		  database
    table_name	  Table name
    link_in_list  1 if table should be linked into thd->temporary_tables

 NOTES:
    Used by alter_table to open a temporary table and when creating
    a temporary table with CREATE TEMPORARY ...

 RETURN
   0  Error
   #  TABLE object
unknown's avatar
unknown committed
5186 5187 5188 5189 5190 5191
*/

TABLE *open_temporary_table(THD *thd, const char *path, const char *db,
			    const char *table_name, bool link_in_list)
{
  TABLE *tmp_table;
5192
  TABLE_SHARE *share;
unknown's avatar
unknown committed
5193 5194 5195
  char cache_key[MAX_DBKEY_LENGTH], *saved_cache_key, *tmp_path;
  uint key_length;
  TABLE_LIST table_list;
unknown's avatar
unknown committed
5196
  DBUG_ENTER("open_temporary_table");
unknown's avatar
unknown committed
5197 5198 5199 5200 5201
  DBUG_PRINT("enter",
             ("table: '%s'.'%s'  path: '%s'  server_id: %u  "
              "pseudo_thread_id: %lu",
              db, table_name, path,
              (uint) thd->server_id, (ulong) thd->variables.pseudo_thread_id));
5202

unknown's avatar
unknown committed
5203 5204 5205 5206 5207 5208 5209 5210
  table_list.db=         (char*) db;
  table_list.table_name= (char*) table_name;
  /* Create the cache_key for temporary tables */
  key_length= create_table_def_key(thd, cache_key, &table_list, 1);

  if (!(tmp_table= (TABLE*) my_malloc(sizeof(*tmp_table) + sizeof(*share) +
                                      strlen(path)+1 + key_length,
                                      MYF(MY_WME))))
unknown's avatar
unknown committed
5211 5212
    DBUG_RETURN(0);				/* purecov: inspected */

unknown's avatar
unknown committed
5213 5214 5215 5216 5217
  share= (TABLE_SHARE*) (tmp_table+1);
  tmp_path= (char*) (share+1);
  saved_cache_key= strmov(tmp_path, path)+1;
  memcpy(saved_cache_key, cache_key, key_length);

5218
  init_tmp_table_share(thd, share, saved_cache_key, key_length,
unknown's avatar
unknown committed
5219 5220 5221 5222 5223 5224 5225 5226
                       strend(saved_cache_key)+1, tmp_path);

  if (open_table_def(thd, share, 0) ||
      open_table_from_share(thd, share, table_name,
                            (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
                                    HA_GET_INDEX),
                            READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
                            ha_open_options,
unknown's avatar
unknown committed
5227
                            tmp_table, FALSE))
unknown's avatar
unknown committed
5228
  {
unknown's avatar
unknown committed
5229 5230
    /* No need to lock share->mutex as this is not needed for tmp tables */
    free_table_share(share);
5231
    my_free((char*) tmp_table,MYF(0));
unknown's avatar
unknown committed
5232 5233 5234
    DBUG_RETURN(0);
  }

unknown's avatar
unknown committed
5235
  tmp_table->reginfo.lock_type= TL_WRITE;	 // Simulate locked
5236
  share->tmp_table= (tmp_table->file->has_transactions() ? 
5237
                     TRANSACTIONAL_TMP_TABLE : NON_TRANSACTIONAL_TMP_TABLE);
5238

unknown's avatar
unknown committed
5239 5240
  if (link_in_list)
  {
5241 5242 5243 5244
    /* growing temp list at the head */
    tmp_table->next= thd->temporary_tables;
    if (tmp_table->next)
      tmp_table->next->prev= tmp_table;
unknown's avatar
unknown committed
5245
    thd->temporary_tables= tmp_table;
5246
    thd->temporary_tables->prev= 0;
unknown's avatar
unknown committed
5247 5248
    if (thd->slave_thread)
      slave_open_temp_tables++;
unknown's avatar
unknown committed
5249
  }
unknown's avatar
unknown committed
5250
  tmp_table->pos_in_table_list= 0;
5251 5252
  DBUG_PRINT("tmptable", ("opened table: '%s'.'%s' 0x%lx", tmp_table->s->db.str,
                          tmp_table->s->table_name.str, (long) tmp_table));
unknown's avatar
unknown committed
5253 5254 5255 5256
  DBUG_RETURN(tmp_table);
}


unknown's avatar
unknown committed
5257
bool rm_temporary_table(handlerton *base, char *path)
unknown's avatar
unknown committed
5258 5259
{
  bool error=0;
unknown's avatar
unknown committed
5260 5261
  handler *file;
  char *ext;
5262 5263
  DBUG_ENTER("rm_temporary_table");

unknown's avatar
unknown committed
5264
  strmov(ext= strend(path), reg_ext);
unknown's avatar
unknown committed
5265 5266
  if (my_delete(path,MYF(0)))
    error=1; /* purecov: inspected */
unknown's avatar
unknown committed
5267 5268
  *ext= 0;				// remove extension
  file= get_new_handler((TABLE_SHARE*) 0, current_thd->mem_root, base);
5269
  if (file && file->ha_delete_table(path))
unknown's avatar
unknown committed
5270
  {
unknown's avatar
unknown committed
5271
    error=1;
unknown's avatar
unknown committed
5272
    sql_print_warning("Could not remove temporary table: '%s', error: %d",
unknown's avatar
unknown committed
5273
                      path, my_errno);
unknown's avatar
unknown committed
5274
  }
unknown's avatar
unknown committed
5275
  delete file;
5276
  DBUG_RETURN(error);
unknown's avatar
unknown committed
5277 5278 5279 5280
}


/*****************************************************************************
unknown's avatar
unknown committed
5281 5282 5283 5284 5285 5286
* The following find_field_in_XXX procedures implement the core of the
* name resolution functionality. The entry point to resolve a column name in a
* list of tables is 'find_field_in_tables'. It calls 'find_field_in_table_ref'
* for each table reference. In turn, depending on the type of table reference,
* 'find_field_in_table_ref' calls one of the 'find_field_in_XXX' procedures
* below specific for the type of table reference.
unknown's avatar
unknown committed
5287 5288
******************************************************************************/

unknown's avatar
unknown committed
5289
/* Special Field pointers as return values of find_field_in_XXX functions. */
unknown's avatar
unknown committed
5290 5291
Field *not_found_field= (Field*) 0x1;
Field *view_ref_found= (Field*) 0x2; 
unknown's avatar
VIEW  
unknown committed
5292

unknown's avatar
unknown committed
5293 5294
#define WRONG_GRANT (Field*) -1

unknown's avatar
unknown committed
5295 5296
static void update_field_dependencies(THD *thd, Field *field, TABLE *table)
{
5297 5298
  DBUG_ENTER("update_field_dependencies");
  if (thd->mark_used_columns != MARK_COLUMNS_NONE)
unknown's avatar
unknown committed
5299
  {
5300 5301 5302 5303 5304 5305 5306
    MY_BITMAP *current_bitmap, *other_bitmap;

    /*
      We always want to register the used keys, as the column bitmap may have
      been set for all fields (for example for view).
    */
      
5307
    table->covering_keys.intersect(field->part_of_key);
5308 5309 5310
    table->merge_keys.merge(field->part_of_key);

    if (thd->mark_used_columns == MARK_COLUMNS_READ)
unknown's avatar
unknown committed
5311
    {
5312 5313
      current_bitmap= table->read_set;
      other_bitmap=   table->write_set;
unknown's avatar
unknown committed
5314 5315
    }
    else
5316 5317 5318 5319 5320
    {
      current_bitmap= table->write_set;
      other_bitmap=   table->read_set;
    }

5321 5322 5323 5324 5325 5326 5327
    /* 
       The test-and-set mechanism in the bitmap is not reliable during
       multi-UPDATE statements under MARK_COLUMNS_READ mode
       (thd->mark_used_columns == MARK_COLUMNS_READ), as this bitmap contains
       only those columns that are used in the SET clause. I.e they are being
       set here. See multi_update::prepare()
    */
5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345
    if (bitmap_fast_test_and_set(current_bitmap, field->field_index))
    {
      if (thd->mark_used_columns == MARK_COLUMNS_WRITE)
      {
        DBUG_PRINT("warning", ("Found duplicated field"));
        thd->dup_field= field;
      }
      else
      {
        DBUG_PRINT("note", ("Field found before"));
      }
      DBUG_VOID_RETURN;
    }
    if (table->get_fields_in_item_tree)
      field->flags|= GET_FIXED_FIELDS_FLAG;
    table->used_fields++;
  }
  else if (table->get_fields_in_item_tree)
5346
    field->flags|= GET_FIXED_FIELDS_FLAG;
5347
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
5348 5349
}

unknown's avatar
VIEW  
unknown committed
5350 5351

/*
unknown's avatar
unknown committed
5352
  Find a field by name in a view that uses merge algorithm.
unknown's avatar
VIEW  
unknown committed
5353 5354

  SYNOPSIS
unknown's avatar
unknown committed
5355
    find_field_in_view()
unknown's avatar
VIEW  
unknown committed
5356
    thd				thread handler
unknown's avatar
unknown committed
5357
    table_list			view to search for 'name'
unknown's avatar
VIEW  
unknown committed
5358 5359
    name			name of field
    length			length of name
5360
    item_name                   name of item if it will be created (VIEW)
unknown's avatar
unknown committed
5361 5362
    ref				expression substituted in VIEW should be passed
                                using this reference (return view_ref_found)
unknown's avatar
unknown committed
5363
    register_tree_change        TRUE if ref is not stack variable and we
unknown's avatar
unknown committed
5364
                                need register changes in item tree
unknown's avatar
VIEW  
unknown committed
5365 5366 5367 5368

  RETURN
    0			field is not found
    view_ref_found	found value in VIEW (real result is in *ref)
unknown's avatar
unknown committed
5369
    #			pointer to field - only for schema table fields
unknown's avatar
VIEW  
unknown committed
5370 5371
*/

unknown's avatar
unknown committed
5372 5373
static Field *
find_field_in_view(THD *thd, TABLE_LIST *table_list,
5374 5375
                   const char *name, uint length,
                   const char *item_name, Item **ref,
unknown's avatar
unknown committed
5376
                   bool register_tree_change)
unknown's avatar
VIEW  
unknown committed
5377
{
unknown's avatar
unknown committed
5378 5379 5380 5381 5382 5383
  DBUG_ENTER("find_field_in_view");
  DBUG_PRINT("enter",
             ("view: '%s', field name: '%s', item name: '%s', ref 0x%lx",
              table_list->alias, name, item_name, (ulong) ref));
  Field_iterator_view field_it;
  field_it.set(table_list);
unknown's avatar
unknown committed
5384
  Query_arena *arena= 0, backup;  
5385
  
unknown's avatar
unknown committed
5386 5387 5388
  DBUG_ASSERT(table_list->schema_table_reformed ||
              (ref != 0 && table_list->view != 0));
  for (; !field_it.end_of_fields(); field_it.next())
unknown's avatar
VIEW  
unknown committed
5389
  {
unknown's avatar
unknown committed
5390
    if (!my_strcasecmp(system_charset_info, field_it.name(), name))
5391
    {
5392
      // in PS use own arena or data will be freed after prepare
unknown's avatar
unknown committed
5393
      if (register_tree_change && thd->stmt_arena->is_stmt_prepare_or_first_sp_execute())
5394
        arena= thd->activate_stmt_arena_if_needed(&backup);
5395 5396 5397 5398
      /*
        create_item() may, or may not create a new Item, depending on
        the column reference. See create_view_field() for details.
      */
unknown's avatar
unknown committed
5399
      Item *item= field_it.create_item(thd);
unknown's avatar
unknown committed
5400
      if (arena)
5401 5402
        thd->restore_active_arena(arena, &backup);
      
unknown's avatar
unknown committed
5403 5404 5405 5406 5407 5408
      if (!item)
        DBUG_RETURN(0);
      /*
       *ref != NULL means that *ref contains the item that we need to
       replace. If the item was aliased by the user, set the alias to
       the replacing item.
5409
       We need to set alias on both ref itself and on ref real item.
unknown's avatar
unknown committed
5410 5411
      */
      if (*ref && !(*ref)->is_autogenerated_name)
5412
      {
unknown's avatar
unknown committed
5413 5414
        item->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
5415 5416 5417
        item->real_item()->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
      }
unknown's avatar
unknown committed
5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445
      if (register_tree_change)
        thd->change_item_tree(ref, item);
      else
        *ref= item;
      DBUG_RETURN((Field*) view_ref_found);
    }
  }
  DBUG_RETURN(0);
}


/*
  Find field by name in a NATURAL/USING join table reference.

  SYNOPSIS
    find_field_in_natural_join()
    thd			 [in]  thread handler
    table_ref            [in]  table reference to search
    name		 [in]  name of field
    length		 [in]  length of name
    ref                  [in/out] if 'name' is resolved to a view field, ref is
                               set to point to the found view field
    register_tree_change [in]  TRUE if ref is not stack variable and we
                               need register changes in item tree
    actual_table         [out] the original table reference where the field
                               belongs - differs from 'table_list' only for
                               NATURAL/USING joins

5446 5447 5448 5449 5450 5451
  DESCRIPTION
    Search for a field among the result fields of a NATURAL/USING join.
    Notice that this procedure is called only for non-qualified field
    names. In the case of qualified fields, we search directly the base
    tables of a natural join.

unknown's avatar
unknown committed
5452
  RETURN
5453 5454 5455
    NULL        if the field was not found
    WRONG_GRANT if no access rights to the found field
    #           Pointer to the found Field
unknown's avatar
unknown committed
5456 5457 5458 5459
*/

static Field *
find_field_in_natural_join(THD *thd, TABLE_LIST *table_ref, const char *name,
5460
                           uint length, Item **ref, bool register_tree_change,
5461
                           TABLE_LIST **actual_table)
unknown's avatar
unknown committed
5462
{
5463 5464
  List_iterator_fast<Natural_join_column>
    field_it(*(table_ref->join_columns));
5465
  Natural_join_column *nj_col, *curr_nj_col;
5466
  Field *found_field;
5467
  Query_arena *arena, backup;
unknown's avatar
unknown committed
5468
  DBUG_ENTER("find_field_in_natural_join");
5469
  DBUG_PRINT("enter", ("field name: '%s', ref 0x%lx",
unknown's avatar
unknown committed
5470 5471
		       name, (ulong) ref));
  DBUG_ASSERT(table_ref->is_natural_join && table_ref->join_columns);
5472
  DBUG_ASSERT(*actual_table == NULL);
unknown's avatar
unknown committed
5473

5474
  LINT_INIT(arena);
5475
  LINT_INIT(found_field);
unknown's avatar
unknown committed
5476

5477 5478
  for (nj_col= NULL, curr_nj_col= field_it++; curr_nj_col; 
       curr_nj_col= field_it++)
unknown's avatar
unknown committed
5479
  {
5480 5481 5482 5483 5484 5485 5486 5487 5488
    if (!my_strcasecmp(system_charset_info, curr_nj_col->name(), name))
    {
      if (nj_col)
      {
        my_error(ER_NON_UNIQ_ERROR, MYF(0), name, thd->where);
        DBUG_RETURN(NULL);
      }
      nj_col= curr_nj_col;
    }
unknown's avatar
VIEW  
unknown committed
5489
  }
5490 5491
  if (!nj_col)
    DBUG_RETURN(NULL);
unknown's avatar
unknown committed
5492 5493 5494

  if (nj_col->view_field)
  {
unknown's avatar
unknown committed
5495
    Item *item;
unknown's avatar
unknown committed
5496
    LINT_INIT(arena);
5497 5498
    if (register_tree_change)
      arena= thd->activate_stmt_arena_if_needed(&backup);
5499 5500 5501 5502
    /*
      create_item() may, or may not create a new Item, depending on the
      column reference. See create_view_field() for details.
    */
unknown's avatar
unknown committed
5503
    item= nj_col->create_item(thd);
5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516
    /*
     *ref != NULL means that *ref contains the item that we need to
     replace. If the item was aliased by the user, set the alias to
     the replacing item.
     We need to set alias on both ref itself and on ref real item.
     */
    if (*ref && !(*ref)->is_autogenerated_name)
    {
      item->set_name((*ref)->name, (*ref)->name_length,
                     system_charset_info);
      item->real_item()->set_name((*ref)->name, (*ref)->name_length,
                                  system_charset_info);
    }
5517 5518 5519
    if (register_tree_change && arena)
      thd->restore_active_arena(arena, &backup);

unknown's avatar
unknown committed
5520 5521 5522 5523
    if (!item)
      DBUG_RETURN(NULL);
    DBUG_ASSERT(nj_col->table_field == NULL);
    if (nj_col->table_ref->schema_table_reformed)
5524
    {
unknown's avatar
unknown committed
5525 5526 5527 5528 5529 5530
      /*
        Translation table items are always Item_fields and fixed
        already('mysql_schema_table' function). So we can return
        ->field. It is used only for 'show & where' commands.
      */
      DBUG_RETURN(((Item_field*) (nj_col->view_field->item))->field);
5531
    }
unknown's avatar
unknown committed
5532 5533 5534 5535 5536 5537 5538 5539 5540 5541
    if (register_tree_change)
      thd->change_item_tree(ref, item);
    else
      *ref= item;
    found_field= (Field*) view_ref_found;
  }
  else
  {
    /* This is a base table. */
    DBUG_ASSERT(nj_col->view_field == NULL);
5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556
    /*
      This fix_fields is not necessary (initially this item is fixed by
      the Item_field constructor; after reopen_tables the Item_func_eq
      calls fix_fields on that item), it's just a check during table
      reopening for columns that was dropped by the concurrent connection.
    */
    if (!nj_col->table_field->fixed &&
        nj_col->table_field->fix_fields(thd, (Item **)&nj_col->table_field))
    {
      DBUG_PRINT("info", ("column '%s' was dropped by the concurrent connection",
                          nj_col->table_field->name));
      DBUG_RETURN(NULL);
    }
    DBUG_ASSERT(nj_col->table_ref->table == nj_col->table_field->field->table);
    found_field= nj_col->table_field->field;
unknown's avatar
unknown committed
5557 5558 5559 5560 5561 5562
    update_field_dependencies(thd, found_field, nj_col->table_ref->table);
  }

  *actual_table= nj_col->table_ref;
  
  DBUG_RETURN(found_field);
unknown's avatar
VIEW  
unknown committed
5563 5564
}

5565

unknown's avatar
VIEW  
unknown committed
5566
/*
unknown's avatar
unknown committed
5567
  Find field by name in a base table or a view with temp table algorithm.
unknown's avatar
VIEW  
unknown committed
5568 5569

  SYNOPSIS
unknown's avatar
unknown committed
5570
    find_field_in_table()
unknown's avatar
VIEW  
unknown committed
5571
    thd				thread handler
unknown's avatar
unknown committed
5572
    table			table where to search for the field
unknown's avatar
VIEW  
unknown committed
5573 5574 5575
    name			name of field
    length			length of name
    allow_rowid			do allow finding of "_rowid" field?
unknown's avatar
unknown committed
5576 5577
    cached_field_index_ptr	cached position in field list (used to speedup
                                lookup for fields in prepared tables)
unknown's avatar
VIEW  
unknown committed
5578 5579

  RETURN
5580 5581
    0	field is not found
    #	pointer to field
unknown's avatar
VIEW  
unknown committed
5582 5583
*/

unknown's avatar
unknown committed
5584 5585
Field *
find_field_in_table(THD *thd, TABLE *table, const char *name, uint length,
5586
                    bool allow_rowid, uint *cached_field_index_ptr)
unknown's avatar
unknown committed
5587
{
unknown's avatar
unknown committed
5588 5589
  Field **field_ptr, *field;
  uint cached_field_index= *cached_field_index_ptr;
5590 5591
  DBUG_ENTER("find_field_in_table");
  DBUG_PRINT("enter", ("table: '%s', field name: '%s'", table->alias, name));
unknown's avatar
unknown committed
5592 5593

  /* We assume here that table->field < NO_CACHED_FIELD_INDEX = UINT_MAX */
5594
  if (cached_field_index < table->s->fields &&
5595
      !my_strcasecmp(system_charset_info,
unknown's avatar
unknown committed
5596 5597
                     table->field[cached_field_index]->field_name, name))
    field_ptr= table->field + cached_field_index;
5598
  else if (table->s->name_hash.records)
unknown's avatar
unknown committed
5599
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
5600 5601
    field_ptr= (Field**) my_hash_search(&table->s->name_hash, (uchar*) name,
                                        length);
unknown's avatar
unknown committed
5602 5603 5604 5605 5606 5607 5608 5609 5610
    if (field_ptr)
    {
      /*
        field_ptr points to field in TABLE_SHARE. Convert it to the matching
        field in table
      */
      field_ptr= (table->field + (field_ptr - table->s->field));
    }
  }
unknown's avatar
unknown committed
5611 5612 5613
  else
  {
    if (!(field_ptr= table->field))
unknown's avatar
unknown committed
5614
      DBUG_RETURN((Field *)0);
unknown's avatar
unknown committed
5615 5616 5617 5618 5619 5620
    for (; *field_ptr; ++field_ptr)
      if (!my_strcasecmp(system_charset_info, (*field_ptr)->field_name, name))
        break;
  }

  if (field_ptr && *field_ptr)
unknown's avatar
unknown committed
5621
  {
unknown's avatar
unknown committed
5622 5623
    *cached_field_index_ptr= field_ptr - table->field;
    field= *field_ptr;
unknown's avatar
unknown committed
5624 5625 5626
  }
  else
  {
unknown's avatar
unknown committed
5627 5628
    if (!allow_rowid ||
        my_strcasecmp(system_charset_info, name, "_rowid") ||
unknown's avatar
unknown committed
5629
        table->s->rowid_field_offset == 0)
unknown's avatar
unknown committed
5630
      DBUG_RETURN((Field*) 0);
unknown's avatar
unknown committed
5631
    field= table->field[table->s->rowid_field_offset-1];
unknown's avatar
unknown committed
5632 5633
  }

unknown's avatar
unknown committed
5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647
  update_field_dependencies(thd, field, table);

  DBUG_RETURN(field);
}


/*
  Find field in a table reference.

  SYNOPSIS
    find_field_in_table_ref()
    thd			   [in]  thread handler
    table_list		   [in]  table reference to search
    name		   [in]  name of field
5648
    length		   [in]  field length of name
unknown's avatar
unknown committed
5649 5650
    item_name              [in]  name of item if it will be created (VIEW)
    db_name                [in]  optional database name that qualifies the
5651
    table_name             [in]  optional table name that qualifies the field
unknown's avatar
unknown committed
5652 5653
    ref		       [in/out] if 'name' is resolved to a view field, ref
                                 is set to point to the found view field
5654
    check_privileges       [in]  check privileges
unknown's avatar
unknown committed
5655 5656 5657 5658 5659 5660 5661 5662 5663
    allow_rowid		   [in]  do allow finding of "_rowid" field?
    cached_field_index_ptr [in]  cached position in field list (used to
                                 speedup lookup for fields in prepared tables)
    register_tree_change   [in]  TRUE if ref is not stack variable and we
                                 need register changes in item tree
    actual_table           [out] the original table reference where the field
                                 belongs - differs from 'table_list' only for
                                 NATURAL_USING joins.

unknown's avatar
unknown committed
5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675
  DESCRIPTION
    Find a field in a table reference depending on the type of table
    reference. There are three types of table references with respect
    to the representation of their result columns:
    - an array of Field_translator objects for MERGE views and some
      information_schema tables,
    - an array of Field objects (and possibly a name hash) for stored
      tables,
    - a list of Natural_join_column objects for NATURAL/USING joins.
    This procedure detects the type of the table reference 'table_list'
    and calls the corresponding search routine.

unknown's avatar
unknown committed
5676 5677 5678 5679 5680 5681 5682 5683
  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_ref(THD *thd, TABLE_LIST *table_list,
5684 5685 5686
                        const char *name, uint length,
                        const char *item_name, const char *db_name,
                        const char *table_name, Item **ref,
5687 5688
                        bool check_privileges, bool allow_rowid,
                        uint *cached_field_index_ptr,
unknown's avatar
unknown committed
5689 5690 5691 5692
                        bool register_tree_change, TABLE_LIST **actual_table)
{
  Field *fld;
  DBUG_ENTER("find_field_in_table_ref");
unknown's avatar
unknown committed
5693 5694 5695
  DBUG_ASSERT(table_list->alias);
  DBUG_ASSERT(name);
  DBUG_ASSERT(item_name);
unknown's avatar
unknown committed
5696 5697 5698 5699 5700 5701
  DBUG_PRINT("enter",
             ("table: '%s'  field name: '%s'  item name: '%s'  ref 0x%lx",
              table_list->alias, name, item_name, (ulong) ref));

  /*
    Check that the table and database that qualify the current field name
unknown's avatar
unknown committed
5702 5703
    are the same as the table reference we are going to search for the field.

5704 5705 5706 5707
    Exclude from the test below nested joins because the columns in a
    nested join generally originate from different tables. Nested joins
    also have no table name, except when a nested join is a merge view
    or an information schema table.
unknown's avatar
unknown committed
5708 5709 5710 5711 5712 5713

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

5714 5715
    TODO: Ensure that table_name, db_name and tables->db always points to
          something !
unknown's avatar
unknown committed
5716
  */
5717 5718
  if (/* Exclude nested joins. */
      (!table_list->nested_join ||
unknown's avatar
unknown committed
5719 5720 5721 5722 5723 5724
       /* Include merge views and information schema tables. */
       table_list->field_translation) &&
      /*
        Test if the field qualifiers match the table reference we plan
        to search.
      */
5725 5726
      table_name && table_name[0] &&
      (my_strcasecmp(table_alias_charset, table_list->alias, table_name) ||
unknown's avatar
unknown committed
5727
       (db_name && db_name[0] && table_list->db && table_list->db[0] &&
5728 5729 5730
        (table_list->schema_table ?
         my_strcasecmp(system_charset_info, db_name, table_list->db) :
         strcmp(db_name, table_list->db)))))
unknown's avatar
unknown committed
5731 5732
    DBUG_RETURN(0);

5733
  *actual_table= NULL;
unknown's avatar
unknown committed
5734

unknown's avatar
unknown committed
5735 5736
  if (table_list->field_translation)
  {
unknown's avatar
unknown committed
5737
    /* 'table_list' is a view or an information schema table. */
5738
    if ((fld= find_field_in_view(thd, table_list, name, length, item_name, ref,
5739
                                 register_tree_change)))
unknown's avatar
unknown committed
5740 5741
      *actual_table= table_list;
  }
5742
  else if (!table_list->nested_join)
5743
  {
5744 5745
    /* 'table_list' is a stored table. */
    DBUG_ASSERT(table_list->table);
unknown's avatar
unknown committed
5746
    if ((fld= find_field_in_table(thd, table_list->table, name, length,
5747 5748
                                  allow_rowid,
                                  cached_field_index_ptr)))
unknown's avatar
unknown committed
5749 5750 5751
      *actual_table= table_list;
  }
  else
5752
  {
unknown's avatar
unknown committed
5753
    /*
unknown's avatar
unknown committed
5754 5755 5756 5757 5758
      'table_list' is a NATURAL/USING join, or an operand of such join that
      is a nested join itself.

      If the field name we search for is qualified, then search for the field
      in the table references used by NATURAL/USING the join.
unknown's avatar
unknown committed
5759
    */
5760 5761 5762 5763 5764 5765
    if (table_name && table_name[0])
    {
      List_iterator<TABLE_LIST> it(table_list->nested_join->join_list);
      TABLE_LIST *table;
      while ((table= it++))
      {
5766 5767
        if ((fld= find_field_in_table_ref(thd, table, name, length, item_name,
                                          db_name, table_name, ref,
5768 5769
                                          check_privileges, allow_rowid,
                                          cached_field_index_ptr,
5770 5771 5772 5773 5774 5775 5776
                                          register_tree_change, actual_table)))
          DBUG_RETURN(fld);
      }
      DBUG_RETURN(0);
    }
    /*
      Non-qualified field, search directly in the result columns of the
unknown's avatar
unknown committed
5777 5778 5779
      natural join. The condition of the outer IF is true for the top-most
      natural join, thus if the field is not qualified, we will search
      directly the top-most NATURAL/USING join.
5780 5781
    */
    fld= find_field_in_natural_join(thd, table_list, name, length, ref,
unknown's avatar
unknown committed
5782
                                    register_tree_change, actual_table);
5783
  }
unknown's avatar
unknown committed
5784

5785 5786
  if (fld)
  {
5787
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5788 5789 5790 5791 5792
    /* Check if there are sufficient access rights to the found field. */
    if (check_privileges &&
        check_column_grant_in_table_ref(thd, *actual_table, name, length))
      fld= WRONG_GRANT;
    else
5793
#endif
5794
      if (thd->mark_used_columns != MARK_COLUMNS_NONE)
5795
      {
5796
        /*
5797 5798 5799
          Get rw_set correct for this field so that the handler
          knows that this field is involved in the query and gets
          retrieved/updated
5800
         */
5801 5802 5803 5804 5805 5806
        Field *field_to_set= NULL;
        if (fld == view_ref_found)
        {
          Item *it= (*ref)->real_item();
          if (it->type() == Item::FIELD_ITEM)
            field_to_set= ((Item_field*)it)->field;
5807 5808 5809
          else
          {
            if (thd->mark_used_columns == MARK_COLUMNS_READ)
5810
              it->walk(&Item::register_field_in_read_map, 1, (uchar *) 0);
5811
          }
5812 5813 5814 5815
        }
        else
          field_to_set= fld;
        if (field_to_set)
5816 5817 5818 5819 5820 5821 5822
        {
          TABLE *table= field_to_set->table;
          if (thd->mark_used_columns == MARK_COLUMNS_READ)
            bitmap_set_bit(table->read_set, field_to_set->field_index);
          else
            bitmap_set_bit(table->write_set, field_to_set->field_index);
        }
5823 5824
      }
  }
unknown's avatar
unknown committed
5825
  DBUG_RETURN(fld);
unknown's avatar
unknown committed
5826 5827
}

5828

5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847
/*
  Find field in table, no side effects, only purpose is to check for field
  in table object and get reference to the field if found.

  SYNOPSIS
  find_field_in_table_sef()

  table                         table where to find
  name                          Name of field searched for

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

Field *find_field_in_table_sef(TABLE *table, const char *name)
{
  Field **field_ptr;
  if (table->s->name_hash.records)
unknown's avatar
unknown committed
5848
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
5849 5850
    field_ptr= (Field**)my_hash_search(&table->s->name_hash,(uchar*) name,
                                       strlen(name));
unknown's avatar
unknown committed
5851 5852 5853 5854 5855 5856 5857 5858 5859
    if (field_ptr)
    {
      /*
        field_ptr points to field in TABLE_SHARE. Convert it to the matching
        field in table
      */
      field_ptr= (table->field + (field_ptr - table->s->field));
    }
  }
5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872 5873 5874
  else
  {
    if (!(field_ptr= table->field))
      return (Field *)0;
    for (; *field_ptr; ++field_ptr)
      if (!my_strcasecmp(system_charset_info, (*field_ptr)->field_name, name))
        break;
  }
  if (field_ptr)
    return *field_ptr;
  else
    return (Field *)0;
}


5875 5876 5877 5878 5879
/*
  Find field in table list.

  SYNOPSIS
    find_field_in_tables()
unknown's avatar
unknown committed
5880 5881 5882 5883 5884 5885
    thd			  pointer to current thread structure
    item		  field item that should be found
    first_table           list of tables to be searched for item
    last_table            end of the list of tables to search for item. If NULL
                          then search to the end of the list 'first_table'.
    ref			  if 'item' is resolved to a view field, ref is set to
5886
                          point to the found view field
unknown's avatar
unknown committed
5887
    report_error	  Degree of error reporting:
5888 5889
                          - IGNORE_ERRORS then do not report any error
                          - IGNORE_EXCEPT_NON_UNIQUE report only non-unique
unknown's avatar
unknown committed
5890
                            fields, suppress all other errors
5891 5892 5893 5894
                          - REPORT_EXCEPT_NON_UNIQUE report all other errors
                            except when non-unique fields were found
                          - REPORT_ALL_ERRORS
    check_privileges      need to check privileges
unknown's avatar
unknown committed
5895 5896
    register_tree_change  TRUE if ref is not a stack variable and we
                          to need register changes in item tree
5897 5898

  RETURN VALUES
5899 5900 5901
    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.
5902 5903 5904 5905 5906
    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
5907
*/
unknown's avatar
unknown committed
5908 5909

Field *
unknown's avatar
unknown committed
5910 5911
find_field_in_tables(THD *thd, Item_ident *item,
                     TABLE_LIST *first_table, TABLE_LIST *last_table,
5912
		     Item **ref, find_item_error_report_type report_error,
5913
                     bool check_privileges, bool register_tree_change)
unknown's avatar
unknown committed
5914 5915
{
  Field *found=0;
unknown's avatar
unknown committed
5916 5917 5918
  const char *db= item->db_name;
  const char *table_name= item->table_name;
  const char *name= item->field_name;
unknown's avatar
unknown committed
5919
  uint length=(uint) strlen(name);
5920
  char name_buff[NAME_LEN+1];
unknown's avatar
unknown committed
5921 5922
  TABLE_LIST *cur_table= first_table;
  TABLE_LIST *actual_table;
unknown's avatar
unknown committed
5923 5924 5925 5926 5927 5928 5929 5930 5931
  bool allow_rowid;

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

  allow_rowid= table_name || (cur_table && !cur_table->next_local);
unknown's avatar
unknown committed
5932

unknown's avatar
unknown committed
5933 5934 5935
  if (item->cached_table)
  {
    /*
unknown's avatar
unknown committed
5936 5937
      This shortcut is used by prepared statements. We assume that
      TABLE_LIST *first_table is not changed during query execution (which
5938
      is true for all queries except RENAME but luckily RENAME doesn't
unknown's avatar
unknown committed
5939
      use fields...) so we can rely on reusing pointer to its member.
unknown's avatar
unknown committed
5940
      With this optimization we also miss case when addition of one more
5941
      field makes some prepared query ambiguous and so erroneous, but we
unknown's avatar
unknown committed
5942 5943
      accept this trade off.
    */
unknown's avatar
unknown committed
5944 5945 5946 5947 5948 5949 5950 5951
    TABLE_LIST *table_ref= item->cached_table;
    /*
      The condition (table_ref->view == NULL) ensures that we will call
      find_field_in_table even in the case of information schema tables
      when table_ref->field_translation != NULL.
      */
    if (table_ref->table && !table_ref->view)
      found= find_field_in_table(thd, table_ref->table, name, length,
5952
                                 TRUE, &(item->cached_field_index));
5953
    else
5954
      found= find_field_in_table_ref(thd, table_ref, name, length, item->name,
5955 5956
                                     NULL, NULL, ref, check_privileges,
                                     TRUE, &(item->cached_field_index),
unknown's avatar
unknown committed
5957 5958
                                     register_tree_change,
                                     &actual_table);
unknown's avatar
unknown committed
5959 5960 5961
    if (found)
    {
      if (found == WRONG_GRANT)
5962
	return (Field*) 0;
5963 5964 5965 5966 5967 5968

      /*
        Only views fields should be marked as dependent, not an underlying
        fields.
      */
      if (!table_ref->belong_to_view)
5969 5970
      {
        SELECT_LEX *current_sel= thd->lex->current_select;
unknown's avatar
unknown committed
5971
        SELECT_LEX *last_select= table_ref->select_lex;
unknown's avatar
unknown committed
5972 5973
        /*
          If the field was an outer referencee, mark all selects using this
unknown's avatar
unknown committed
5974
          sub query as dependent on the outer query
unknown's avatar
unknown committed
5975
        */
5976
        if (current_sel != last_select)
unknown's avatar
unknown committed
5977
          mark_select_range_as_dependent(thd, last_select, current_sel,
5978 5979
                                         found, *ref, item);
      }
unknown's avatar
unknown committed
5980 5981 5982 5983
      return found;
    }
  }

5984 5985 5986
  if (db && lower_case_table_names)
  {
    /*
unknown's avatar
unknown committed
5987
      convert database to lower case for comparison.
5988 5989 5990 5991
      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);
unknown's avatar
unknown committed
5992
    my_casedn_str(files_charset_info, name_buff);
5993 5994
    db= name_buff;
  }
unknown's avatar
unknown committed
5995

5996 5997 5998 5999 6000
  if (last_table)
    last_table= last_table->next_name_resolution_table;

  for (; cur_table != last_table ;
       cur_table= cur_table->next_name_resolution_table)
unknown's avatar
unknown committed
6001
  {
6002 6003
    Field *cur_field= find_field_in_table_ref(thd, cur_table, name, length,
                                              item->name, db, table_name, ref,
6004 6005 6006
                                              (thd->lex->sql_command ==
                                               SQLCOM_SHOW_FIELDS)
                                              ? false : check_privileges,
6007
                                              allow_rowid,
unknown's avatar
unknown committed
6008 6009 6010 6011
                                              &(item->cached_field_index),
                                              register_tree_change,
                                              &actual_table);
    if (cur_field)
6012
    {
unknown's avatar
unknown committed
6013
      if (cur_field == WRONG_GRANT)
6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030
      {
        if (thd->lex->sql_command != SQLCOM_SHOW_FIELDS)
          return (Field*) 0;

        thd->clear_error();
        cur_field= find_field_in_table_ref(thd, cur_table, name, length,
                                           item->name, db, table_name, ref,
                                           false,
                                           allow_rowid,
                                           &(item->cached_field_index),
                                           register_tree_change,
                                           &actual_table);
        if (cur_field)
        {
          Field *nf=new Field_null(NULL,0,Field::NONE,
                                   cur_field->field_name,
                                   &my_charset_bin);
6031
          nf->init(cur_table->table);
6032 6033 6034
          cur_field= nf;
        }
      }
unknown's avatar
unknown committed
6035 6036 6037 6038 6039 6040 6041 6042

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

6043 6044 6045 6046 6047
      DBUG_ASSERT(thd->where);
      /*
        If we found a fully qualified field we return it directly as it can't
        have duplicates.
       */
unknown's avatar
unknown committed
6048
      if (db)
6049 6050
        return cur_field;

unknown's avatar
unknown committed
6051 6052
      if (found)
      {
6053 6054
        if (report_error == REPORT_ALL_ERRORS ||
            report_error == IGNORE_EXCEPT_NON_UNIQUE)
6055
          my_error(ER_NON_UNIQ_ERROR, MYF(0),
unknown's avatar
unknown committed
6056
                   table_name ? item->full_name() : name, thd->where);
6057
        return (Field*) 0;
unknown's avatar
unknown committed
6058
      }
unknown's avatar
unknown committed
6059
      found= cur_field;
unknown's avatar
unknown committed
6060 6061
    }
  }
6062

unknown's avatar
unknown committed
6063 6064
  if (found)
    return found;
6065 6066 6067 6068 6069 6070 6071 6072

  /*
    If the field was qualified and there were no tables to search, issue
    an error that an unknown table was given. The situation is detected
    as follows: if there were no tables we wouldn't go through the loop
    and cur_table wouldn't be updated by the loop increment part, so it
    will be equal to the first table.
  */
unknown's avatar
unknown committed
6073
  if (table_name && (cur_table == first_table) &&
6074 6075 6076
      (report_error == REPORT_ALL_ERRORS ||
       report_error == REPORT_EXCEPT_NON_UNIQUE))
  {
6077
    char buff[NAME_LEN*2 + 2];
6078 6079 6080 6081 6082 6083 6084
    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);
  }
6085
  else
unknown's avatar
unknown committed
6086
  {
6087 6088 6089 6090 6091
    if (report_error == REPORT_ALL_ERRORS ||
        report_error == REPORT_EXCEPT_NON_UNIQUE)
      my_error(ER_BAD_FIELD_ERROR, MYF(0), item->full_name(), thd->where);
    else
      found= not_found_field;
unknown's avatar
unknown committed
6092
  }
6093
  return found;
unknown's avatar
unknown committed
6094 6095
}

6096 6097 6098

/*
  Find Item in list of items (find_field_in_tables analog)
6099 6100 6101 6102

  TODO
    is it better return only counter?

6103 6104
  SYNOPSIS
    find_item_in_list()
6105 6106 6107
    find			Item to find
    items			List of items
    counter			To return number of found item
6108
    report_error
6109 6110 6111 6112 6113
      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
unknown's avatar
unknown committed
6114 6115 6116 6117 6118 6119 6120
    resolution                  Set to the resolution type if the item is found 
                                (it says whether the item is resolved 
                                 against an alias name,
                                 or as a field name without alias,
                                 or as a field hidden by alias,
                                 or ignoring alias)
                                
6121
  RETURN VALUES
6122 6123 6124 6125 6126
    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
6127
                        found field
6128 6129
*/

6130
/* Special Item pointer to serve as a return value from find_item_in_list(). */
unknown's avatar
unknown committed
6131
Item **not_found_item= (Item**) 0x1;
6132 6133


unknown's avatar
unknown committed
6134
Item **
6135
find_item_in_list(Item *find, List<Item> &items, uint *counter,
unknown's avatar
unknown committed
6136 6137
                  find_item_error_report_type report_error,
                  enum_resolution_type *resolution)
unknown's avatar
unknown committed
6138 6139
{
  List_iterator<Item> li(items);
6140
  Item **found=0, **found_unaliased= 0, *item;
6141
  const char *db_name=0;
unknown's avatar
unknown committed
6142 6143
  const char *field_name=0;
  const char *table_name=0;
6144
  bool found_unaliased_non_uniq= 0;
6145 6146 6147 6148 6149
  /*
    true if the item that we search for is a valid name reference
    (and not an item that happens to have a name).
  */
  bool is_ref_by_name= 0;
Staale Smedseng's avatar
Staale Smedseng committed
6150
  uint unaliased_counter= 0;
6151

unknown's avatar
unknown committed
6152
  *resolution= NOT_RESOLVED;
6153

6154 6155 6156
  is_ref_by_name= (find->type() == Item::FIELD_ITEM  || 
                   find->type() == Item::REF_ITEM);
  if (is_ref_by_name)
unknown's avatar
unknown committed
6157 6158 6159
  {
    field_name= ((Item_ident*) find)->field_name;
    table_name= ((Item_ident*) find)->table_name;
6160
    db_name=    ((Item_ident*) find)->db_name;
unknown's avatar
unknown committed
6161 6162
  }

6163
  for (uint i= 0; (item=li++); i++)
unknown's avatar
unknown committed
6164
  {
6165
    if (field_name && item->real_item()->type() == Item::FIELD_ITEM)
unknown's avatar
unknown committed
6166
    {
6167
      Item_ident *item_field= (Item_ident*) item;
6168

unknown's avatar
unknown committed
6169 6170 6171 6172 6173 6174
      /*
	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
      */ 
6175 6176 6177 6178
      if (!item_field->name)
        continue;

      if (table_name)
unknown's avatar
unknown committed
6179
      {
6180 6181 6182
        /*
          If table name is specified we should find field 'field_name' in
          table 'table_name'. According to SQL-standard we should ignore
6183 6184 6185 6186 6187
          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.
6188

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

	  item_field->field_name and item_field->table_name can be 0x0 if
6194
	  item is not fix_field()'ed yet.
6195
        */
6196 6197
        if (item_field->field_name && item_field->table_name &&
	    !my_strcasecmp(system_charset_info, item_field->field_name,
6198
                           field_name) &&
unknown's avatar
unknown committed
6199 6200
            !my_strcasecmp(table_alias_charset, item_field->table_name, 
                           table_name) &&
6201 6202 6203
            (!db_name || (item_field->db_name &&
                          !strcmp(item_field->db_name, db_name))))
        {
6204
          if (found_unaliased)
6205
          {
6206 6207 6208 6209 6210 6211 6212
            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.
            */
6213
            if (report_error != IGNORE_ERRORS)
6214 6215
              my_error(ER_NON_UNIQ_ERROR, MYF(0),
                       find->full_name(), current_thd->where);
6216 6217
            return (Item**) 0;
          }
6218 6219
          found_unaliased= li.ref();
          unaliased_counter= i;
unknown's avatar
unknown committed
6220
          *resolution= RESOLVED_IGNORING_ALIAS;
6221 6222
          if (db_name)
            break;                              // Perfect match
6223 6224
        }
      }
unknown's avatar
unknown committed
6225
      else
6226
      {
unknown's avatar
unknown committed
6227 6228 6229 6230 6231
        int fname_cmp= my_strcasecmp(system_charset_info,
                                     item_field->field_name,
                                     field_name);
        if (!my_strcasecmp(system_charset_info,
                           item_field->name,field_name))
6232
        {
unknown's avatar
unknown committed
6233 6234 6235 6236 6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252
          /*
            If table name was not given we should scan through aliases
            and 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;
          *resolution= fname_cmp ? RESOLVED_AGAINST_ALIAS:
	                           RESOLVED_WITH_NO_ALIAS;
6253
        }
unknown's avatar
unknown committed
6254
        else if (!fname_cmp)
6255
        {
unknown's avatar
unknown committed
6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267
          /*
            We will use non-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;
          }
6268 6269 6270
          found_unaliased= li.ref();
          unaliased_counter= i;
        }
unknown's avatar
unknown committed
6271 6272
      }
    }
unknown's avatar
unknown committed
6273 6274 6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287 6288 6289
    else if (!table_name)
    { 
      if (is_ref_by_name && find->name && item->name &&
	  !my_strcasecmp(system_charset_info,item->name,find->name))
      {
        found= li.ref();
        *counter= i;
        *resolution= RESOLVED_AGAINST_ALIAS;
        break;
      }
      else if (find->eq(item,0))
      {
        found= li.ref();
        *counter= i;
        *resolution= RESOLVED_IGNORING_ALIAS;
        break;
      }
6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319
    }
    else if (table_name && item->type() == Item::REF_ITEM &&
             ((Item_ref *)item)->ref_type() == Item_ref::VIEW_REF)
    {
      /*
        TODO:Here we process prefixed view references only. What we should 
        really do is process all types of Item_refs. But this will currently 
        lead to a clash with the way references to outer SELECTs (from the 
        HAVING clause) are handled in e.g. :
        SELECT 1 FROM t1 AS t1_o GROUP BY a
          HAVING (SELECT t1_o.a FROM t1 AS t1_i GROUP BY t1_i.a LIMIT 1).
        Processing all Item_refs here will cause t1_o.a to resolve to itself.
        We still need to process the special case of Item_direct_view_ref 
        because in the context of views they have the same meaning as 
        Item_field for tables.
      */
      Item_ident *item_ref= (Item_ident *) item;
      if (item_ref->name && item_ref->table_name &&
          !my_strcasecmp(system_charset_info, item_ref->name, field_name) &&
          !my_strcasecmp(table_alias_charset, item_ref->table_name,
                         table_name) &&
          (!db_name || (item_ref->db_name && 
                        !strcmp (item_ref->db_name, db_name))))
      {
        found= li.ref();
        *counter= i;
        *resolution= RESOLVED_IGNORING_ALIAS;
        break;
      }
    }
unknown's avatar
unknown committed
6320
  }
6321 6322 6323 6324 6325
  if (!found)
  {
    if (found_unaliased_non_uniq)
    {
      if (report_error != IGNORE_ERRORS)
6326 6327
        my_error(ER_NON_UNIQ_ERROR, MYF(0),
                 find->full_name(), current_thd->where);
6328 6329 6330 6331 6332 6333
      return (Item **) 0;
    }
    if (found_unaliased)
    {
      found= found_unaliased;
      *counter= unaliased_counter;
unknown's avatar
unknown committed
6334
      *resolution= RESOLVED_BEHIND_ALIAS;
6335 6336
    }
  }
6337 6338
  if (found)
    return found;
6339
  if (report_error != REPORT_EXCEPT_NOT_FOUND)
6340 6341
  {
    if (report_error == REPORT_ALL_ERRORS)
6342 6343
      my_error(ER_BAD_FIELD_ERROR, MYF(0),
               find->full_name(), current_thd->where);
6344 6345 6346 6347
    return (Item **) 0;
  }
  else
    return (Item **) not_found_item;
unknown's avatar
unknown committed
6348 6349
}

unknown's avatar
unknown committed
6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361 6362 6363 6364 6365 6366 6367 6368 6369 6370 6371 6372 6373 6374 6375 6376 6377

/*
  Test if a string is a member of a list of strings.

  SYNOPSIS
    test_if_string_in_list()
    find      the string to look for
    str_list  a list of strings to be searched

  DESCRIPTION
    Sequentially search a list of strings for a string, and test whether
    the list contains the same string.

  RETURN
    TRUE  if find is in str_list
    FALSE otherwise
*/

static bool
test_if_string_in_list(const char *find, List<String> *str_list)
{
  List_iterator<String> str_list_it(*str_list);
  String *curr_str;
  size_t find_length= strlen(find);
  while ((curr_str= str_list_it++))
  {
    if (find_length != curr_str->length())
      continue;
6378
    if (!my_strcasecmp(system_charset_info, find, curr_str->ptr()))
unknown's avatar
unknown committed
6379 6380 6381 6382 6383 6384 6385 6386 6387 6388 6389 6390 6391 6392 6393 6394 6395 6396 6397 6398 6399
      return TRUE;
  }
  return FALSE;
}


/*
  Create a new name resolution context for an item so that it is
  being resolved in a specific table reference.

  SYNOPSIS
    set_new_item_local_context()
    thd        pointer to current thread
    item       item for which new context is created and set
    table_ref  table ref where an item showld be resolved

  DESCRIPTION
    Create a new name resolution context for an item, so that the item
    is resolved only the supplied 'table_ref'.

  RETURN
6400 6401
    FALSE  if all OK
    TRUE   otherwise
unknown's avatar
unknown committed
6402 6403 6404 6405 6406 6407
*/

static bool
set_new_item_local_context(THD *thd, Item_ident *item, TABLE_LIST *table_ref)
{
  Name_resolution_context *context;
6408
  if (!(context= new (thd->mem_root) Name_resolution_context))
unknown's avatar
unknown committed
6409 6410
    return TRUE;
  context->init();
6411 6412
  context->first_name_resolution_table=
    context->last_name_resolution_table= table_ref;
unknown's avatar
unknown committed
6413 6414 6415 6416 6417 6418 6419 6420 6421 6422 6423 6424 6425 6426 6427 6428 6429 6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444
  item->context= context;
  return FALSE;
}


/*
  Find and mark the common columns of two table references.

  SYNOPSIS
    mark_common_columns()
    thd                [in] current thread
    table_ref_1        [in] the first (left) join operand
    table_ref_2        [in] the second (right) join operand
    using_fields       [in] if the join is JOIN...USING - the join columns,
                            if NATURAL join, then NULL
    found_using_fields [out] number of fields from the USING clause that were
                             found among the common fields

  DESCRIPTION
    The procedure finds the common columns of two relations (either
    tables or intermediate join results), and adds an equi-join condition
    to the ON clause of 'table_ref_2' for each pair of matching columns.
    If some of table_ref_XXX represents a base table or view, then we
    create new 'Natural_join_column' instances for each column
    reference and store them in the 'join_columns' of the table
    reference.

  IMPLEMENTATION
    The procedure assumes that store_natural_using_join_columns() was
    called for the previous level of NATURAL/USING joins.

  RETURN
6445 6446
    TRUE   error when some common column is non-unique, or out of memory
    FALSE  OK
unknown's avatar
unknown committed
6447 6448 6449 6450 6451 6452 6453 6454 6455 6456
*/

static bool
mark_common_columns(THD *thd, TABLE_LIST *table_ref_1, TABLE_LIST *table_ref_2,
                    List<String> *using_fields, uint *found_using_fields)
{
  Field_iterator_table_ref it_1, it_2;
  Natural_join_column *nj_col_1, *nj_col_2;
  Query_arena *arena, backup;
  bool result= TRUE;
unknown's avatar
unknown committed
6457 6458 6459 6460 6461 6462 6463 6464 6465 6466 6467
  bool first_outer_loop= TRUE;
  /*
    Leaf table references to which new natural join columns are added
    if the leaves are != NULL.
  */
  TABLE_LIST *leaf_1= (table_ref_1->nested_join &&
                       !table_ref_1->is_natural_join) ?
                      NULL : table_ref_1;
  TABLE_LIST *leaf_2= (table_ref_2->nested_join &&
                       !table_ref_2->is_natural_join) ?
                      NULL : table_ref_2;
unknown's avatar
unknown committed
6468 6469

  DBUG_ENTER("mark_common_columns");
6470
  DBUG_PRINT("info", ("operand_1: %s  operand_2: %s",
unknown's avatar
unknown committed
6471 6472
                      table_ref_1->alias, table_ref_2->alias));

6473
  *found_using_fields= 0;
unknown's avatar
unknown committed
6474
  arena= thd->activate_stmt_arena_if_needed(&backup);
unknown's avatar
unknown committed
6475 6476 6477

  for (it_1.set(table_ref_1); !it_1.end_of_fields(); it_1.next())
  {
6478
    bool found= FALSE;
unknown's avatar
unknown committed
6479
    const char *field_name_1;
6480 6481
    /* true if field_name_1 is a member of using_fields */
    bool is_using_column_1;
6482
    if (!(nj_col_1= it_1.get_or_create_column_ref(thd, leaf_1)))
unknown's avatar
unknown committed
6483 6484
      goto err;
    field_name_1= nj_col_1->name();
6485 6486 6487 6488 6489
    is_using_column_1= using_fields && 
      test_if_string_in_list(field_name_1, using_fields);
    DBUG_PRINT ("info", ("field_name_1=%s.%s", 
                         nj_col_1->table_name() ? nj_col_1->table_name() : "", 
                         field_name_1));
unknown's avatar
unknown committed
6490

6491 6492 6493 6494 6495 6496 6497
    /*
      Find a field with the same name in table_ref_2.

      Note that for the second loop, it_2.set() will iterate over
      table_ref_2->join_columns and not generate any new elements or
      lists.
    */
unknown's avatar
unknown committed
6498 6499 6500 6501
    nj_col_2= NULL;
    for (it_2.set(table_ref_2); !it_2.end_of_fields(); it_2.next())
    {
      Natural_join_column *cur_nj_col_2;
6502
      const char *cur_field_name_2;
6503
      if (!(cur_nj_col_2= it_2.get_or_create_column_ref(thd, leaf_2)))
unknown's avatar
unknown committed
6504
        goto err;
6505
      cur_field_name_2= cur_nj_col_2->name();
6506 6507 6508 6509
      DBUG_PRINT ("info", ("cur_field_name_2=%s.%s", 
                           cur_nj_col_2->table_name() ? 
                             cur_nj_col_2->table_name() : "", 
                           cur_field_name_2));
unknown's avatar
unknown committed
6510

unknown's avatar
unknown committed
6511 6512 6513 6514 6515 6516
      /*
        Compare the two columns and check for duplicate common fields.
        A common field is duplicate either if it was already found in
        table_ref_2 (then found == TRUE), or if a field in table_ref_2
        was already matched by some previous field in table_ref_1
        (then cur_nj_col_2->is_common == TRUE).
6517 6518 6519 6520
        Note that it is too early to check the columns outside of the
        USING list for ambiguity because they are not actually "referenced"
        here. These columns must be checked only on unqualified reference 
        by name (e.g. in SELECT list).
unknown's avatar
unknown committed
6521
      */
unknown's avatar
unknown committed
6522 6523
      if (!my_strcasecmp(system_charset_info, field_name_1, cur_field_name_2))
      {
6524 6525 6526
        DBUG_PRINT ("info", ("match c1.is_common=%d", nj_col_1->is_common));
        if (cur_nj_col_2->is_common ||
            (found && (!using_fields || is_using_column_1)))
unknown's avatar
unknown committed
6527 6528 6529 6530 6531 6532 6533 6534
        {
          my_error(ER_NON_UNIQ_ERROR, MYF(0), field_name_1, thd->where);
          goto err;
        }
        nj_col_2= cur_nj_col_2;
        found= TRUE;
      }
    }
unknown's avatar
unknown committed
6535 6536 6537 6538 6539 6540 6541 6542 6543
    if (first_outer_loop && leaf_2)
    {
      /*
        Make sure that the next inner loop "knows" that all columns
        are materialized already.
      */
      leaf_2->is_join_columns_complete= TRUE;
      first_outer_loop= FALSE;
    }
unknown's avatar
unknown committed
6544
    if (!found)
6545
      continue;                                 // No matching field
unknown's avatar
unknown committed
6546 6547 6548 6549 6550 6551

    /*
      field_1 and field_2 have the same names. Check if they are in the USING
      clause (if present), mark them as common fields, and add a new
      equi-join condition to the ON clause.
    */
6552
    if (nj_col_2 && (!using_fields ||is_using_column_1))
unknown's avatar
unknown committed
6553 6554 6555 6556 6557 6558
    {
      Item *item_1=   nj_col_1->create_item(thd);
      Item *item_2=   nj_col_2->create_item(thd);
      Field *field_1= nj_col_1->field();
      Field *field_2= nj_col_2->field();
      Item_ident *item_ident_1, *item_ident_2;
6559 6560 6561 6562 6563
      Item_func_eq *eq_cond;

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

unknown's avatar
unknown committed
6564
      /*
6565
        The following assert checks that the two created items are of
unknown's avatar
unknown committed
6566 6567 6568 6569 6570 6571 6572 6573 6574 6575 6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589
        type Item_ident.
      */
      DBUG_ASSERT(!thd->lex->current_select->no_wrap_view_item);
      /*
        In the case of no_wrap_view_item == 0, the created items must be
        of sub-classes of Item_ident.
      */
      DBUG_ASSERT(item_1->type() == Item::FIELD_ITEM ||
                  item_1->type() == Item::REF_ITEM);
      DBUG_ASSERT(item_2->type() == Item::FIELD_ITEM ||
                  item_2->type() == Item::REF_ITEM);

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

6594 6595
      if (!(eq_cond= new Item_func_eq(item_ident_1, item_ident_2)))
        goto err;                               /* Out of memory. */
unknown's avatar
unknown committed
6596 6597 6598 6599 6600 6601

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

      nj_col_1->is_common= nj_col_2->is_common= TRUE;
6607 6608 6609 6610 6611 6612 6613
      DBUG_PRINT ("info", ("%s.%s and %s.%s are common", 
                           nj_col_1->table_name() ? 
                             nj_col_1->table_name() : "", 
                           nj_col_1->name(),
                           nj_col_2->table_name() ? 
                             nj_col_2->table_name() : "", 
                           nj_col_2->name()));
unknown's avatar
unknown committed
6614 6615 6616

      if (field_1)
      {
unknown's avatar
unknown committed
6617
        TABLE *table_1= nj_col_1->table_ref->table;
unknown's avatar
unknown committed
6618
        /* Mark field_1 used for table cache. */
6619
        bitmap_set_bit(table_1->read_set, field_1->field_index);
6620
        table_1->covering_keys.intersect(field_1->part_of_key);
6621
        table_1->merge_keys.merge(field_1->part_of_key);
unknown's avatar
unknown committed
6622 6623 6624
      }
      if (field_2)
      {
unknown's avatar
unknown committed
6625
        TABLE *table_2= nj_col_2->table_ref->table;
unknown's avatar
unknown committed
6626
        /* Mark field_2 used for table cache. */
6627
        bitmap_set_bit(table_2->read_set, field_2->field_index);
6628
        table_2->covering_keys.intersect(field_2->part_of_key);
6629
        table_2->merge_keys.merge(field_2->part_of_key);
unknown's avatar
unknown committed
6630 6631 6632 6633 6634 6635
      }

      if (using_fields != NULL)
        ++(*found_using_fields);
    }
  }
unknown's avatar
unknown committed
6636 6637
  if (leaf_1)
    leaf_1->is_join_columns_complete= TRUE;
unknown's avatar
unknown committed
6638 6639 6640 6641 6642 6643 6644 6645 6646 6647 6648 6649

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

err:
  if (arena)
unknown's avatar
unknown committed
6650
    thd->restore_active_arena(arena, &backup);
unknown's avatar
unknown committed
6651 6652 6653 6654 6655 6656 6657 6658 6659 6660 6661 6662 6663 6664 6665 6666 6667 6668 6669 6670 6671 6672 6673 6674 6675 6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686
  DBUG_RETURN(result);
}



/*
  Materialize and store the row type of NATURAL/USING join.

  SYNOPSIS
    store_natural_using_join_columns()
    thd                current thread
    natural_using_join the table reference of the NATURAL/USING join
    table_ref_1        the first (left) operand (of a NATURAL/USING join).
    table_ref_2        the second (right) operand (of a NATURAL/USING join).
    using_fields       if the join is JOIN...USING - the join columns,
                       if NATURAL join, then NULL
    found_using_fields number of fields from the USING clause that were
                       found among the common fields

  DESCRIPTION
    Iterate over the columns of both join operands and sort and store
    all columns into the 'join_columns' list of natural_using_join
    where the list is formed by three parts:
      part1: The coalesced columns of table_ref_1 and table_ref_2,
             sorted according to the column order of the first table.
      part2: The other columns of the first table, in the order in
             which they were defined in CREATE TABLE.
      part3: The other columns of the second table, in the order in
             which they were defined in CREATE TABLE.
    Time complexity - O(N1+N2), where Ni = length(table_ref_i).

  IMPLEMENTATION
    The procedure assumes that mark_common_columns() has been called
    for the join that is being processed.

  RETURN
6687 6688
    TRUE    error: Some common column is ambiguous
    FALSE   OK
unknown's avatar
unknown committed
6689 6690 6691 6692 6693 6694 6695 6696 6697 6698 6699 6700 6701
*/

static bool
store_natural_using_join_columns(THD *thd, TABLE_LIST *natural_using_join,
                                 TABLE_LIST *table_ref_1,
                                 TABLE_LIST *table_ref_2,
                                 List<String> *using_fields,
                                 uint found_using_fields)
{
  Field_iterator_table_ref it_1, it_2;
  Natural_join_column *nj_col_1, *nj_col_2;
  Query_arena *arena, backup;
  bool result= TRUE;
6702
  List<Natural_join_column> *non_join_columns;
unknown's avatar
unknown committed
6703 6704
  DBUG_ENTER("store_natural_using_join_columns");

6705 6706
  DBUG_ASSERT(!natural_using_join->join_columns);

unknown's avatar
unknown committed
6707
  arena= thd->activate_stmt_arena_if_needed(&backup);
unknown's avatar
unknown committed
6708

6709 6710
  if (!(non_join_columns= new List<Natural_join_column>) ||
      !(natural_using_join->join_columns= new List<Natural_join_column>))
unknown's avatar
unknown committed
6711 6712 6713 6714 6715
    goto err;

  /* Append the columns of the first join operand. */
  for (it_1.set(table_ref_1); !it_1.end_of_fields(); it_1.next())
  {
6716
    nj_col_1= it_1.get_natural_column_ref();
unknown's avatar
unknown committed
6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731 6732 6733 6734 6735 6736 6737
    if (nj_col_1->is_common)
    {
      natural_using_join->join_columns->push_back(nj_col_1);
      /* Reset the common columns for the next call to mark_common_columns. */
      nj_col_1->is_common= FALSE;
    }
    else
      non_join_columns->push_back(nj_col_1);
  }

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

      for (;;)
unknown's avatar
unknown committed
6744
      {
6745 6746 6747 6748 6749 6750 6751
        /* If reached the end of fields, and none was found, report error. */
        if (!(common_field= it++))
        {
          my_error(ER_BAD_FIELD_ERROR, MYF(0), using_field_name_ptr,
                   current_thd->where);
          goto err;
        }
unknown's avatar
unknown committed
6752 6753
        if (!my_strcasecmp(system_charset_info,
                           common_field->name(), using_field_name_ptr))
6754
          break;                                // Found match
unknown's avatar
unknown committed
6755 6756 6757 6758 6759 6760 6761
      }
    }
  }

  /* Append the non-equi-join columns of the second join operand. */
  for (it_2.set(table_ref_2); !it_2.end_of_fields(); it_2.next())
  {
6762
    nj_col_2= it_2.get_natural_column_ref();
unknown's avatar
unknown committed
6763 6764 6765
    if (!nj_col_2->is_common)
      non_join_columns->push_back(nj_col_2);
    else
6766
    {
unknown's avatar
unknown committed
6767 6768
      /* Reset the common columns for the next call to mark_common_columns. */
      nj_col_2->is_common= FALSE;
6769
    }
unknown's avatar
unknown committed
6770 6771 6772 6773 6774 6775 6776 6777 6778 6779
  }

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

  result= FALSE;

err:
  if (arena)
unknown's avatar
unknown committed
6780
    thd->restore_active_arena(arena, &backup);
unknown's avatar
unknown committed
6781 6782 6783
  DBUG_RETURN(result);
}

6784

unknown's avatar
unknown committed
6785 6786 6787 6788 6789 6790 6791 6792 6793 6794 6795 6796 6797 6798 6799 6800 6801 6802 6803 6804 6805 6806 6807 6808 6809 6810
/*
  Precompute and store the row types of the top-most NATURAL/USING joins.

  SYNOPSIS
    store_top_level_join_columns()
    thd            current thread
    table_ref      nested join or table in a FROM clause
    left_neighbor  neighbor table reference to the left of table_ref at the
                   same level in the join tree
    right_neighbor neighbor table reference to the right of table_ref at the
                   same level in the join tree

  DESCRIPTION
    The procedure performs a post-order traversal of a nested join tree
    and materializes the row types of NATURAL/USING joins in a
    bottom-up manner until it reaches the TABLE_LIST elements that
    represent the top-most NATURAL/USING joins. The procedure should be
    applied to each element of SELECT_LEX::top_join_list (i.e. to each
    top-level element of the FROM clause).

  IMPLEMENTATION
    Notice that the table references in the list nested_join->join_list
    are in reverse order, thus when we iterate over it, we are moving
    from the right to the left in the FROM clause.

  RETURN
6811 6812
    TRUE   Error
    FALSE  OK
unknown's avatar
unknown committed
6813 6814 6815 6816 6817 6818 6819
*/

static bool
store_top_level_join_columns(THD *thd, TABLE_LIST *table_ref,
                             TABLE_LIST *left_neighbor,
                             TABLE_LIST *right_neighbor)
{
unknown's avatar
unknown committed
6820 6821 6822
  Query_arena *arena, backup;
  bool result= TRUE;

unknown's avatar
unknown committed
6823
  DBUG_ENTER("store_top_level_join_columns");
6824

unknown's avatar
unknown committed
6825
  arena= thd->activate_stmt_arena_if_needed(&backup);
unknown's avatar
unknown committed
6826

unknown's avatar
unknown committed
6827 6828 6829 6830
  /* Call the procedure recursively for each nested table reference. */
  if (table_ref->nested_join)
  {
    List_iterator_fast<TABLE_LIST> nested_it(table_ref->nested_join->join_list);
unknown's avatar
unknown committed
6831 6832 6833 6834
    TABLE_LIST *same_level_left_neighbor= nested_it++;
    TABLE_LIST *same_level_right_neighbor= NULL;
    /* Left/right-most neighbors, possibly at higher levels in the join tree. */
    TABLE_LIST *real_left_neighbor, *real_right_neighbor;
6835

unknown's avatar
unknown committed
6836
    while (same_level_left_neighbor)
unknown's avatar
unknown committed
6837
    {
unknown's avatar
unknown committed
6838 6839
      TABLE_LIST *cur_table_ref= same_level_left_neighbor;
      same_level_left_neighbor= nested_it++;
6840 6841 6842 6843
      /*
        The order of RIGHT JOIN operands is reversed in 'join list' to
        transform it into a LEFT JOIN. However, in this procedure we need
        the join operands in their lexical order, so below we reverse the
unknown's avatar
unknown committed
6844 6845 6846 6847 6848
        join operands. Notice that this happens only in the first loop,
        and not in the second one, as in the second loop
        same_level_left_neighbor == NULL.
        This is the correct behavior, because the second loop sets
        cur_table_ref reference correctly after the join operands are
6849 6850
        swapped in the first loop.
      */
unknown's avatar
unknown committed
6851
      if (same_level_left_neighbor &&
6852 6853 6854 6855
          cur_table_ref->outer_join & JOIN_TYPE_RIGHT)
      {
        /* This can happen only for JOIN ... ON. */
        DBUG_ASSERT(table_ref->nested_join->join_list.elements == 2);
unknown's avatar
unknown committed
6856
        swap_variables(TABLE_LIST*, same_level_left_neighbor, cur_table_ref);
6857 6858
      }

unknown's avatar
unknown committed
6859 6860 6861 6862 6863 6864 6865 6866 6867
      /*
        Pick the parent's left and right neighbors if there are no immediate
        neighbors at the same level.
      */
      real_left_neighbor=  (same_level_left_neighbor) ?
                           same_level_left_neighbor : left_neighbor;
      real_right_neighbor= (same_level_right_neighbor) ?
                           same_level_right_neighbor : right_neighbor;

6868 6869
      if (cur_table_ref->nested_join &&
          store_top_level_join_columns(thd, cur_table_ref,
unknown's avatar
unknown committed
6870
                                       real_left_neighbor, real_right_neighbor))
unknown's avatar
unknown committed
6871
        goto err;
unknown's avatar
unknown committed
6872
      same_level_right_neighbor= cur_table_ref;
unknown's avatar
unknown committed
6873 6874 6875 6876 6877 6878 6879 6880 6881 6882 6883 6884 6885 6886 6887 6888 6889 6890 6891 6892 6893 6894 6895 6896 6897 6898 6899 6900 6901 6902
    }
  }

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

    /*
      The two join operands were interchanged in the parser, change the order
      back for 'mark_common_columns'.
    */
    if (table_ref_2->outer_join & JOIN_TYPE_RIGHT)
      swap_variables(TABLE_LIST*, table_ref_1, table_ref_2);
    if (mark_common_columns(thd, table_ref_1, table_ref_2,
                            using_fields, &found_using_fields))
unknown's avatar
unknown committed
6903
      goto err;
unknown's avatar
unknown committed
6904 6905 6906 6907 6908 6909 6910 6911 6912 6913 6914

    /*
      Swap the join operands back, so that we pick the columns of the second
      one as the coalesced columns. In this way the coalesced columns are the
      same as of an equivalent LEFT JOIN.
    */
    if (table_ref_1->outer_join & JOIN_TYPE_RIGHT)
      swap_variables(TABLE_LIST*, table_ref_1, table_ref_2);
    if (store_natural_using_join_columns(thd, table_ref, table_ref_1,
                                         table_ref_2, using_fields,
                                         found_using_fields))
unknown's avatar
unknown committed
6915
      goto err;
unknown's avatar
unknown committed
6916 6917 6918 6919 6920 6921 6922 6923 6924

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

unknown's avatar
unknown committed
6925 6926 6927 6928 6929
    /* Add a TRUE condition to outer joins that have no common columns. */
    if (table_ref_2->outer_join &&
        !table_ref_1->on_expr && !table_ref_2->on_expr)
      table_ref_2->on_expr= new Item_int((longlong) 1,1);   /* Always true. */

unknown's avatar
unknown committed
6930 6931 6932
    /* Change this table reference to become a leaf for name resolution. */
    if (left_neighbor)
    {
6933
      TABLE_LIST *last_leaf_on_the_left;
unknown's avatar
unknown committed
6934 6935 6936 6937 6938
      last_leaf_on_the_left= left_neighbor->last_leaf_for_name_resolution();
      last_leaf_on_the_left->next_name_resolution_table= table_ref;
    }
    if (right_neighbor)
    {
6939
      TABLE_LIST *first_leaf_on_the_right;
unknown's avatar
unknown committed
6940 6941 6942 6943 6944 6945
      first_leaf_on_the_right= right_neighbor->first_leaf_for_name_resolution();
      table_ref->next_name_resolution_table= first_leaf_on_the_right;
    }
    else
      table_ref->next_name_resolution_table= NULL;
  }
unknown's avatar
unknown committed
6946 6947 6948 6949
  result= FALSE; /* All is OK. */

err:
  if (arena)
unknown's avatar
unknown committed
6950
    thd->restore_active_arena(arena, &backup);
unknown's avatar
unknown committed
6951
  DBUG_RETURN(result);
unknown's avatar
unknown committed
6952 6953 6954 6955 6956 6957 6958 6959 6960 6961 6962 6963 6964 6965 6966 6967 6968 6969 6970 6971 6972 6973 6974 6975
}


/*
  Compute and store the row types of the top-most NATURAL/USING joins
  in a FROM clause.

  SYNOPSIS
    setup_natural_join_row_types()
    thd          current thread
    from_clause  list of top-level table references in a FROM clause

  DESCRIPTION
    Apply the procedure 'store_top_level_join_columns' to each of the
    top-level table referencs of the FROM clause. Adjust the list of tables
    for name resolution - context->first_name_resolution_table to the
    top-most, lef-most NATURAL/USING join.

  IMPLEMENTATION
    Notice that the table references in 'from_clause' are in reverse
    order, thus when we iterate over it, we are moving from the right
    to the left in the FROM clause.

  RETURN
6976 6977
    TRUE   Error
    FALSE  OK
unknown's avatar
unknown committed
6978
*/
6979 6980
static bool setup_natural_join_row_types(THD *thd,
                                         List<TABLE_LIST> *from_clause,
unknown's avatar
unknown committed
6981 6982 6983 6984 6985 6986 6987 6988 6989
                                         Name_resolution_context *context)
{
  thd->where= "from clause";
  if (from_clause->elements == 0)
    return FALSE; /* We come here in the case of UNIONs. */

  List_iterator_fast<TABLE_LIST> table_ref_it(*from_clause);
  TABLE_LIST *table_ref; /* Current table reference. */
  /* Table reference to the left of the current. */
6990
  TABLE_LIST *left_neighbor;
unknown's avatar
unknown committed
6991 6992
  /* Table reference to the right of the current. */
  TABLE_LIST *right_neighbor= NULL;
6993 6994 6995 6996
  bool save_first_natural_join_processing=
    context->select_lex->first_natural_join_processing;

  context->select_lex->first_natural_join_processing= FALSE;
unknown's avatar
unknown committed
6997

6998 6999
  /* Note that tables in the list are in reversed order */
  for (left_neighbor= table_ref_it++; left_neighbor ; )
unknown's avatar
unknown committed
7000 7001 7002
  {
    table_ref= left_neighbor;
    left_neighbor= table_ref_it++;
7003 7004 7005 7006 7007 7008
    /* 
      Do not redo work if already done:
      1) for stored procedures,
      2) for multitable update after lock failure and table reopening.
    */
    if (save_first_natural_join_processing)
unknown's avatar
unknown committed
7009
    {
7010
      context->select_lex->first_natural_join_processing= FALSE;
7011 7012 7013 7014 7015 7016 7017 7018 7019
      if (store_top_level_join_columns(thd, table_ref,
                                       left_neighbor, right_neighbor))
        return TRUE;
      if (left_neighbor)
      {
        TABLE_LIST *first_leaf_on_the_right;
        first_leaf_on_the_right= table_ref->first_leaf_for_name_resolution();
        left_neighbor->next_name_resolution_table= first_leaf_on_the_right;
      }
unknown's avatar
unknown committed
7020 7021 7022 7023 7024 7025 7026
    }
    right_neighbor= table_ref;
  }

  /*
    Store the top-most, left-most NATURAL/USING join, so that we start
    the search from that one instead of context->table_list. At this point
7027
    right_neighbor points to the left-most top-level table reference in the
unknown's avatar
unknown committed
7028 7029 7030 7031 7032 7033 7034 7035 7036 7037
    FROM clause.
  */
  DBUG_ASSERT(right_neighbor);
  context->first_name_resolution_table=
    right_neighbor->first_leaf_for_name_resolution();

  return FALSE;
}


unknown's avatar
unknown committed
7038
/****************************************************************************
7039
** Expand all '*' in given fields
unknown's avatar
unknown committed
7040 7041
****************************************************************************/

7042 7043 7044
int setup_wild(THD *thd, TABLE_LIST *tables, List<Item> &fields,
	       List<Item> *sum_func_list,
	       uint wild_num)
unknown's avatar
unknown committed
7045
{
7046
  if (!wild_num)
7047
    return(0);
7048

7049
  Item *item;
unknown's avatar
unknown committed
7050
  List_iterator<Item> it(fields);
unknown's avatar
unknown committed
7051
  Query_arena *arena, backup;
7052
  DBUG_ENTER("setup_wild");
unknown's avatar
unknown committed
7053 7054

  /*
7055 7056
    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
unknown's avatar
unknown committed
7057
  */
unknown's avatar
unknown committed
7058
  arena= thd->activate_stmt_arena_if_needed(&backup);
7059

7060
  thd->lex->current_select->cur_pos_in_select_list= 0;
unknown's avatar
unknown committed
7061
  while (wild_num && (item= it++))
unknown's avatar
VIEW  
unknown committed
7062
  {
7063 7064
    if (item->type() == Item::FIELD_ITEM &&
        ((Item_field*) item)->field_name &&
7065 7066
	((Item_field*) item)->field_name[0] == '*' &&
	!((Item_field*) item)->field)
7067
    {
7068
      uint elem= fields.elements;
unknown's avatar
VIEW  
unknown committed
7069
      bool any_privileges= ((Item_field *) item)->any_privileges;
unknown's avatar
unknown committed
7070 7071 7072 7073 7074 7075 7076 7077 7078
      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.
        */
7079 7080
        it.replace(new Item_int("Not_used", (longlong) 1,
                                MY_INT64_NUM_DECIMAL_DIGITS));
unknown's avatar
unknown committed
7081
      }
7082 7083
      else if (insert_fields(thd, ((Item_field*) item)->context,
                             ((Item_field*) item)->db_name,
unknown's avatar
unknown committed
7084
                             ((Item_field*) item)->table_name, &it,
7085
                             any_privileges))
unknown's avatar
unknown committed
7086 7087
      {
	if (arena)
unknown's avatar
unknown committed
7088
	  thd->restore_active_arena(arena, &backup);
7089
	DBUG_RETURN(-1);
unknown's avatar
unknown committed
7090
      }
7091
      if (sum_func_list)
7092 7093 7094 7095 7096 7097 7098 7099
      {
	/*
	  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;
      }
7100
      wild_num--;
7101
    }
7102 7103
    else
      thd->lex->current_select->cur_pos_in_select_list++;
7104
  }
7105
  thd->lex->current_select->cur_pos_in_select_list= UNDEF_POS;
unknown's avatar
unknown committed
7106 7107 7108 7109 7110
  if (arena)
  {
    /* make * substituting permanent */
    SELECT_LEX *select_lex= thd->lex->current_select;
    select_lex->with_wild= 0;
7111 7112 7113 7114 7115 7116 7117
    /*   
      The assignment below is translated to memcpy() call (at least on some
      platforms). memcpy() expects that source and destination areas do not
      overlap. That problem was detected by valgrind. 
    */
    if (&select_lex->item_list != &fields)
      select_lex->item_list= fields;
unknown's avatar
unknown committed
7118

unknown's avatar
unknown committed
7119
    thd->restore_active_arena(arena, &backup);
unknown's avatar
unknown committed
7120
  }
7121
  DBUG_RETURN(0);
7122 7123
}

7124 7125 7126 7127
/****************************************************************************
** Check that all given fields exists and fill struct with current data
****************************************************************************/

7128
bool setup_fields(THD *thd, Item **ref_pointer_array,
7129
                  List<Item> &fields, enum_mark_columns mark_used_columns,
unknown's avatar
unknown committed
7130
                  List<Item> *sum_func_list, bool allow_sum_func)
7131 7132
{
  reg2 Item *item;
7133
  enum_mark_columns save_mark_used_columns= thd->mark_used_columns;
unknown's avatar
unknown committed
7134
  nesting_map save_allow_sum_func= thd->lex->allow_sum_func;
7135
  List_iterator<Item> it(fields);
7136
  bool save_is_item_list_lookup;
7137 7138
  DBUG_ENTER("setup_fields");

7139 7140
  thd->mark_used_columns= mark_used_columns;
  DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
unknown's avatar
unknown committed
7141 7142
  if (allow_sum_func)
    thd->lex->allow_sum_func|= 1 << thd->lex->current_select->nest_level;
7143
  thd->where= THD::DEFAULT_WHERE;
7144 7145
  save_is_item_list_lookup= thd->lex->current_select->is_item_list_lookup;
  thd->lex->current_select->is_item_list_lookup= 0;
7146

7147 7148 7149 7150 7151 7152 7153 7154 7155 7156 7157 7158 7159 7160
  /*
    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);

7161 7162 7163 7164 7165 7166 7167 7168 7169 7170 7171 7172 7173 7174 7175 7176
  /*
    We call set_entry() there (before fix_fields() of the whole list of field
    items) because:
    1) the list of field items has same order as in the query, and the
       Item_func_get_user_var item may go before the Item_func_set_user_var:
          SELECT @a, @a := 10 FROM t;
    2) The entry->update_query_id value controls constantness of
       Item_func_get_user_var items, so in presence of Item_func_set_user_var
       items we have to refresh their entries before fixing of
       Item_func_get_user_var items.
  */
  List_iterator<Item_func_set_user_var> li(thd->lex->set_var_list);
  Item_func_set_user_var *var;
  while ((var= li++))
    var->set_entry(thd, FALSE);

unknown's avatar
unknown committed
7177
  Item **ref= ref_pointer_array;
7178
  thd->lex->current_select->cur_pos_in_select_list= 0;
unknown's avatar
unknown committed
7179
  while ((item= it++))
7180
  {
7181
    if ((!item->fixed && item->fix_fields(thd, it.ref())) ||
unknown's avatar
unknown committed
7182
	(item= *(it.ref()))->check_cols(1))
unknown's avatar
unknown committed
7183
    {
7184
      thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
unknown's avatar
unknown committed
7185
      thd->lex->allow_sum_func= save_allow_sum_func;
7186 7187
      thd->mark_used_columns= save_mark_used_columns;
      DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
unknown's avatar
unknown committed
7188
      DBUG_RETURN(TRUE); /* purecov: inspected */
unknown's avatar
unknown committed
7189
    }
unknown's avatar
unknown committed
7190 7191
    if (ref)
      *(ref++)= item;
7192 7193
    if (item->with_sum_func && item->type() != Item::SUM_FUNC_ITEM &&
	sum_func_list)
7194
      item->split_sum_func(thd, ref_pointer_array, *sum_func_list);
unknown's avatar
unknown committed
7195
    thd->used_tables|= item->used_tables();
7196
    thd->lex->current_select->cur_pos_in_select_list++;
7197
  }
7198
  thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
7199 7200
  thd->lex->current_select->cur_pos_in_select_list= UNDEF_POS;

unknown's avatar
unknown committed
7201
  thd->lex->allow_sum_func= save_allow_sum_func;
7202 7203
  thd->mark_used_columns= save_mark_used_columns;
  DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
7204
  DBUG_RETURN(test(thd->is_error()));
7205
}
7206

7207

7208 7209 7210 7211 7212 7213 7214 7215 7216 7217 7218 7219 7220 7221 7222
/*
  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)
  {
7223 7224 7225 7226 7227 7228
    if (table->merge_underlying_list)
    {
      DBUG_ASSERT(table->view &&
                  table->effective_algorithm == VIEW_ALGORITHM_MERGE);
      list= make_leaves_list(list, table->merge_underlying_list);
    }
7229 7230 7231 7232 7233 7234 7235 7236 7237
    else
    {
      *list= table;
      list= &table->next_leaf;
    }
  }
  return list;
}

7238
/*
unknown's avatar
unknown committed
7239 7240 7241 7242
  prepare tables

  SYNOPSIS
    setup_tables()
unknown's avatar
unknown committed
7243
    thd		  Thread handler
7244
    context       name resolution contest to setup table list there
unknown's avatar
unknown committed
7245 7246 7247
    from_clause   Top-level list of table references in the FROM clause
    tables	  Table list (select_lex->table_list)
    leaves        List of join table leaves list (select_lex->leaf_tables)
unknown's avatar
unknown committed
7248 7249
    refresh       It is onle refresh for subquery
    select_insert It is SELECT ... INSERT command
unknown's avatar
unknown committed
7250

unknown's avatar
unknown committed
7251 7252
  NOTE
    Check also that the 'used keys' and 'ignored keys' exists and set up the
unknown's avatar
unknown committed
7253 7254 7255 7256
    table structure accordingly.
    Create a list of leaf tables. For queries with NATURAL/USING JOINs,
    compute the row types of the top most natural/using join table references
    and link these into a list of table references for name resolution.
7257

unknown's avatar
unknown committed
7258 7259
    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.
unknown's avatar
VIEW  
unknown committed
7260

unknown's avatar
unknown committed
7261
  RETURN
unknown's avatar
unknown committed
7262
    FALSE ok;  In this case *map will includes the chosen index
unknown's avatar
unknown committed
7263
    TRUE  error
7264 7265
*/

7266
bool setup_tables(THD *thd, Name_resolution_context *context,
unknown's avatar
unknown committed
7267
                  List<TABLE_LIST> *from_clause, TABLE_LIST *tables,
7268
                  TABLE_LIST **leaves, bool select_insert)
7269
{
unknown's avatar
unknown committed
7270
  uint tablenr= 0;
7271
  DBUG_ENTER("setup_tables");
7272

7273 7274
  DBUG_ASSERT ((select_insert && !tables->next_name_resolution_table) || !tables || 
               (context->table_list && context->first_name_resolution_table));
unknown's avatar
unknown committed
7275 7276
  /*
    this is used for INSERT ... SELECT.
7277
    For select we setup tables except first (and its underlying tables)
unknown's avatar
unknown committed
7278 7279 7280 7281
  */
  TABLE_LIST *first_select_table= (select_insert ?
                                   tables->next_local:
                                   0);
7282 7283 7284
  if (!(*leaves))
    make_leaves_list(leaves, tables);

unknown's avatar
unknown committed
7285 7286
  TABLE_LIST *table_list;
  for (table_list= *leaves;
unknown's avatar
VIEW  
unknown committed
7287
       table_list;
7288
       table_list= table_list->next_leaf, tablenr++)
unknown's avatar
unknown committed
7289
  {
unknown's avatar
unknown committed
7290
    TABLE *table= table_list->table;
unknown's avatar
unknown committed
7291
    table->pos_in_table_list= table_list;
unknown's avatar
unknown committed
7292
    if (first_select_table &&
7293
        table_list->top_table() == first_select_table)
unknown's avatar
unknown committed
7294 7295 7296 7297 7298
    {
      /* new counting for SELECT of INSERT ... SELECT command */
      first_select_table= 0;
      tablenr= 0;
    }
unknown's avatar
unknown committed
7299
    setup_table_map(table, table_list, tablenr);
7300 7301
    if (table_list->process_index_hints(table))
      DBUG_RETURN(1);
unknown's avatar
unknown committed
7302 7303 7304 7305
  }
  if (tablenr > MAX_TABLES)
  {
    my_error(ER_TOO_MANY_TABLES,MYF(0),MAX_TABLES);
7306
    DBUG_RETURN(1);
unknown's avatar
unknown committed
7307
  }
unknown's avatar
unknown committed
7308
  for (table_list= tables;
7309 7310
       table_list;
       table_list= table_list->next_local)
7311
  {
7312
    if (table_list->merge_underlying_list)
7313
    {
7314 7315
      DBUG_ASSERT(table_list->view &&
                  table_list->effective_algorithm == VIEW_ALGORITHM_MERGE);
unknown's avatar
unknown committed
7316
      Query_arena *arena= thd->stmt_arena, backup;
7317 7318 7319 7320
      bool res;
      if (arena->is_conventional())
        arena= 0;                                   // For easier test
      else
unknown's avatar
unknown committed
7321
        thd->set_n_backup_active_arena(arena, &backup);
7322
      res= table_list->setup_underlying(thd);
7323
      if (arena)
unknown's avatar
unknown committed
7324
        thd->restore_active_arena(arena, &backup);
7325 7326 7327
      if (res)
        DBUG_RETURN(1);
    }
7328
  }
unknown's avatar
unknown committed
7329 7330 7331 7332 7333

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

7334
  DBUG_RETURN(0);
unknown's avatar
unknown committed
7335
}
7336

unknown's avatar
unknown committed
7337

7338 7339 7340 7341 7342 7343 7344 7345 7346 7347 7348 7349 7350 7351 7352 7353 7354 7355 7356 7357 7358 7359 7360 7361 7362 7363 7364
/*
  prepare tables and check access for the view tables

  SYNOPSIS
    setup_tables_and_check_view_access()
    thd		  Thread handler
    context       name resolution contest to setup table list there
    from_clause   Top-level list of table references in the FROM clause
    tables	  Table list (select_lex->table_list)
    conds	  Condition of current SELECT (can be changed by VIEW)
    leaves        List of join table leaves list (select_lex->leaf_tables)
    refresh       It is onle refresh for subquery
    select_insert It is SELECT ... INSERT command
    want_access   what access is needed

  NOTE
    a wrapper for check_tables that will also check the resulting
    table leaves list for access to all the tables that belong to a view

  RETURN
    FALSE ok;  In this case *map will include the chosen index
    TRUE  error
*/
bool setup_tables_and_check_access(THD *thd, 
                                   Name_resolution_context *context,
                                   List<TABLE_LIST> *from_clause,
                                   TABLE_LIST *tables,
unknown's avatar
unknown committed
7365
                                   TABLE_LIST **leaves,
7366
                                   bool select_insert,
7367
                                   ulong want_access_first,
7368 7369
                                   ulong want_access)
{
unknown's avatar
unknown committed
7370
  TABLE_LIST *leaves_tmp= NULL;
7371
  bool first_table= true;
7372

unknown's avatar
unknown committed
7373 7374
  if (setup_tables(thd, context, from_clause, tables,
                   &leaves_tmp, select_insert))
7375 7376
    return TRUE;

unknown's avatar
unknown committed
7377 7378
  if (leaves)
    *leaves= leaves_tmp;
7379 7380

  for (; leaves_tmp; leaves_tmp= leaves_tmp->next_leaf)
unknown's avatar
unknown committed
7381
  {
7382
    if (leaves_tmp->belong_to_view && 
7383
        check_single_table_access(thd, first_table ? want_access_first :
7384
                                  want_access, leaves_tmp, FALSE))
7385 7386 7387 7388
    {
      tables->hide_view_error(thd);
      return TRUE;
    }
7389
    first_table= 0;
unknown's avatar
unknown committed
7390
  }
7391 7392 7393 7394
  return FALSE;
}


7395 7396 7397 7398 7399 7400 7401 7402 7403 7404 7405 7406 7407 7408 7409
/*
   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,
7410
                               List<String> *index_list)
unknown's avatar
unknown committed
7411
{
unknown's avatar
unknown committed
7412
  List_iterator_fast<String> it(*index_list);
unknown's avatar
unknown committed
7413 7414
  String *name;
  uint pos;
7415 7416

  map->clear_all();
unknown's avatar
unknown committed
7417 7418
  while ((name=it++))
  {
7419 7420 7421
    if (table->s->keynames.type_names == 0 ||
        (pos= find_type(&table->s->keynames, name->ptr(),
                        name->length(), 1)) <=
7422
        0)
unknown's avatar
unknown committed
7423
    {
7424
      my_error(ER_KEY_DOES_NOT_EXITS, MYF(0), name->c_ptr(),
unknown's avatar
unknown committed
7425
	       table->pos_in_table_list->alias);
7426
      map->set_all();
7427
      return 1;
unknown's avatar
unknown committed
7428
    }
7429
    map->set_bit(pos-1);
unknown's avatar
unknown committed
7430
  }
7431
  return 0;
unknown's avatar
unknown committed
7432 7433
}

7434

7435 7436 7437 7438 7439 7440
/*
  Drops in all fields instead of current '*' field

  SYNOPSIS
    insert_fields()
    thd			Thread handler
7441
    context             Context for name resolution
7442 7443 7444 7445 7446 7447 7448
    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
  RETURN
7449
    0	ok     'it' is updated to point at last inserted
unknown's avatar
unknown committed
7450
    1	error.  Error message is generated but not sent to client
7451
*/
unknown's avatar
unknown committed
7452

unknown's avatar
unknown committed
7453
bool
7454
insert_fields(THD *thd, Name_resolution_context *context, const char *db_name,
unknown's avatar
VIEW  
unknown committed
7455
	      const char *table_name, List_iterator<Item> *it,
7456
              bool any_privileges)
unknown's avatar
unknown committed
7457
{
unknown's avatar
unknown committed
7458 7459
  Field_iterator_table_ref field_iterator;
  bool found;
unknown's avatar
unknown committed
7460
  char name_buff[NAME_LEN+1];
unknown's avatar
unknown committed
7461
  DBUG_ENTER("insert_fields");
unknown's avatar
unknown committed
7462
  DBUG_PRINT("arena", ("stmt arena: 0x%lx", (ulong)thd->stmt_arena));
unknown's avatar
unknown committed
7463

7464 7465
  if (db_name && lower_case_table_names)
  {
unknown's avatar
unknown committed
7466 7467 7468 7469 7470
    /*
      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
    */
unknown's avatar
unknown committed
7471
    strmake(name_buff, db_name, sizeof(name_buff)-1);
unknown's avatar
unknown committed
7472
    my_casedn_str(files_charset_info, name_buff);
unknown's avatar
unknown committed
7473
    db_name= name_buff;
7474 7475
  }

unknown's avatar
unknown committed
7476
  found= FALSE;
7477 7478 7479 7480 7481 7482 7483 7484

  /*
    If table names are qualified, then loop over all tables used in the query,
    else treat natural joins as leaves and do not iterate over their underlying
    tables.
  */
  for (TABLE_LIST *tables= (table_name ? context->table_list :
                            context->first_name_resolution_table);
7485
       tables;
7486 7487 7488
       tables= (table_name ? tables->next_local :
                tables->next_name_resolution_table)
       )
unknown's avatar
unknown committed
7489
  {
7490 7491 7492
    Field *field;
    TABLE *table= tables->table;

unknown's avatar
unknown committed
7493 7494
    DBUG_ASSERT(tables->is_leaf_for_name_resolution());

7495 7496
    if ((table_name && my_strcasecmp(table_alias_charset, table_name,
                                    tables->alias)) ||
7497 7498
        (db_name && strcmp(tables->db,db_name)))
      continue;
unknown's avatar
unknown committed
7499

unknown's avatar
unknown committed
7500
#ifndef NO_EMBEDDED_ACCESS_CHECKS
7501 7502 7503 7504 7505 7506 7507 7508 7509 7510 7511 7512 7513 7514 7515 7516 7517 7518 7519 7520 7521 7522 7523 7524 7525 7526
    /* 
       Ensure that we have access rights to all fields to be inserted. Under
       some circumstances, this check may be skipped.

       - If any_privileges is true, skip the check.

       - If the SELECT privilege has been found as fulfilled already for both
         the TABLE and TABLE_LIST objects (and both of these exist, of
         course), the check is skipped.

       - If the SELECT privilege has been found fulfilled for the TABLE object
         and the TABLE_LIST represents a derived table other than a view (see
         below), the check is skipped.

       - If the TABLE_LIST object represents a view, we may skip checking if
         the SELECT privilege has been found fulfilled for it, regardless of
         the TABLE object.

       - If there is no TABLE object, the test is skipped if either 
         * the TABLE_LIST does not represent a view, or
         * the SELECT privilege has been found fulfilled.         

       A TABLE_LIST that is not a view may be a subquery, an
       information_schema table, or a nested table reference. See the comment
       for TABLE_LIST.
    */
7527
    if (!((table && !tables->view && (table->grant.privilege & SELECT_ACL)) ||
Staale Smedseng's avatar
Staale Smedseng committed
7528
          (tables->view && (tables->grant.privilege & SELECT_ACL))) &&
unknown's avatar
unknown committed
7529 7530 7531
        !any_privileges)
    {
      field_iterator.set(tables);
7532
      if (check_grant_all_columns(thd, SELECT_ACL, &field_iterator))
unknown's avatar
unknown committed
7533 7534
        DBUG_RETURN(TRUE);
    }
unknown's avatar
unknown committed
7535
#endif
unknown's avatar
VIEW  
unknown committed
7536

unknown's avatar
unknown committed
7537 7538 7539 7540 7541 7542 7543 7544 7545 7546 7547 7548 7549 7550 7551 7552 7553 7554 7555 7556 7557
    /*
      Update the tables used in the query based on the referenced fields. For
      views and natural joins this update is performed inside the loop below.
    */
    if (table)
      thd->used_tables|= table->map;

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

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

      if (!(item= field_iterator.create_item(thd)))
        DBUG_RETURN(TRUE);
7558 7559 7560 7561
      DBUG_ASSERT(item->fixed);
      /* cache the table for the Item_fields inserted by expanding stars */
      if (item->type() == Item::FIELD_ITEM && tables->cacheable_table)
        ((Item_field *)item)->cached_table= tables;
unknown's avatar
unknown committed
7562 7563

      if (!found)
7564
      {
unknown's avatar
unknown committed
7565
        found= TRUE;
7566
        it->replace(item); /* Replace '*' with the first found item. */
7567
      }
unknown's avatar
VIEW  
unknown committed
7568
      else
unknown's avatar
unknown committed
7569 7570 7571 7572 7573 7574 7575
        it->after(item);   /* Add 'item' to the SELECT list. */

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

unknown's avatar
unknown committed
7588 7589 7590
        if (!tables->schema_table && 
            !(fld->have_privileges=
              (get_column_grant(thd, field_iterator.grant(),
7591
                                field_iterator.get_db_name(),
7592
                                field_table_name, fld->field_name) &
unknown's avatar
unknown committed
7593 7594
               VIEW_ANY_ACL)))
        {
7595
          my_error(ER_TABLEACCESS_DENIED_ERROR, MYF(0), "ANY",
7596 7597
                   thd->security_ctx->priv_user,
                   thd->security_ctx->host_or_ip,
7598
                   field_table_name);
unknown's avatar
unknown committed
7599 7600
          DBUG_RETURN(TRUE);
        }
7601
      }
unknown's avatar
unknown committed
7602
#endif
7603

unknown's avatar
unknown committed
7604
      if ((field= field_iterator.field()))
unknown's avatar
unknown committed
7605
      {
7606 7607
        /* Mark fields as used to allow storage engine to optimze access */
        bitmap_set_bit(field->table->read_set, field->field_index);
unknown's avatar
unknown committed
7608
        if (table)
7609
        {
7610
          table->covering_keys.intersect(field->part_of_key);
7611 7612
          table->merge_keys.merge(field->part_of_key);
        }
unknown's avatar
unknown committed
7613
        if (tables->is_natural_join)
unknown's avatar
unknown committed
7614
        {
unknown's avatar
unknown committed
7615 7616
          TABLE *field_table;
          /*
7617
            In this case we are sure that the column ref will not be created
unknown's avatar
unknown committed
7618
            because it was already created and stored with the natural join.
7619
          */
unknown's avatar
unknown committed
7620
          Natural_join_column *nj_col;
unknown's avatar
unknown committed
7621
          if (!(nj_col= field_iterator.get_natural_column_ref()))
unknown's avatar
unknown committed
7622
            DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7623
          DBUG_ASSERT(nj_col->table_field);
unknown's avatar
unknown committed
7624 7625
          field_table= nj_col->table_ref->table;
          if (field_table)
unknown's avatar
VIEW  
unknown committed
7626
          {
unknown's avatar
unknown committed
7627
            thd->used_tables|= field_table->map;
7628
            field_table->covering_keys.intersect(field->part_of_key);
7629
            field_table->merge_keys.merge(field->part_of_key);
unknown's avatar
unknown committed
7630
            field_table->used_fields++;
unknown's avatar
VIEW  
unknown committed
7631
          }
unknown's avatar
unknown committed
7632
        }
unknown's avatar
unknown committed
7633
      }
unknown's avatar
unknown committed
7634 7635
      else
        thd->used_tables|= item->used_tables();
7636
      thd->lex->current_select->cur_pos_in_select_list++;
unknown's avatar
unknown committed
7637
    }
unknown's avatar
unknown committed
7638 7639 7640 7641 7642 7643 7644 7645
    /*
      In case of stored tables, all fields are considered as used,
      while in the case of views, the fields considered as used are the
      ones marked in setup_tables during fix_fields of view columns.
      For NATURAL joins, used_tables is updated in the IF above.
    */
    if (table)
      table->used_fields= table->s->fields;
unknown's avatar
unknown committed
7646
  }
7647
  if (found)
unknown's avatar
unknown committed
7648
    DBUG_RETURN(FALSE);
7649

unknown's avatar
unknown committed
7650
  /*
7651 7652 7653
    TODO: in the case when we skipped all columns because there was a
    qualified '*', and all columns were coalesced, we have to give a more
    meaningful message than ER_BAD_TABLE_ERROR.
unknown's avatar
unknown committed
7654
  */
7655
  if (!table_name)
unknown's avatar
unknown committed
7656
    my_message(ER_NO_TABLES_USED, ER(ER_NO_TABLES_USED), MYF(0));
7657 7658
  else
    my_error(ER_BAD_TABLE_ERROR, MYF(0), table_name);
unknown's avatar
unknown committed
7659 7660

  DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7661 7662 7663 7664
}


/*
unknown's avatar
unknown committed
7665
  Fix all conditions and outer join expressions.
7666 7667 7668 7669

  SYNOPSIS
    setup_conds()
    thd     thread handler
unknown's avatar
unknown committed
7670 7671 7672 7673 7674 7675 7676 7677 7678 7679
    tables  list of tables for name resolving (select_lex->table_list)
    leaves  list of leaves of join table tree (select_lex->leaf_tables)
    conds   WHERE clause

  DESCRIPTION
    TODO

  RETURN
    TRUE  if some error occured (e.g. out of memory)
    FALSE if all is OK
unknown's avatar
unknown committed
7680 7681
*/

7682 7683
int setup_conds(THD *thd, TABLE_LIST *tables, TABLE_LIST *leaves,
                COND **conds)
unknown's avatar
unknown committed
7684
{
unknown's avatar
unknown committed
7685
  SELECT_LEX *select_lex= thd->lex->current_select;
unknown's avatar
unknown committed
7686
  Query_arena *arena= thd->stmt_arena, backup;
unknown's avatar
unknown committed
7687
  TABLE_LIST *table= NULL;	// For HP compilers
7688 7689 7690 7691 7692 7693 7694 7695 7696 7697
  /*
    it_is_update set to TRUE when tables of primary SELECT_LEX (SELECT_LEX
    which belong to LEX, i.e. most up SELECT) will be updated by
    INSERT/UPDATE/LOAD
    NOTE: using this condition helps to prevent call of prepare_check_option()
    from subquery of VIEW, because tables of subquery belongs to VIEW
    (see condition before prepare_check_option() call)
  */
  bool it_is_update= (select_lex == &thd->lex->select_lex) &&
    thd->lex->which_check_option_applicable();
7698 7699
  bool save_is_item_list_lookup= select_lex->is_item_list_lookup;
  select_lex->is_item_list_lookup= 0;
unknown's avatar
unknown committed
7700
  DBUG_ENTER("setup_conds");
unknown's avatar
unknown committed
7701

unknown's avatar
unknown committed
7702
  if (select_lex->conds_processed_with_permanent_arena ||
unknown's avatar
unknown committed
7703
      arena->is_conventional())
unknown's avatar
unknown committed
7704 7705
    arena= 0;                                   // For easier test

7706 7707
  thd->mark_used_columns= MARK_COLUMNS_READ;
  DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
unknown's avatar
unknown committed
7708
  select_lex->cond_count= 0;
7709
  select_lex->between_count= 0;
unknown's avatar
unknown committed
7710
  select_lex->max_equal_elems= 0;
unknown's avatar
VIEW  
unknown committed
7711

7712 7713 7714 7715 7716 7717
  for (table= tables; table; table= table->next_local)
  {
    if (table->prepare_where(thd, conds, FALSE))
      goto err_no_arena;
  }

unknown's avatar
unknown committed
7718 7719 7720
  if (*conds)
  {
    thd->where="where clause";
7721
    if ((!(*conds)->fixed && (*conds)->fix_fields(thd, conds)) ||
unknown's avatar
unknown committed
7722
	(*conds)->check_cols(1))
7723
      goto err_no_arena;
unknown's avatar
unknown committed
7724 7725
  }

unknown's avatar
unknown committed
7726 7727 7728 7729
  /*
    Apply fix_fields() to all ON clauses at all levels of nesting,
    including the ones inside view definitions.
  */
unknown's avatar
merge  
unknown committed
7730
  for (table= leaves; table; table= table->next_leaf)
unknown's avatar
unknown committed
7731
  {
unknown's avatar
unknown committed
7732 7733
    TABLE_LIST *embedded; /* The table at the current level of nesting. */
    TABLE_LIST *embedding= table; /* The parent nested table reference. */
7734
    do
unknown's avatar
VIEW  
unknown committed
7735
    {
7736 7737
      embedded= embedding;
      if (embedded->on_expr)
7738
      {
7739 7740
        /* Make a join an a expression */
        thd->where="on clause";
7741 7742
        if ((!embedded->on_expr->fixed &&
            embedded->on_expr->fix_fields(thd, &embedded->on_expr)) ||
7743
	    embedded->on_expr->check_cols(1))
7744
	  goto err_no_arena;
unknown's avatar
unknown committed
7745
        select_lex->cond_count++;
7746
      }
7747
      embedding= embedded->embedding;
unknown's avatar
unknown committed
7748
    }
7749 7750
    while (embedding &&
           embedding->nested_join->join_list.head() == embedded);
7751 7752 7753 7754

    /* process CHECK OPTION */
    if (it_is_update)
    {
unknown's avatar
unknown committed
7755
      TABLE_LIST *view= table->top_table();
7756 7757 7758 7759 7760 7761 7762
      if (view->effective_with_check)
      {
        if (view->prepare_check_option(thd))
          goto err_no_arena;
        thd->change_item_tree(&table->check_option, view->check_option);
      }
    }
unknown's avatar
unknown committed
7763
  }
unknown's avatar
unknown committed
7764

unknown's avatar
unknown committed
7765
  if (!thd->stmt_arena->is_conventional())
unknown's avatar
unknown committed
7766 7767 7768 7769 7770 7771 7772 7773 7774 7775
  {
    /*
      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;
  }
7776
  thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
7777
  DBUG_RETURN(test(thd->is_error()));
unknown's avatar
unknown committed
7778

7779
err_no_arena:
7780
  select_lex->is_item_list_lookup= save_is_item_list_lookup;
unknown's avatar
unknown committed
7781
  DBUG_RETURN(1);
unknown's avatar
unknown committed
7782 7783 7784 7785 7786 7787 7788 7789
}


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

unknown's avatar
unknown committed
7790 7791 7792 7793 7794 7795 7796 7797 7798 7799 7800

/*
  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

7801 7802 7803 7804 7805
  NOTE
    fill_record() may set table->auto_increment_field_not_null and a
    caller should make sure that it is reset after their last call to this
    function.

unknown's avatar
unknown committed
7806 7807 7808 7809 7810
  RETURN
    FALSE   OK
    TRUE    error occured
*/

unknown's avatar
unknown committed
7811
static bool
unknown's avatar
unknown committed
7812 7813
fill_record(THD * thd, List<Item> &fields, List<Item> &values,
            bool ignore_errors)
unknown's avatar
unknown committed
7814
{
unknown's avatar
unknown committed
7815
  List_iterator_fast<Item> f(fields),v(values);
7816
  Item *value, *fld;
unknown's avatar
unknown committed
7817
  Item_field *field;
7818
  TABLE *table= 0;
unknown's avatar
unknown committed
7819 7820
  DBUG_ENTER("fill_record");

7821 7822 7823 7824 7825 7826 7827 7828 7829 7830 7831 7832 7833 7834 7835 7836 7837 7838 7839 7840
  /*
    Reset the table->auto_increment_field_not_null as it is valid for
    only one row.
  */
  if (fields.elements)
  {
    /*
      On INSERT or UPDATE fields are checked to be from the same table,
      thus we safely can take table from the first field.
    */
    fld= (Item_field*)f++;
    if (!(field= fld->filed_for_view_update()))
    {
      my_error(ER_NONUPDATEABLE_COLUMN, MYF(0), fld->name);
      goto err;
    }
    table= field->field->table;
    table->auto_increment_field_not_null= FALSE;
    f.rewind();
  }
7841
  while ((fld= f++))
unknown's avatar
unknown committed
7842
  {
7843 7844 7845
    if (!(field= fld->filed_for_view_update()))
    {
      my_error(ER_NONUPDATEABLE_COLUMN, MYF(0), fld->name);
7846
      goto err;
7847
    }
unknown's avatar
unknown committed
7848
    value=v++;
7849
    Field *rfield= field->field;
7850
    table= rfield->table;
unknown's avatar
unknown committed
7851
    if (rfield == table->next_number_field)
unknown's avatar
unknown committed
7852
      table->auto_increment_field_not_null= TRUE;
unknown's avatar
unknown committed
7853
    if ((value->save_in_field(rfield, 0) < 0) && !ignore_errors)
unknown's avatar
unknown committed
7854 7855
    {
      my_message(ER_UNKNOWN_ERROR, ER(ER_UNKNOWN_ERROR), MYF(0));
7856
      goto err;
unknown's avatar
unknown committed
7857
    }
unknown's avatar
unknown committed
7858
  }
7859
  DBUG_RETURN(thd->is_error());
7860 7861 7862 7863
err:
  if (table)
    table->auto_increment_field_not_null= FALSE;
  DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7864 7865 7866
}


unknown's avatar
unknown committed
7867 7868 7869 7870 7871 7872 7873 7874 7875 7876 7877 7878 7879 7880 7881 7882 7883 7884 7885 7886 7887 7888 7889 7890 7891 7892 7893 7894 7895 7896
/*
  Fill fields in list with values from the list of items and invoke
  before triggers.

  SYNOPSIS
    fill_record_n_invoke_before_triggers()
      thd           thread context
      fields        Item_fields list to be filled
      values        values to fill with
      ignore_errors TRUE if we should ignore errors
      triggers      object holding list of triggers to be invoked
      event         event type for triggers to be invoked

  NOTE
    This function assumes that fields which values will be set and triggers
    to be invoked belong to the same table, and that TABLE::record[0] and
    record[1] buffers correspond to new and old versions of row respectively.

  RETURN
    FALSE   OK
    TRUE    error occured
*/

bool
fill_record_n_invoke_before_triggers(THD *thd, List<Item> &fields,
                                     List<Item> &values, bool ignore_errors,
                                     Table_triggers_list *triggers,
                                     enum trg_event_type event)
{
  return (fill_record(thd, fields, values, ignore_errors) ||
7897 7898
          (triggers && triggers->process_triggers(thd, event,
                                                 TRG_ACTION_BEFORE, TRUE)));
unknown's avatar
unknown committed
7899 7900 7901
}


unknown's avatar
unknown committed
7902 7903 7904 7905 7906 7907 7908 7909 7910 7911
/*
  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

7912 7913 7914 7915 7916
  NOTE
    fill_record() may set table->auto_increment_field_not_null and a
    caller should make sure that it is reset after their last call to this
    function.

unknown's avatar
unknown committed
7917 7918 7919 7920 7921 7922 7923
  RETURN
    FALSE   OK
    TRUE    error occured
*/

bool
fill_record(THD *thd, Field **ptr, List<Item> &values, bool ignore_errors)
unknown's avatar
unknown committed
7924
{
unknown's avatar
unknown committed
7925
  List_iterator_fast<Item> v(values);
unknown's avatar
unknown committed
7926
  Item *value;
7927
  TABLE *table= 0;
unknown's avatar
unknown committed
7928 7929 7930
  DBUG_ENTER("fill_record");

  Field *field;
7931 7932 7933 7934 7935 7936 7937 7938 7939 7940 7941 7942 7943
  /*
    Reset the table->auto_increment_field_not_null as it is valid for
    only one row.
  */
  if (*ptr)
  {
    /*
      On INSERT or UPDATE fields are checked to be from the same table,
      thus we safely can take table from the first field.
    */
    table= (*ptr)->table;
    table->auto_increment_field_not_null= FALSE;
  }
7944
  while ((field = *ptr++) && ! thd->is_error())
unknown's avatar
unknown committed
7945 7946
  {
    value=v++;
7947
    table= field->table;
unknown's avatar
unknown committed
7948
    if (field == table->next_number_field)
unknown's avatar
unknown committed
7949
      table->auto_increment_field_not_null= TRUE;
7950
    if (value->save_in_field(field, 0) < 0)
7951
      goto err;
unknown's avatar
unknown committed
7952
  }
7953
  DBUG_RETURN(thd->is_error());
7954 7955 7956 7957 7958

err:
  if (table)
    table->auto_increment_field_not_null= FALSE;
  DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7959 7960 7961
}


unknown's avatar
unknown committed
7962 7963 7964 7965 7966 7967 7968 7969 7970 7971 7972 7973 7974 7975 7976 7977 7978 7979 7980 7981 7982 7983 7984 7985 7986 7987 7988 7989 7990 7991
/*
  Fill fields in array with values from the list of items and invoke
  before triggers.

  SYNOPSIS
    fill_record_n_invoke_before_triggers()
      thd           thread context
      ptr           NULL-ended array of fields to be filled
      values        values to fill with
      ignore_errors TRUE if we should ignore errors
      triggers      object holding list of triggers to be invoked
      event         event type for triggers to be invoked

  NOTE
    This function assumes that fields which values will be set and triggers
    to be invoked belong to the same table, and that TABLE::record[0] and
    record[1] buffers correspond to new and old versions of row respectively.

  RETURN
    FALSE   OK
    TRUE    error occured
*/

bool
fill_record_n_invoke_before_triggers(THD *thd, Field **ptr,
                                     List<Item> &values, bool ignore_errors,
                                     Table_triggers_list *triggers,
                                     enum trg_event_type event)
{
  return (fill_record(thd, ptr, values, ignore_errors) ||
7992 7993
          (triggers && triggers->process_triggers(thd, event,
                                                 TRG_ACTION_BEFORE, TRUE)));
unknown's avatar
unknown committed
7994 7995 7996
}


7997
my_bool mysql_rm_tmp_tables(void)
unknown's avatar
unknown committed
7998
{
unknown's avatar
unknown committed
7999
  uint i, idx;
8000
  char	filePath[FN_REFLEN], *tmpdir, filePathCopy[FN_REFLEN];
unknown's avatar
unknown committed
8001 8002
  MY_DIR *dirp;
  FILEINFO *file;
unknown's avatar
unknown committed
8003
  TABLE_SHARE share;
8004
  THD *thd;
unknown's avatar
unknown committed
8005 8006
  DBUG_ENTER("mysql_rm_tmp_tables");

8007 8008
  if (!(thd= new THD))
    DBUG_RETURN(1);
unknown's avatar
unknown committed
8009
  thd->thread_stack= (char*) &thd;
8010 8011
  thd->store_globals();

unknown's avatar
unknown committed
8012 8013 8014
  for (i=0; i<=mysql_tmpdir_list.max; i++)
  {
    tmpdir=mysql_tmpdir_list.list[i];
unknown's avatar
unknown committed
8015
    /* See if the directory exists */
unknown's avatar
unknown committed
8016 8017
    if (!(dirp = my_dir(tmpdir,MYF(MY_WME | MY_DONT_SORT))))
      continue;
unknown's avatar
unknown committed
8018

unknown's avatar
unknown committed
8019
    /* Remove all SQLxxx tables from directory */
unknown's avatar
unknown committed
8020

unknown's avatar
unknown committed
8021 8022 8023
    for (idx=0 ; idx < (uint) dirp->number_off_files ; idx++)
    {
      file=dirp->dir_entry+idx;
unknown's avatar
unknown committed
8024

unknown's avatar
unknown committed
8025 8026 8027 8028
      /* skiping . and .. */
      if (file->name[0] == '.' && (!file->name[1] ||
                                   (file->name[1] == '.' &&  !file->name[2])))
        continue;
unknown's avatar
unknown committed
8029

8030 8031
      if (!bcmp((uchar*) file->name, (uchar*) tmp_file_prefix,
                tmp_file_prefix_length))
unknown's avatar
unknown committed
8032
      {
unknown's avatar
unknown committed
8033 8034 8035 8036 8037
        char *ext= fn_ext(file->name);
        uint ext_len= strlen(ext);
        uint filePath_len= my_snprintf(filePath, sizeof(filePath),
                                       "%s%c%s", tmpdir, FN_LIBCHAR,
                                       file->name);
8038
        if (!bcmp((uchar*) reg_ext, (uchar*) ext, ext_len))
8039
        {
unknown's avatar
unknown committed
8040 8041 8042 8043
          handler *handler_file= 0;
          /* We should cut file extention before deleting of table */
          memcpy(filePathCopy, filePath, filePath_len - ext_len);
          filePathCopy[filePath_len - ext_len]= 0;
8044
          init_tmp_table_share(thd, &share, "", 0, "", filePathCopy);
unknown's avatar
unknown committed
8045 8046
          if (!open_table_def(thd, &share, 0) &&
              ((handler_file= get_new_handler(&share, thd->mem_root,
unknown's avatar
unknown committed
8047
                                              share.db_type()))))
unknown's avatar
unknown committed
8048
          {
8049
            handler_file->ha_delete_table(filePathCopy);
unknown's avatar
unknown committed
8050 8051 8052
            delete handler_file;
          }
          free_table_share(&share);
8053
        }
unknown's avatar
unknown committed
8054 8055 8056 8057 8058
        /*
          File can be already deleted by tmp_table.file->delete_table().
          So we hide error messages which happnes during deleting of these
          files(MYF(0)).
        */
Konstantin Osipov's avatar
Konstantin Osipov committed
8059
        (void) my_delete(filePath, MYF(0)); 
unknown's avatar
unknown committed
8060
      }
unknown's avatar
unknown committed
8061
    }
unknown's avatar
unknown committed
8062
    my_dirend(dirp);
unknown's avatar
unknown committed
8063
  }
8064 8065 8066
  delete thd;
  my_pthread_setspecific_ptr(THR_THD,  0);
  DBUG_RETURN(0);
unknown's avatar
unknown committed
8067 8068 8069 8070 8071 8072 8073 8074 8075
}



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

/*
unknown's avatar
unknown committed
8076 8077 8078 8079 8080
  free all unused tables

  NOTE
    This is called by 'handle_manager' when one wants to periodicly flush
    all not used tables.
unknown's avatar
unknown committed
8081 8082 8083 8084 8085 8086
*/

void flush_tables()
{
  (void) pthread_mutex_lock(&LOCK_open);
  while (unused_tables)
8087
    free_cache_entry(unused_tables);
unknown's avatar
unknown committed
8088 8089 8090 8091
  (void) pthread_mutex_unlock(&LOCK_open);
}


8092 8093 8094 8095 8096 8097 8098 8099 8100 8101 8102 8103 8104 8105 8106 8107 8108 8109 8110 8111 8112 8113 8114 8115 8116
/**
   A callback to the server internals that is used to address
   special cases of the locking protocol.
   Invoked when acquiring an exclusive lock, for each thread that
   has a conflicting shared metadata lock.

   This function:
     - aborts waiting of the thread on a data lock, to make it notice
       the pending exclusive lock and back off.
     - if the thread is an INSERT DELAYED thread, sends it a KILL
       signal to terminate it.

   @note This function does not wait for the thread to give away its
         locks. Waiting is done outside for all threads at once.

   @param thd    Current thread context
   @param in_use The thread to wake up

   @retval  TRUE  if the thread was woken up
   @retval  FALSE otherwise (e.g. it was not waiting for a table-level lock).

   @note It is one of two places where border between MDL and the
         rest of the server is broken.
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
8117
bool mysql_notify_thread_having_shared_lock(THD *thd, THD *in_use)
8118 8119 8120 8121 8122 8123 8124 8125 8126 8127 8128 8129 8130 8131 8132 8133 8134
{
  bool signalled= FALSE;
  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_cond_broadcast(in_use->mysys_var->current_cond);
    pthread_mutex_unlock(&in_use->mysys_var->mutex);
    signalled= TRUE;
  }
  pthread_mutex_lock(&LOCK_open);
  for (TABLE *thd_table= in_use->open_tables;
       thd_table ;
       thd_table= thd_table->next)
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
8135 8136 8137 8138 8139 8140 8141
    /*
      Check for TABLE::db_stat is needed since in some places we call
      handler::close() for table instance (and set TABLE::db_stat to 0)
      and do not remove such instances from the THD::open_tables
      for some time, during which other thread can see those instances
      (e.g. see partitioning code).
    */
8142 8143 8144 8145 8146 8147 8148 8149 8150
    if (thd_table->db_stat)
      signalled|= mysql_lock_abort_for_thread(thd, thd_table);
  }
  pthread_mutex_unlock(&LOCK_open);
  return signalled;
}


/**
Konstantin Osipov's avatar
Konstantin Osipov committed
8151 8152 8153 8154 8155 8156 8157 8158 8159 8160 8161 8162 8163 8164 8165 8166 8167 8168 8169 8170 8171 8172 8173
   Remove all or some (depending on parameter) instances of TABLE and
   TABLE_SHARE from the table definition cache.

   @param  thd          Thread context
   @param  remove_type  Type of removal:
                        TDC_RT_REMOVE_ALL     - remove all TABLE instances and
                                                TABLE_SHARE instance. There
                                                should be no used TABLE objects
                                                and caller should have exclusive
                                                metadata lock on the table.
                        TDC_RT_REMOVE_NOT_OWN - remove all TABLE instances
                                                except those that belong to
                                                this thread. There should be
                                                no TABLE objects used by other
                                                threads and caller should have
                                                exclusive metadata lock on the
                                                table.
                        TDC_RT_REMOVE_UNUSED  - remove all unused TABLE
                                                instances (if there are no
                                                used instances will also
                                                remove TABLE_SHARE).
   @param  db           Name of database
   @param  table_name   Name of table
8174 8175 8176 8177 8178 8179

   @note Unlike remove_table_from_cache() it assumes that table instances
         are already not used by any (other) thread (this should be achieved
         by using meta-data locks).
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
8180 8181
void tdc_remove_table(THD *thd, enum_tdc_remove_table_type remove_type,
                      const char *db, const char *table_name)
8182 8183 8184 8185 8186 8187
{
  char key[MAX_DBKEY_LENGTH];
  uint key_length;
  TABLE *table;
  TABLE_SHARE *share;

Konstantin Osipov's avatar
Konstantin Osipov committed
8188
  safe_mutex_assert_owner(&LOCK_open);
8189

Konstantin Osipov's avatar
Konstantin Osipov committed
8190
  DBUG_ASSERT(remove_type == TDC_RT_REMOVE_UNUSED ||
8191
              thd->mdl_context.is_exclusive_lock_owner(MDL_TABLE, db, table_name));
8192

Konstantin Osipov's avatar
Konstantin Osipov committed
8193
  key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
8194 8195 8196 8197

  if ((share= (TABLE_SHARE*) my_hash_search(&table_def_cache,(uchar*) key,
                                            key_length)))
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
8198 8199 8200 8201 8202 8203 8204 8205 8206 8207 8208 8209 8210 8211 8212 8213 8214 8215 8216 8217 8218 8219 8220 8221 8222 8223 8224 8225
    if (share->ref_count)
    {
      I_P_List_iterator<TABLE, TABLE_share> it(share->free_tables);
#ifndef DBUG_OFF
      if (remove_type == TDC_RT_REMOVE_ALL)
      {
        DBUG_ASSERT(share->used_tables.is_empty());
      }
      else if (remove_type == TDC_RT_REMOVE_NOT_OWN)
      {
        I_P_List_iterator<TABLE, TABLE_share> it2(share->used_tables);
        while ((table= it2++))
          if (table->in_use != thd)
          {
            DBUG_ASSERT(0);
          }
      }
#endif
      /*
        Set share's version to zero in order to ensure that it gets
        automatically deleted once it is no longer referenced.
      */
      share->version= 0;
      while ((table= it++))
        free_cache_entry(table);
    }
    else
      (void) my_hash_delete(&table_def_cache, (uchar*) share);
8226 8227 8228 8229 8230 8231 8232 8233 8234 8235 8236 8237
  }
}


/**
   Wait until there are no old versions of tables in the table
   definition cache for the metadata locks that we try to acquire.

   @param thd      Thread context
   @param context  Metadata locking context with locks.
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
8238 8239
static bool
tdc_wait_for_old_versions(THD *thd, MDL_request_list *mdl_requests)
8240 8241 8242
{
  TABLE_SHARE *share;
  const char *old_msg;
Konstantin Osipov's avatar
Konstantin Osipov committed
8243
  MDL_request *mdl_request;
8244 8245 8246 8247 8248 8249 8250 8251 8252 8253 8254 8255

  while (!thd->killed)
  {
    /*
      Here we have situation as in mdl_wait_for_locks() we need to
      get rid of offending HANDLERs to avoid deadlock.
      TODO: We should also investigate in which situations we have
            to broadcast on COND_refresh because of this.
    */
    mysql_ha_flush(thd);
    pthread_mutex_lock(&LOCK_open);

Konstantin Osipov's avatar
Konstantin Osipov committed
8256
    MDL_request_list::Iterator it(*mdl_requests);
Konstantin Osipov's avatar
Konstantin Osipov committed
8257
    while ((mdl_request= it++))
8258
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
8259 8260
      if ((share= get_cached_table_share(mdl_request->key.db_name(),
                                         mdl_request->key.table_name())) &&
8261 8262 8263 8264
          share->version != refresh_version &&
          !share->used_tables.is_empty())
        break;
    }
Konstantin Osipov's avatar
Konstantin Osipov committed
8265
    if (!mdl_request)
8266 8267 8268 8269 8270 8271 8272 8273 8274 8275 8276 8277 8278
    {
      pthread_mutex_unlock(&LOCK_open);
      break;
    }
    old_msg= thd->enter_cond(&COND_refresh, &LOCK_open, "Waiting for table");
    pthread_cond_wait(&COND_refresh, &LOCK_open);
    /* LOCK_open mutex is unlocked by THD::exit_cond() as side-effect. */
    thd->exit_cond(old_msg);
  }
  return thd->killed;
}


8279
int setup_ftfuncs(SELECT_LEX *select_lex)
unknown's avatar
unknown committed
8280
{
8281 8282
  List_iterator<Item_func_match> li(*(select_lex->ftfunc_list)),
                                 lj(*(select_lex->ftfunc_list));
8283
  Item_func_match *ftf, *ftf2;
unknown's avatar
unknown committed
8284 8285

  while ((ftf=li++))
8286
  {
unknown's avatar
unknown committed
8287 8288
    if (ftf->fix_index())
      return 1;
8289 8290
    lj.rewind();
    while ((ftf2=lj++) != ftf)
8291
    {
8292
      if (ftf->eq(ftf2,1) && !ftf2->master)
8293 8294 8295
        ftf2->master=ftf;
    }
  }
unknown's avatar
unknown committed
8296 8297 8298

  return 0;
}
8299

8300

8301
int init_ftfuncs(THD *thd, SELECT_LEX *select_lex, bool no_order)
8302
{
8303
  if (select_lex->ftfunc_list->elements)
8304
  {
8305
    List_iterator<Item_func_match> li(*(select_lex->ftfunc_list));
unknown's avatar
unknown committed
8306 8307
    Item_func_match *ifm;
    DBUG_PRINT("info",("Performing FULLTEXT search"));
8308
    thd_proc_info(thd, "FULLTEXT initialization");
8309

unknown's avatar
unknown committed
8310 8311 8312
    while ((ifm=li++))
      ifm->init_search(no_order);
  }
8313 8314
  return 0;
}
unknown's avatar
VIEW  
unknown committed
8315 8316 8317 8318 8319 8320 8321


/*
  open new .frm format table

  SYNOPSIS
    open_new_frm()
8322
    THD		  thread handler
unknown's avatar
unknown committed
8323
    path	  path to .frm file (without extension)
unknown's avatar
VIEW  
unknown committed
8324
    alias	  alias for table
8325 8326
    db            database
    table_name    name of table
8327
    db_stat	  open flags (for example ->OPEN_KEYFILE|HA_OPEN_RNDFILE..)
unknown's avatar
VIEW  
unknown committed
8328 8329 8330 8331 8332 8333 8334
		  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
*/
8335

8336
static bool
unknown's avatar
unknown committed
8337
open_new_frm(THD *thd, TABLE_SHARE *share, const char *alias,
8338
             uint db_stat, uint prgflag,
unknown's avatar
VIEW  
unknown committed
8339 8340 8341 8342
	     uint ha_open_flags, TABLE *outparam, TABLE_LIST *table_desc,
	     MEM_ROOT *mem_root)
{
  LEX_STRING pathstr;
8343
  File_parser *parser;
unknown's avatar
unknown committed
8344
  char path[FN_REFLEN];
8345 8346
  DBUG_ENTER("open_new_frm");

unknown's avatar
unknown committed
8347 8348 8349 8350
  /* Create path with extension */
  pathstr.length= (uint) (strxmov(path, share->normalized_path.str, reg_ext,
                                  NullS)- path);
  pathstr.str=    path;
8351

8352
  if ((parser= sql_parse_prepare(&pathstr, mem_root, 1)))
unknown's avatar
VIEW  
unknown committed
8353
  {
8354
    if (is_equal(&view_type, parser->type()))
unknown's avatar
VIEW  
unknown committed
8355
    {
8356
      if (table_desc == 0 || table_desc->required_type == FRMTYPE_TABLE)
unknown's avatar
VIEW  
unknown committed
8357
      {
unknown's avatar
unknown committed
8358 8359
        my_error(ER_WRONG_OBJECT, MYF(0), share->db.str, share->table_name.str,
                 "BASE TABLE");
8360
        goto err;
unknown's avatar
VIEW  
unknown committed
8361
      }
8362 8363
      if (mysql_make_view(thd, parser, table_desc,
                          (prgflag & OPEN_VIEW_NO_PARSE)))
8364
        goto err;
unknown's avatar
VIEW  
unknown committed
8365 8366 8367 8368
    }
    else
    {
      /* only VIEWs are supported now */
8369
      my_error(ER_FRM_UNKNOWN_TYPE, MYF(0), share->path.str,  parser->type()->str);
8370
      goto err;
unknown's avatar
VIEW  
unknown committed
8371
    }
8372
    DBUG_RETURN(0);
unknown's avatar
VIEW  
unknown committed
8373
  }
unknown's avatar
unknown committed
8374
 
8375 8376
err:
  DBUG_RETURN(1);
unknown's avatar
VIEW  
unknown committed
8377
}
8378 8379 8380 8381 8382 8383


bool is_equal(const LEX_STRING *a, const LEX_STRING *b)
{
  return a->length == b->length && !strncmp(a->str, b->str, a->length);
}
unknown's avatar
unknown committed
8384 8385 8386 8387 8388 8389 8390


/*
  SYNOPSIS
    abort_and_upgrade_lock()
    lpt                           Parameter passing struct
    All parameters passed through the ALTER_PARTITION_PARAM_TYPE object
8391 8392
  RETURN VALUE
    0
unknown's avatar
unknown committed
8393 8394 8395 8396 8397 8398 8399 8400 8401 8402 8403 8404 8405
  DESCRIPTION
    Remember old lock level (for possible downgrade later on), abort all
    waiting threads and ensure that all keeping locks currently are
    completed such that we own the lock exclusively and no other interaction
    is ongoing.

    thd                           Thread object
    table                         Table object
    db                            Database name
    table_name                    Table name
    old_lock_level                Old lock level
*/

8406
int abort_and_upgrade_lock(ALTER_PARTITION_PARAM_TYPE *lpt)
unknown's avatar
unknown committed
8407
{
Konstantin Osipov's avatar
Konstantin Osipov committed
8408 8409 8410
  DBUG_ENTER("abort_and_upgrade_lock");

  if (wait_while_table_is_used(lpt->thd, lpt->table, HA_EXTRA_FORCE_REOPEN))
8411
    DBUG_RETURN(1);
8412
  DBUG_RETURN(0);
unknown's avatar
unknown committed
8413 8414 8415 8416
}


/*
8417 8418
  Tells if two (or more) tables have auto_increment columns and we want to
  lock those tables with a write lock.
8419

8420 8421 8422
  SYNOPSIS
    has_two_write_locked_tables_with_auto_increment
      tables        Table list
unknown's avatar
unknown committed
8423 8424 8425 8426 8427 8428 8429 8430

  NOTES:
    Call this function only when you have established the list of all tables
    which you'll want to update (including stored functions, triggers, views
    inside your statement).
*/

static bool
8431
has_write_table_with_auto_increment(TABLE_LIST *tables)
unknown's avatar
unknown committed
8432 8433 8434 8435
{
  for (TABLE_LIST *table= tables; table; table= table->next_global)
  {
    /* we must do preliminary checks as table->table may be NULL */
unknown's avatar
unknown committed
8436
    if (!table->placeholder() &&
unknown's avatar
unknown committed
8437 8438
        table->table->found_next_number_field &&
        (table->lock_type >= TL_WRITE_ALLOW_WRITE))
8439
      return 1;
unknown's avatar
unknown committed
8440
  }
8441

unknown's avatar
unknown committed
8442 8443
  return 0;
}
8444 8445 8446 8447 8448 8449 8450 8451 8452 8453 8454 8455 8456 8457 8458 8459 8460 8461 8462 8463 8464 8465 8466 8467 8468 8469 8470 8471 8472 8473


/*
  Open and lock system tables for read.

  SYNOPSIS
    open_system_tables_for_read()
      thd         Thread context.
      table_list  List of tables to open.
      backup      Pointer to Open_tables_state instance where
                  information about currently open tables will be
                  saved, and from which will be restored when we will
                  end work with system tables.

  NOTES
    Thanks to restrictions which we put on opening and locking of
    system tables for writing, we can open and lock them for reading
    even when we already have some other tables open and locked.  One
    must call close_system_tables() to close systems tables opened
    with this call.

  RETURN
    FALSE   Success
    TRUE    Error
*/

bool
open_system_tables_for_read(THD *thd, TABLE_LIST *table_list,
                            Open_tables_state *backup)
{
Konstantin Osipov's avatar
Konstantin Osipov committed
8474 8475 8476
  Query_tables_list query_tables_list_backup;
  LEX *lex= thd->lex;

8477 8478
  DBUG_ENTER("open_system_tables_for_read");

Konstantin Osipov's avatar
Konstantin Osipov committed
8479 8480 8481 8482 8483 8484 8485 8486
  /*
    Besides using new Open_tables_state for opening system tables,
    we also have to backup and reset/and then restore part of LEX
    which is accessed by open_tables() in order to determine if
    prelocking is needed and what tables should be added for it.
    close_system_tables() doesn't require such treatment.
  */
  lex->reset_n_backup_query_tables_list(&query_tables_list_backup);
8487 8488
  thd->reset_n_backup_open_tables_state(backup);

Konstantin Osipov's avatar
Konstantin Osipov committed
8489 8490
  if (open_and_lock_tables_derived(thd, table_list, FALSE,
                                   MYSQL_LOCK_IGNORE_FLUSH))
8491
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
8492 8493
    lex->restore_backup_query_tables_list(&query_tables_list_backup);
    goto error;
8494 8495
  }

Konstantin Osipov's avatar
Konstantin Osipov committed
8496
  for (TABLE_LIST *tables= table_list; tables; tables= tables->next_global)
8497
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
8498 8499
    DBUG_ASSERT(tables->table->s->table_category == TABLE_CATEGORY_SYSTEM);
    tables->table->use_all_columns();
8500
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
8501 8502 8503
  lex->restore_backup_query_tables_list(&query_tables_list_backup);

  DBUG_RETURN(FALSE);
8504 8505 8506 8507 8508 8509 8510 8511 8512 8513 8514 8515 8516 8517 8518 8519 8520 8521 8522 8523 8524 8525 8526 8527 8528 8529 8530 8531 8532 8533 8534 8535 8536 8537 8538 8539 8540 8541 8542 8543 8544 8545 8546 8547 8548 8549 8550 8551

error:
  close_system_tables(thd, backup);

  DBUG_RETURN(TRUE);
}


/*
  Close system tables, opened with open_system_tables_for_read().

  SYNOPSIS
    close_system_tables()
      thd     Thread context
      backup  Pointer to Open_tables_state instance which holds
              information about tables which were open before we
              decided to access system tables.
*/

void
close_system_tables(THD *thd, Open_tables_state *backup)
{
  close_thread_tables(thd);
  thd->restore_backup_open_tables_state(backup);
}


/*
  Open and lock one system table for update.

  SYNOPSIS
    open_system_table_for_update()
      thd        Thread context.
      one_table  Table to open.

  NOTES
    Table opened with this call should closed using close_thread_tables().

  RETURN
    0	Error
    #	Pointer to TABLE object of system table
*/

TABLE *
open_system_table_for_update(THD *thd, TABLE_LIST *one_table)
{
  DBUG_ENTER("open_system_table_for_update");

8552
  TABLE *table= open_ltable(thd, one_table, one_table->lock_type, 0);
8553 8554
  if (table)
  {
8555
    DBUG_ASSERT(table->s->table_category == TABLE_CATEGORY_SYSTEM);
8556 8557 8558 8559 8560
    table->use_all_columns();
  }

  DBUG_RETURN(table);
}
8561 8562 8563 8564 8565 8566 8567 8568 8569 8570 8571 8572 8573 8574 8575 8576

/**
  Open a performance schema table.
  Opening such tables is performed internally in the server
  implementation, and is a 'nested' open, since some tables
  might be already opened by the current thread.
  The thread context before this call is saved, and is restored
  when calling close_performance_schema_table().
  @param thd The current thread
  @param one_table Performance schema table to open
  @param backup [out] Temporary storage used to save the thread context
*/
TABLE *
open_performance_schema_table(THD *thd, TABLE_LIST *one_table,
                              Open_tables_state *backup)
{
8577 8578 8579 8580 8581 8582 8583
  uint flags= ( MYSQL_LOCK_IGNORE_GLOBAL_READ_LOCK |
                MYSQL_LOCK_IGNORE_GLOBAL_READ_ONLY |
                MYSQL_LOCK_IGNORE_FLUSH |
                MYSQL_LOCK_PERF_SCHEMA);
  TABLE *table;
  /* Save value that is changed in mysql_lock_tables() */
  ulonglong save_utime_after_lock= thd->utime_after_lock;
8584 8585 8586 8587
  DBUG_ENTER("open_performance_schema_table");

  thd->reset_n_backup_open_tables_state(backup);

8588
  if ((table= open_ltable(thd, one_table, one_table->lock_type, flags)))
8589 8590 8591
  {
    DBUG_ASSERT(table->s->table_category == TABLE_CATEGORY_PERFORMANCE);
    /* Make sure all columns get assigned to a default value */
8592
    table->use_all_columns();
8593
    table->no_replicate= 1;
8594 8595 8596 8597 8598
    /*
      Don't set automatic timestamps as we may want to use time of logging,
      not from query start
    */
    table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
8599
  }
8600
  else
8601 8602 8603 8604 8605 8606 8607 8608 8609
  {
    /*
      If error in mysql_lock_tables(), open_ltable doesn't close the
      table. Thread kill during mysql_lock_tables() is such error. But
      open tables cannot be accepted when restoring the open tables
      state.
    */
    if (thd->killed)
      close_thread_tables(thd);
8610
    thd->restore_backup_open_tables_state(backup);
8611
  }
8612

8613
  thd->utime_after_lock= save_utime_after_lock;
8614 8615
  DBUG_RETURN(table);
}
8616 8617 8618 8619 8620 8621 8622 8623 8624 8625 8626 8627

/**
  Close a performance schema table.
  The last table opened by open_performance_schema_table()
  is closed, then the thread context is restored.
  @param thd The current thread
  @param backup [in] the context to restore.
*/
void close_performance_schema_table(THD *thd, Open_tables_state *backup)
{
  bool found_old_table;

8628 8629 8630 8631 8632
  /*
    If open_performance_schema_table() fails,
    this function should not be called.
  */
  DBUG_ASSERT(thd->lock != NULL);
8633

8634 8635 8636 8637 8638 8639 8640 8641 8642 8643 8644 8645 8646
  /*
    Note:
    We do not create explicitly a separate transaction for the
    performance table I/O, but borrow the current transaction.
    lock + unlock will autocommit the change done in the
    performance schema table: this is the expected result.
    The current transaction should not be affected by this code.
    TODO: Note that if a transactional engine is used for log tables,
    this code will need to be revised, as a separate transaction
    might be needed.
  */
  mysql_unlock_tables(thd, thd->lock);
  thd->lock= 0;
8647 8648 8649 8650

  pthread_mutex_lock(&LOCK_open);

  found_old_table= false;
8651 8652 8653
  /*
    Note that we need to hold LOCK_open while changing the
    open_tables list. Another thread may work on it.
Konstantin Osipov's avatar
Konstantin Osipov committed
8654
    (See: notify_thread_having_shared_lock())
8655
  */
8656 8657 8658 8659 8660 8661 8662 8663
  while (thd->open_tables)
    found_old_table|= close_thread_table(thd, &thd->open_tables);

  if (found_old_table)
    broadcast_refresh();

  pthread_mutex_unlock(&LOCK_open);

Konstantin Osipov's avatar
Konstantin Osipov committed
8664
  thd->mdl_context.release_all_locks();
8665

8666 8667 8668
  thd->restore_backup_open_tables_state(backup);
}

8669 8670 8671
/**
  @} (end of group Data_Dictionary)
*/