sql_base.cc 285 KB
Newer Older
Marc Alff's avatar
Marc Alff committed
1
/* Copyright 2000-2008 MySQL AB, 2008-2009 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"
Konstantin Osipov's avatar
Konstantin Osipov committed
24
#include "sp_cache.h"
25
#include "sql_trigger.h"
Konstantin Osipov's avatar
Konstantin Osipov committed
26
#include "transaction.h"
27
#include "sql_prepare.h"
unknown's avatar
unknown committed
28 29 30
#include <m_ctype.h>
#include <my_dir.h>
#include <hash.h>
31
#include "rpl_filter.h"
32
#ifdef  __WIN__
unknown's avatar
unknown committed
33 34 35
#include <io.h>
#endif

36

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);
Konstantin Osipov's avatar
Konstantin Osipov committed
124 125
static bool tdc_wait_for_old_versions(THD *thd,
                                      MDL_request_list *mdl_requests);
unknown's avatar
unknown committed
126
static bool
127
has_write_table_with_auto_increment(TABLE_LIST *tables);
unknown's avatar
unknown committed
128

unknown's avatar
unknown committed
129

unknown's avatar
unknown committed
130
uint cached_open_tables(void)
unknown's avatar
unknown committed
131
{
132
  return table_cache_count;
unknown's avatar
unknown committed
133 134
}

unknown's avatar
unknown committed
135

unknown's avatar
unknown committed
136 137 138
#ifdef EXTRA_DEBUG
static void check_unused(void)
{
unknown's avatar
unknown committed
139
  uint count= 0, open_files= 0, idx= 0;
140 141
  TABLE *cur_link, *start_link, *entry;
  TABLE_SHARE *share;
unknown's avatar
unknown committed
142 143 144 145 146 147 148 149 150 151

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

171 172 173 174
      if (entry->in_use)
      {
        DBUG_PRINT("error",("Used table is in share's list of unused tables")); /* purecov: inspected */
      }
unknown's avatar
unknown committed
175
      count--;
unknown's avatar
unknown committed
176
      open_files++;
177 178 179 180 181 182 183 184 185 186
    }
    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
187 188 189
  }
  if (count != 0)
  {
190
    DBUG_PRINT("error",("Unused_links doesn't match open_cache: diff: %d", /* purecov: inspected */
unknown's avatar
unknown committed
191 192 193 194 195 196 197
			count)); /* purecov: inspected */
  }
}
#else
#define check_unused()
#endif

unknown's avatar
unknown committed
198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223

/*
  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
*/

224
uint create_table_def_key(THD *thd, char *key, TABLE_LIST *table_list,
unknown's avatar
unknown committed
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243
                          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)
*****************************************************************************/

244
extern "C" uchar *table_def_key(const uchar *record, size_t *length,
unknown's avatar
unknown committed
245 246 247 248
                               my_bool not_used __attribute__((unused)))
{
  TABLE_SHARE *entry=(TABLE_SHARE*) record;
  *length= entry->table_cache_key.length;
249
  return (uchar*) entry->table_cache_key.str;
unknown's avatar
unknown committed
250 251 252 253 254 255
}


static void table_def_free_entry(TABLE_SHARE *share)
{
  DBUG_ENTER("table_def_free_entry");
256
  mysql_mutex_assert_owner(&LOCK_open);
unknown's avatar
unknown committed
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273
  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
274 275 276
  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
277 278 279
}


Konstantin Osipov's avatar
Konstantin Osipov committed
280 281 282 283 284 285 286 287 288 289
/**
  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)
  {
290
    mysql_mutex_lock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
291 292 293 294 295 296 297 298 299
    /* 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;
300
    mysql_mutex_unlock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
301 302 303 304
  }
}


unknown's avatar
unknown committed
305 306 307 308 309 310
void table_def_free(void)
{
  DBUG_ENTER("table_def_free");
  if (table_def_inited)
  {
    table_def_inited= 0;
311
    /* Free table definitions. */
Konstantin Osipov's avatar
Konstantin Osipov committed
312
    my_hash_free(&table_def_cache);
unknown's avatar
unknown committed
313 314 315 316 317 318 319 320 321 322 323
  }
  DBUG_VOID_RETURN;
}


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


324 325 326 327 328 329 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
/*
  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
402 403 404 405
  /* 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));
406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
}


/**
   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
436 437 438 439
/*
  Get TABLE_SHARE for a table.

  get_table_share()
440
  thd			Thread handle
unknown's avatar
unknown committed
441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460
  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
*/

461
TABLE_SHARE *get_table_share(THD *thd, TABLE_LIST *table_list, char *key,
462 463
                             uint key_length, uint db_flags, int *error,
                             my_hash_value_type hash_value)
unknown's avatar
unknown committed
464 465 466 467 468 469
{
  TABLE_SHARE *share;
  DBUG_ENTER("get_table_share");

  *error= 0;

470 471 472 473
  /*
    To be able perform any operation on table we should own
    some kind of metadata lock on it.
  */
474 475 476 477
  DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_key::TABLE,
                                             table_list->db,
                                             table_list->table_name,
                                             MDL_SHARED));
478

unknown's avatar
unknown committed
479
  /* Read table definition from cache */
480 481
  if ((share= (TABLE_SHARE*) my_hash_search_using_hash_value(&table_def_cache,
                                                             hash_value, (uchar*) key, key_length)))
unknown's avatar
unknown committed
482 483 484 485 486 487 488
    goto found;

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

489 490 491 492 493 494 495 496 497 498 499 500 501 502 503
  /*
    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);

504
  if (my_hash_insert(&table_def_cache, (uchar*) share))
unknown's avatar
unknown committed
505 506 507 508 509 510 511
  {
    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
512
    (void) my_hash_delete(&table_def_cache, (uchar*) share);
unknown's avatar
unknown committed
513 514 515 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
    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
553
    my_hash_delete(&table_def_cache, (uchar*) oldest_unused_share);
unknown's avatar
unknown committed
554 555 556 557 558 559 560 561 562 563 564 565 566 567 568

  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,
569
                             char *key, uint key_length,
570 571 572
                             uint db_flags, int *error,
                             my_hash_value_type hash_value)

unknown's avatar
unknown committed
573 574 575 576 577
{
  TABLE_SHARE *share;
  int tmp;
  DBUG_ENTER("get_table_share_with_create");

578 579
  share= get_table_share(thd, table_list, key, key_length, db_flags, error,
                         hash_value);
580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598
  /*
    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
  thd->clear_error();                           // Clear error message
  DBUG_RETURN(get_table_share(thd, table_list, key, key_length,
649
                              db_flags, error, hash_value));
unknown's avatar
unknown committed
650 651
}

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

Marc Alff's avatar
Marc Alff committed
671
  mysql_mutex_assert_owner(&LOCK_open);
unknown's avatar
unknown committed
672

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
  TABLE_LIST table_list;
  uint key_length;
Marc Alff's avatar
Marc Alff committed
721
  mysql_mutex_assert_owner(&LOCK_open);
unknown's avatar
unknown committed
722 723 724 725

  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);
742
  mysql_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

Marc Alff's avatar
Marc Alff committed
775
  mysql_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
  }
Marc Alff's avatar
Marc Alff committed
815
  mysql_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
  mysql_mutex_assert_owner(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
893

894 895 896 897 898 899 900 901
  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;
902
      mysql_mutex_lock(&in_use->mysys_var->mutex);
903 904
      if (in_use->mysys_var->current_cond)
      {
905 906 907
        mysql_mutex_lock(in_use->mysys_var->current_mutex);
        mysql_cond_broadcast(in_use->mysys_var->current_cond);
        mysql_mutex_unlock(in_use->mysys_var->current_mutex);
908
      }
909
      mysql_mutex_unlock(&in_use->mysys_var->mutex);
910 911 912 913 914
    }
  }
}


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)
Marc Alff's avatar
Marc Alff committed
943
    mysql_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
  if (!have_lock)
981
    mysql_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
      TABLE *table= find_table_for_mdl_upgrade(thd->open_tables, table_list->db,
1005
                                               table_list->table_name, TRUE);
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
    mysql_mutex_lock(&LOCK_open);
1033 1034 1035 1036

    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

    if (found)
    {
      DBUG_PRINT("signal", ("Waiting for COND_refresh"));
1065
      mysql_cond_wait(&COND_refresh, &LOCK_open);
1066 1067 1068 1069 1070 1071
    }

    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)
1086
      tab->mdl_ticket->downgrade_exclusive_lock(MDL_SHARED_NO_READ_WRITE);
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)
Marc Alff's avatar
Marc Alff committed
1109
    mysql_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)
Marc Alff's avatar
Marc Alff committed
1142
    mysql_mutex_unlock(&LOCK_open);
1143

1144 1145
  if (if_wait_for_refresh)
  {
Marc Alff's avatar
Marc Alff committed
1146
    mysql_mutex_lock(&thd->mysys_var->mutex);
1147 1148 1149
    thd->mysys_var->current_mutex= 0;
    thd->mysys_var->current_cond= 0;
    thd->proc_info=0;
Marc Alff's avatar
Marc Alff committed
1150
    mysql_mutex_unlock(&thd->mysys_var->mutex);
1151 1152 1153 1154 1155 1156
  }

  DBUG_RETURN(result);
}


1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171
/**
  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)
1172 1173 1174
      mark_tmp_table_for_reuse(table);
  }
}
Konstantin Osipov's avatar
Konstantin Osipov committed
1175 1176


1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216
/**
  Reset a single temporary table.
  Effectively this "closes" one temporary table,
  in a session.

  @param table     Temporary table.
*/

void mark_tmp_table_for_reuse(TABLE *table)
{
  DBUG_ASSERT(table->s->tmp_table);

  table->query_id= 0;
  table->file->ha_reset();

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

  /*
    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;
1217 1218 1219
}


1220
/*
1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231
  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.
1232 1233 1234 1235 1236 1237 1238 1239 1240

  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.
1241 1242 1243 1244 1245
*/

static void mark_used_tables_as_free_for_reuse(THD *thd, TABLE *table)
{
  for (; table ; table= table->next)
1246
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
1247 1248
    DBUG_ASSERT(table->pos_in_locked_tables == NULL ||
                table->pos_in_locked_tables->table == table);
1249
    if (table->query_id == thd->query_id)
1250
    {
1251
      table->query_id= 0;
1252 1253 1254
      table->file->ha_reset();
    }
  }
1255 1256 1257
}


1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269
/**
  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;

Marc Alff's avatar
Marc Alff committed
1270
  mysql_mutex_assert_not_owner(&LOCK_open);
1271

Marc Alff's avatar
Marc Alff committed
1272
  mysql_mutex_lock(&LOCK_open);
1273 1274 1275 1276 1277 1278 1279

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

  /* Free tables to hold down open files */
1280 1281
  while (table_cache_count > table_cache_size && unused_tables)
    free_cache_entry(unused_tables);
1282 1283 1284 1285 1286 1287
  if (found_old_table)
  {
    /* Tell threads waiting for refresh that something has happened */
    broadcast_refresh();
  }

Marc Alff's avatar
Marc Alff committed
1288
  mysql_mutex_unlock(&LOCK_open);
1289 1290 1291
}


Konstantin Osipov's avatar
Konstantin Osipov committed
1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318
/**
  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);

1319
  mysql_mutex_assert_not_owner(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
1320 1321 1322
  /*
    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
1323
    @sa mysql_notify_thread_having_shared_lock()
Konstantin Osipov's avatar
Konstantin Osipov committed
1324
  */
1325
  mysql_mutex_lock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
1326 1327 1328 1329 1330 1331 1332 1333

  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))
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
1334 1335 1336 1337
      /* Inform handler that table will be dropped after close */
      if (table->db_stat)
        table->file->extra(HA_EXTRA_PREPARE_FOR_DROP);

Konstantin Osipov's avatar
Konstantin Osipov committed
1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360
      /*
        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();
1361
  mysql_mutex_unlock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
1362 1363 1364
}


1365 1366 1367
/*
  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
1368

1369 1370 1371 1372 1373 1374 1375
  SYNOPSIS
    close_thread_tables()
    thd			Thread handler

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

1377 1378 1379 1380
    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.
1381
*/
unknown's avatar
unknown committed
1382

Konstantin Osipov's avatar
Konstantin Osipov committed
1383
void close_thread_tables(THD *thd)
unknown's avatar
unknown committed
1384
{
1385
  TABLE *table;
unknown's avatar
unknown committed
1386 1387
  DBUG_ENTER("close_thread_tables");

1388 1389 1390 1391 1392 1393 1394
#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
1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408
  /* 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);
    }
  }

1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419
  /*
    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.
  */
1420
  if (thd->derived_tables)
1421
  {
1422
    TABLE *next;
1423
    /*
1424 1425
      Close all derived tables generated in queries like
      SELECT * FROM (SELECT * FROM t1)
1426 1427 1428 1429 1430 1431 1432 1433
    */
    for (table= thd->derived_tables ; table ; table= next)
    {
      next= table->next;
      free_tmp_table(thd, table);
    }
    thd->derived_tables= 0;
  }
1434

1435 1436 1437 1438
  /*
    Mark all temporary tables used by this statement as free for reuse.
  */
  mark_temp_tables_as_free_for_reuse(thd);
1439 1440 1441 1442 1443 1444 1445 1446 1447
  /*
    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))
1448
  {
Marc Alff's avatar
Marc Alff committed
1449
    thd->stmt_da->can_overwrite_status= TRUE;
Konstantin Osipov's avatar
Konstantin Osipov committed
1450
    thd->is_error() ? trans_rollback_stmt(thd) : trans_commit_stmt(thd);
Marc Alff's avatar
Marc Alff committed
1451
    thd->stmt_da->can_overwrite_status= FALSE;
1452

1453
    /*
1454 1455
      Reset transaction state, but only if we're not inside a
      sub-statement of a prelocked statement.
1456
    */
Konstantin Osipov's avatar
Konstantin Osipov committed
1457 1458
    if (thd->locked_tables_mode <= LTM_LOCK_TABLES ||
        thd->lex->requires_prelocking())
1459 1460 1461
      thd->transaction.stmt.reset();
  }

Konstantin Osipov's avatar
Konstantin Osipov committed
1462
  if (thd->locked_tables_mode)
1463
  {
1464

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

1468 1469 1470
    /*
      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
1471 1472 1473 1474 1475

      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.
1476
    */
Konstantin Osipov's avatar
Konstantin Osipov committed
1477
    if (! thd->lex->requires_prelocking())
1478 1479 1480
      DBUG_VOID_RETURN;

    /*
1481 1482 1483
      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.
1484
    */
Konstantin Osipov's avatar
Konstantin Osipov committed
1485 1486
    if (thd->locked_tables_mode == LTM_PRELOCKED_UNDER_LOCK_TABLES)
      thd->locked_tables_mode= LTM_LOCK_TABLES;
1487

Konstantin Osipov's avatar
Konstantin Osipov committed
1488
    if (thd->locked_tables_mode == LTM_LOCK_TABLES)
1489 1490
      DBUG_VOID_RETURN;

1491
    thd->leave_locked_tables_mode();
Konstantin Osipov's avatar
Konstantin Osipov committed
1492

1493
    /* Fallthrough */
1494
  }
unknown's avatar
unknown committed
1495 1496 1497

  if (thd->lock)
  {
1498 1499 1500 1501 1502 1503 1504 1505 1506
    /*
      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.
     */
1507
    (void)thd->binlog_flush_pending_rows_event(TRUE);
1508 1509
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;
unknown's avatar
unknown committed
1510
  }
1511 1512 1513
  /*
    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
1514
    (See: mysql_notify_thread_having_shared_lock())
1515 1516 1517
    Closing a MERGE child before the parent would be fatal if the
    other thread tries to abort the MERGE lock in between.
  */
1518 1519
  if (thd->open_tables)
    close_open_tables(thd);
1520

1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536
  /*
    - If inside a multi-statement transaction,
    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 commit ordering
    and guarantees serializability across multiple transactions.
    - If closing a system table, defer the release of metadata locks
    to the caller. We have no sentinel in MDL subsystem to guard
    transactional locks from system tables locks, so don't know
    which locks are which here.
    - If in autocommit mode, or outside a transactional context,
    automatically release metadata locks of the current statement.
  */
  if (! thd->in_multi_stmt_transaction() &&
      ! (thd->state_flags & Open_tables_state::BACKUPS_AVAIL))
1537 1538 1539
  {
    thd->mdl_context.release_transactional_locks();
  }
1540

unknown's avatar
unknown committed
1541 1542 1543
  DBUG_VOID_RETURN;
}

1544

1545 1546 1547 1548
/* move one table to free list */

bool close_thread_table(THD *thd, TABLE **table_ptr)
{
1549 1550
  bool found_old_table= 0;
  TABLE *table= *table_ptr;
1551
  DBUG_ENTER("close_thread_table");
1552
  DBUG_ASSERT(table->key_read == 0);
unknown's avatar
unknown committed
1553
  DBUG_ASSERT(!table->file || table->file->inited == handler::NONE);
1554
  mysql_mutex_assert_owner(&LOCK_open);
1555 1556

  *table_ptr=table->next;
1557

Konstantin Osipov's avatar
Konstantin Osipov committed
1558
  table->mdl_ticket= NULL;
1559 1560
  if (table->s->needs_reopen() ||
      thd->version != refresh_version || table->needs_reopen() ||
Konstantin Osipov's avatar
Konstantin Osipov committed
1561
      table_def_shutdown_in_progress)
1562
  {
1563
    free_cache_entry(table);
1564 1565 1566 1567
    found_old_table=1;
  }
  else
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
1568 1569 1570
    /* Avoid to have MERGE tables with attached children in unused_tables. */
    DBUG_ASSERT(table->file);
    table->file->extra(HA_EXTRA_DETACH_CHILDREN);
1571

1572
    /* Free memory and reset for next loop */
1573 1574
    free_field_buffers_larger_than(table,MAX_TDC_BLOB_SIZE);
    
1575
    table->file->ha_reset();
1576
    table_def_unuse_table(table);
1577 1578 1579 1580
  }
  DBUG_RETURN(found_old_table);
}

unknown's avatar
unknown committed
1581

1582 1583 1584 1585 1586 1587 1588
/* 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
1589 1590
/*
  Close all temporary tables created by 'CREATE TEMPORARY TABLE' for thread
1591
  creates one DROP TEMPORARY TABLE binlog event for each pseudo-thread 
unknown's avatar
unknown committed
1592
*/
unknown's avatar
unknown committed
1593 1594 1595

void close_temporary_tables(THD *thd)
{
1596
  TABLE *table;
Staale Smedseng's avatar
Staale Smedseng committed
1597
  TABLE *next= NULL;
unknown's avatar
unknown committed
1598
  TABLE *prev_table;
1599
  /* Assume thd->variables.option_bits has OPTION_QUOTE_SHOW_CREATE */
unknown's avatar
unknown committed
1600 1601
  bool was_quote_show= TRUE;

1602 1603
  if (!thd->temporary_tables)
    return;
1604

1605
  if (!mysql_bin_log.is_open() || 
1606
      (thd->is_current_stmt_binlog_format_row() && thd->variables.binlog_format == BINLOG_FORMAT_ROW))
1607
  {
1608 1609
    TABLE *tmp_next;
    for (table= thd->temporary_tables; table; table= tmp_next)
1610
    {
1611
      tmp_next= table->next;
1612 1613 1614 1615 1616 1617
      close_temporary(table, 1, 1);
    }
    thd->temporary_tables= 0;
    return;
  }

unknown's avatar
unknown committed
1618
  /* Better add "if exists", in case a RESET MASTER has been done */
1619 1620 1621 1622
  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
1623
  bool found_user_tables= FALSE;
1624

unknown's avatar
unknown committed
1625 1626
  memcpy(buf, stub, stub_len);

1627
  /*
1628 1629
    Insertion sort of temp tables by pseudo_thread_id to build ordered list
    of sublists of equal pseudo_thread_id
1630
  */
1631 1632

  for (prev_table= thd->temporary_tables, table= prev_table->next;
1633 1634
       table;
       prev_table= table, table= table->next)
unknown's avatar
unknown committed
1635
  {
1636 1637
    TABLE *prev_sorted /* same as for prev_table */, *sorted;
    if (is_user_table(table))
1638
    {
1639 1640 1641 1642
      if (!found_user_tables)
        found_user_tables= true;
      for (prev_sorted= NULL, sorted= thd->temporary_tables; sorted != table;
           prev_sorted= sorted, sorted= sorted->next)
1643
      {
1644 1645
        if (!is_user_table(sorted) ||
            tmpkeyval(thd, sorted) > tmpkeyval(thd, table))
1646
        {
1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659
          /* 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;
1660 1661 1662
        }
      }
    }
unknown's avatar
unknown committed
1663
  }
1664 1665 1666

  /* We always quote db,table names though it is slight overkill */
  if (found_user_tables &&
1667
      !(was_quote_show= test(thd->variables.option_bits & OPTION_QUOTE_SHOW_CREATE)))
1668
  {
1669
    thd->variables.option_bits |= OPTION_QUOTE_SHOW_CREATE;
unknown's avatar
unknown committed
1670
  }
1671

1672
  /* scan sorted tmps to generate sequence of DROP */
1673
  for (table= thd->temporary_tables; table; table= next)
unknown's avatar
unknown committed
1674
  {
1675
    if (is_user_table(table))
1676
    {
unknown's avatar
unknown committed
1677
      my_thread_id save_pseudo_thread_id= thd->variables.pseudo_thread_id;
1678 1679
      /* Set pseudo_thread_id to be that of the processed table */
      thd->variables.pseudo_thread_id= tmpkeyval(thd, table);
1680
      String db;
1681
      db.append(table->s->db.str);
1682 1683 1684
      /* 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
1685
      */
1686 1687
      for (s_query.length(stub_len);
           table && is_user_table(table) &&
1688
             tmpkeyval(thd, table) == thd->variables.pseudo_thread_id &&
1689 1690
             table->s->db.length == db.length() &&
             strcmp(table->s->db.str, db.ptr()) == 0;
1691 1692
           table= next)
      {
1693
        /*
1694 1695
          We are going to add ` around the table names and possible more
          due to special characters
1696 1697 1698
        */
        append_identifier(thd, &s_query, table->s->table_name.str,
                          strlen(table->s->table_name.str));
1699
        s_query.append(',');
1700 1701 1702 1703
        next= table->next;
        close_temporary(table, 1, 1);
      }
      thd->clear_error();
1704 1705 1706 1707
      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 ',' */,
1708
                            FALSE, TRUE, FALSE, 0);
1709
      qinfo.db= db.ptr();
1710
      qinfo.db_len= db.length();
1711
      thd->variables.character_set_client= cs_save;
1712 1713 1714 1715 1716
      if (mysql_bin_log.write(&qinfo))
      {
        push_warning(thd, MYSQL_ERROR::WARN_LEVEL_ERROR, MYF(0),
                     "Failed to write the DROP statement for temporary tables to binary log");
      }
unknown's avatar
unknown committed
1717
      thd->variables.pseudo_thread_id= save_pseudo_thread_id;
1718
    }
1719
    else
1720 1721 1722
    {
      next= table->next;
      close_temporary(table, 1, 1);
1723
    }
unknown's avatar
unknown committed
1724
  }
1725
  if (!was_quote_show)
1726
    thd->variables.option_bits&= ~OPTION_QUOTE_SHOW_CREATE; /* restore option */
unknown's avatar
unknown committed
1727 1728 1729
  thd->temporary_tables=0;
}

1730
/*
1731
  Find table in list.
1732 1733

  SYNOPSIS
1734
    find_table_in_list()
1735
    table		Pointer to table list
1736
    offset		Offset to which list in table structure to use
1737 1738
    db_name		Data base name
    table_name		Table name
unknown's avatar
VIEW  
unknown committed
1739

1740 1741 1742
  NOTES:
    This is called by find_table_in_local_list() and
    find_table_in_global_list().
unknown's avatar
VIEW  
unknown committed
1743 1744 1745 1746 1747 1748

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

1749
TABLE_LIST *find_table_in_list(TABLE_LIST *table,
1750
                               TABLE_LIST *TABLE_LIST::*link,
1751 1752
                               const char *db_name,
                               const char *table_name)
unknown's avatar
VIEW  
unknown committed
1753
{
1754
  for (; table; table= table->*link )
1755
  {
1756 1757 1758 1759
    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;
1760
  }
unknown's avatar
VIEW  
unknown committed
1761 1762 1763 1764
  return table;
}


1765
/*
1766
  Test that table is unique (It's only exists once in the table list)
1767 1768 1769

  SYNOPSIS
    unique_table()
1770
    thd                   thread handle
1771
    table                 table which should be checked
1772
    table_list            list of tables
1773
    check_alias           whether to check tables' aliases
1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788

  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

1789 1790 1791 1792
    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.

1793 1794
    TODO: when we will have table/view change detection we can do this check
          only once for PS/SP
1795 1796

  RETURN
unknown's avatar
unknown committed
1797 1798
    found duplicate
    0 if table is unique
1799 1800
*/

1801 1802
TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list,
                         bool check_alias)
1803
{
unknown's avatar
unknown committed
1804
  TABLE_LIST *res;
1805
  const char *d_name, *t_name, *t_alias;
unknown's avatar
unknown committed
1806 1807
  DBUG_ENTER("unique_table");
  DBUG_PRINT("enter", ("table alias: %s", table->alias));
1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819

  /*
    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)
1820
  {
1821 1822 1823 1824 1825 1826 1827 1828 1829
    /* 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);
1830
  }
1831 1832
  d_name= table->db;
  t_name= table->table_name;
1833
  t_alias= table->alias;
1834 1835

  DBUG_PRINT("info", ("real table: %s.%s", d_name, t_name));
unknown's avatar
unknown committed
1836
  for (;;)
unknown's avatar
unknown committed
1837
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853
    /*
      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
1854
          my_strcasecmp(files_charset_info, t_alias, res->alias) :
Konstantin Osipov's avatar
Konstantin Osipov committed
1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865
          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)
1866
      break;
Konstantin Osipov's avatar
Konstantin Osipov committed
1867

1868
    /*
1869
      If we found entry of this table or table of SELECT which already
1870
      processed in derived table or top select of multi-update/multi-delete
1871
      (exclude_from_table_unique_test) or prelocking placeholder.
1872
    */
Konstantin Osipov's avatar
Konstantin Osipov committed
1873
next:
1874
    table_list= res->next_global;
1875 1876
    DBUG_PRINT("info",
               ("found same copy of table or table which we should skip"));
unknown's avatar
unknown committed
1877
  }
1878
  DBUG_RETURN(res);
1879 1880 1881
}


1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916
/*
  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)
    {
1917
      /* Issue the ER_NON_INSERTABLE_TABLE error for an INSERT */
1918
      if (update->view == duplicate->view)
1919 1920 1921
        my_error(!strncmp(operation, "INSERT", 6) ?
                 ER_NON_INSERTABLE_TABLE : ER_NON_UPDATABLE_TABLE, MYF(0),
                 update->alias, operation);
1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938
      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
1939
TABLE *find_temporary_table(THD *thd, const char *db, const char *table_name)
unknown's avatar
unknown committed
1940
{
unknown's avatar
unknown committed
1941
  TABLE_LIST table_list;
unknown's avatar
unknown committed
1942

unknown's avatar
unknown committed
1943 1944 1945 1946
  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
  return find_temporary_table(thd, &table_list);
}
1947

unknown's avatar
unknown committed
1948 1949 1950 1951 1952 1953

TABLE *find_temporary_table(THD *thd, TABLE_LIST *table_list)
{
  char	key[MAX_DBKEY_LENGTH];
  uint	key_length;
  TABLE *table;
1954 1955 1956
  DBUG_ENTER("find_temporary_table");
  DBUG_PRINT("enter", ("table: '%s'.'%s'",
                       table_list->db, table_list->table_name));
unknown's avatar
unknown committed
1957 1958 1959

  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
1960
  {
unknown's avatar
unknown committed
1961 1962
    if (table->s->table_cache_key.length == key_length &&
	!memcmp(table->s->table_cache_key.str, key, key_length))
unknown's avatar
unknown committed
1963 1964 1965 1966 1967
    {
      DBUG_PRINT("info",
                 ("Found table. server_id: %u  pseudo_thread_id: %lu",
                  (uint) thd->server_id,
                  (ulong) thd->variables.pseudo_thread_id));
1968
      DBUG_RETURN(table);
unknown's avatar
unknown committed
1969
    }
unknown's avatar
unknown committed
1970
  }
unknown's avatar
unknown committed
1971
  DBUG_RETURN(0);                               // Not a temporary table
unknown's avatar
unknown committed
1972 1973
}

unknown's avatar
unknown committed
1974

1975 1976 1977 1978 1979
/**
  Drop a temporary table.

  Try to locate the table in the list of thd->temporary_tables.
  If the table is found:
1980
   - if the table is being used by some outer statement, fail.
Konstantin Osipov's avatar
Konstantin Osipov committed
1981 1982 1983 1984
   - 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.
1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995
   - 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.

1996 1997 1998 1999
  @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
2000 2001
*/

2002
int drop_temporary_table(THD *thd, TABLE_LIST *table_list)
unknown's avatar
unknown committed
2003
{
unknown's avatar
unknown committed
2004
  TABLE *table;
2005
  DBUG_ENTER("drop_temporary_table");
2006 2007
  DBUG_PRINT("tmptable", ("closing table: '%s'.'%s'",
                          table_list->db, table_list->table_name));
unknown's avatar
unknown committed
2008

unknown's avatar
unknown committed
2009
  if (!(table= find_temporary_table(thd, table_list)))
2010 2011 2012 2013 2014 2015 2016 2017 2018
    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);
  }

2019 2020 2021 2022
  /*
    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
2023
  mysql_lock_remove(thd, thd->lock, table);
unknown's avatar
unknown committed
2024
  close_temporary_table(thd, table, 1, 1);
2025
  DBUG_RETURN(0);
unknown's avatar
unknown committed
2026 2027
}

unknown's avatar
unknown committed
2028
/*
2029
  unlink from thd->temporary tables and close temporary table
unknown's avatar
unknown committed
2030 2031 2032 2033 2034
*/

void close_temporary_table(THD *thd, TABLE *table,
                           bool free_share, bool delete_table)
{
2035 2036 2037 2038 2039
  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));

2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058
  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
2059
  if (thd->slave_thread)
2060 2061 2062
  {
    /* natural invariant of temporary_tables */
    DBUG_ASSERT(slave_open_temp_tables || !thd->temporary_tables);
unknown's avatar
unknown committed
2063
    slave_open_temp_tables--;
2064
  }
unknown's avatar
unknown committed
2065
  close_temporary(table, free_share, delete_table);
2066
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079
}


/*
  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
2080
  handlerton *table_type= table->s->db_type();
unknown's avatar
unknown committed
2081
  DBUG_ENTER("close_temporary");
2082 2083
  DBUG_PRINT("tmptable", ("closing table: '%s'.'%s'",
                          table->s->db.str, table->s->table_name.str));
unknown's avatar
unknown committed
2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097

  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
2098 2099 2100 2101 2102 2103 2104
/*
  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'.
*/
2105

2106
bool rename_temporary_table(THD* thd, TABLE *table, const char *db,
unknown's avatar
unknown committed
2107 2108 2109
			    const char *table_name)
{
  char *key;
2110
  uint key_length;
2111
  TABLE_SHARE *share= table->s;
unknown's avatar
unknown committed
2112 2113 2114
  TABLE_LIST table_list;
  DBUG_ENTER("rename_temporary_table");

2115
  if (!(key=(char*) alloc_root(&share->mem_root, MAX_DBKEY_LENGTH)))
unknown's avatar
unknown committed
2116 2117 2118 2119
    DBUG_RETURN(1);				/* purecov: inspected */

  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
2120 2121
  key_length= create_table_def_key(thd, key, &table_list, 1);
  share->set_table_cache_key(key, key_length);
unknown's avatar
unknown committed
2122
  DBUG_RETURN(0);
unknown's avatar
unknown committed
2123 2124 2125
}


Konstantin Osipov's avatar
Konstantin Osipov committed
2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150
/**
   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)
{
  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));

2151 2152
  if (thd->mdl_context.upgrade_shared_lock_to_exclusive(
             table->mdl_ticket, thd->variables.lock_wait_timeout))
Konstantin Osipov's avatar
Konstantin Osipov committed
2153 2154
    DBUG_RETURN(TRUE);

2155
  mysql_mutex_lock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
2156 2157
  tdc_remove_table(thd, TDC_RT_REMOVE_NOT_OWN,
                   table->s->db.str, table->s->table_name.str);
2158
  mysql_mutex_unlock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
2159 2160
  /* extra() call must come only after all instances above are closed */
  (void) table->file->extra(function);
Konstantin Osipov's avatar
Konstantin Osipov committed
2161 2162 2163 2164 2165
  DBUG_RETURN(FALSE);
}


/**
Konstantin Osipov's avatar
Konstantin Osipov committed
2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181
  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
2182 2183 2184 2185 2186
*/

void drop_open_table(THD *thd, TABLE *table, const char *db_name,
                     const char *table_name)
{
Konstantin Osipov's avatar
Konstantin Osipov committed
2187
  DBUG_ENTER("drop_open_table");
unknown's avatar
unknown committed
2188 2189 2190 2191
  if (table->s->tmp_table)
    close_temporary_table(thd, table, 1, 1);
  else
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
2192 2193
    DBUG_ASSERT(table == thd->open_tables);

unknown's avatar
unknown committed
2194
    handlerton *table_type= table->s->db_type();
Konstantin Osipov's avatar
Konstantin Osipov committed
2195 2196 2197
    /* Ensure the table is removed from the cache. */
    table->s->version= 0;

Marc Alff's avatar
Marc Alff committed
2198
    mysql_mutex_lock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
2199
    table->file->extra(HA_EXTRA_PREPARE_FOR_DROP);
Konstantin Osipov's avatar
Konstantin Osipov committed
2200
    close_thread_table(thd, &thd->open_tables);
unknown's avatar
unknown committed
2201
    quick_rm_table(table_type, db_name, table_name, 0);
Marc Alff's avatar
Marc Alff committed
2202
    mysql_mutex_unlock(&LOCK_open);
unknown's avatar
unknown committed
2203
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
2204
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2205 2206 2207
}


2208
/*
unknown's avatar
unknown committed
2209 2210 2211 2212 2213 2214 2215 2216
   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
2217 2218
*/

Marc Alff's avatar
Marc Alff committed
2219
void wait_for_condition(THD *thd, mysql_mutex_t *mutex, mysql_cond_t *cond)
unknown's avatar
unknown committed
2220 2221 2222
{
  /* Wait until the current table is up to date */
  const char *proc_info;
unknown's avatar
unknown committed
2223 2224
  thd->mysys_var->current_mutex= mutex;
  thd->mysys_var->current_cond= cond;
unknown's avatar
unknown committed
2225
  proc_info=thd->proc_info;
2226
  thd_proc_info(thd, "Waiting for table");
2227
  DBUG_ENTER("wait_for_condition");
unknown's avatar
unknown committed
2228
  if (!thd->killed)
Marc Alff's avatar
Marc Alff committed
2229
    mysql_cond_wait(cond, mutex);
unknown's avatar
unknown committed
2230

unknown's avatar
unknown committed
2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241
  /*
    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
  */
    
Marc Alff's avatar
Marc Alff committed
2242 2243
  mysql_mutex_unlock(mutex);
  mysql_mutex_lock(&thd->mysys_var->mutex);
unknown's avatar
unknown committed
2244 2245
  thd->mysys_var->current_mutex= 0;
  thd->mysys_var->current_cond= 0;
2246
  thd_proc_info(thd, proc_info);
Marc Alff's avatar
Marc Alff committed
2247
  mysql_mutex_unlock(&thd->mysys_var->mutex);
unknown's avatar
unknown committed
2248
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2249 2250
}

2251

unknown's avatar
unknown committed
2252
/**
unknown's avatar
unknown committed
2253 2254
    Check that table exists in table definition cache, on disk
    or in some storage engine.
unknown's avatar
unknown committed
2255

unknown's avatar
unknown committed
2256 2257 2258
    @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
2259 2260 2261
                         exists and to FALSE otherwise.

    @note This function assumes that caller owns LOCK_open mutex.
Konstantin Osipov's avatar
Konstantin Osipov committed
2262 2263
          It also assumes that the fact that there are no exclusive
          metadata locks on the table was checked beforehand.
unknown's avatar
unknown committed
2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274

    @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)
{
2275
  char path[FN_REFLEN + 1];
unknown's avatar
unknown committed
2276 2277 2278
  int rc;
  DBUG_ENTER("check_if_table_exists");

2279
  mysql_mutex_assert_owner(&LOCK_open);
unknown's avatar
unknown committed
2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315

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


2316 2317 2318 2319 2320 2321 2322
/**
   @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)
{
2323
  mysql_mutex_lock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
2324
  release_table_share((TABLE_SHARE*) share);
2325
  broadcast_refresh();
2326
  mysql_mutex_unlock(&LOCK_open);
2327 2328 2329
}


Konstantin Osipov's avatar
Konstantin Osipov committed
2330 2331 2332
/**
   A helper function that acquires an MDL lock for a table
   being opened.
Konstantin Osipov's avatar
Konstantin Osipov committed
2333 2334 2335 2336
*/

static bool
open_table_get_mdl_lock(THD *thd, TABLE_LIST *table_list,
Konstantin Osipov's avatar
Konstantin Osipov committed
2337
                        MDL_request *mdl_request,
Konstantin Osipov's avatar
Konstantin Osipov committed
2338 2339
                        Open_table_context *ot_ctx,
                        uint flags)
Konstantin Osipov's avatar
Konstantin Osipov committed
2340
{
2341
  if (table_list->lock_strategy)
Konstantin Osipov's avatar
Konstantin Osipov committed
2342
  {
2343
    MDL_request_list mdl_requests;
2344
    MDL_request *global_request;
Konstantin Osipov's avatar
Konstantin Osipov committed
2345 2346 2347 2348 2349 2350 2351 2352 2353
    /*
      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.
    */
2354

Konstantin Osipov's avatar
Konstantin Osipov committed
2355
    mdl_request->set_type(MDL_EXCLUSIVE);
2356
    DBUG_ASSERT(! thd->mdl_context.has_locks() ||
2357
                thd->handler_tables_hash.records ||
2358
                thd->global_read_lock.is_acquired());
2359 2360 2361

    if (!(global_request= ot_ctx->get_global_mdl_request(thd)))
      return 1;
Konstantin Osipov's avatar
Konstantin Osipov committed
2362

2363 2364
    mdl_requests.push_front(mdl_request);
    mdl_requests.push_front(global_request);
2365

2366 2367
    if (thd->mdl_context.acquire_locks(&mdl_requests,
                                       thd->variables.lock_wait_timeout))
Konstantin Osipov's avatar
Konstantin Osipov committed
2368 2369 2370 2371
      return 1;
  }
  else
  {
2372
    if (flags & MYSQL_OPEN_FORCE_SHARED_MDL)
2373
    {
2374 2375 2376 2377 2378 2379 2380 2381 2382
      /*
        While executing PREPARE for prepared statement we override
        type-of-operation aware type of shared metadata lock which
        was set in the parser with simple shared metadata lock.
        This is necessary to allow concurrent execution of PREPARE
        and LOCK TABLES WRITE statement which locks one of the tables
        used in the statement being prepared.
      */
      DBUG_ASSERT(!(flags & (MYSQL_OPEN_TAKE_UPGRADABLE_MDL |
2383
                             MYSQL_OPEN_FORCE_SHARED_HIGH_PRIO_MDL)));
2384

2385 2386
      mdl_request->set_type(MDL_SHARED);
    }
2387
    else if (flags & MYSQL_OPEN_FORCE_SHARED_HIGH_PRIO_MDL)
2388 2389 2390
    {
      DBUG_ASSERT(!(flags & MYSQL_OPEN_TAKE_UPGRADABLE_MDL));
      mdl_request->set_type(MDL_SHARED_HIGH_PRIO);
2391 2392 2393 2394
    }

    ot_ctx->add_request(mdl_request);

2395
    if (thd->mdl_context.try_acquire_lock(mdl_request))
Konstantin Osipov's avatar
Konstantin Osipov committed
2396
      return 1;
2397

Konstantin Osipov's avatar
Konstantin Osipov committed
2398
    if (mdl_request->ticket == NULL)
Konstantin Osipov's avatar
Konstantin Osipov committed
2399
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
2400 2401 2402
      if (flags & MYSQL_OPEN_FAIL_ON_MDL_CONFLICT)
        my_error(ER_WARN_I_S_SKIPPED_TABLE, MYF(0), table_list->db, table_list->table_name);
      else
2403
        ot_ctx->request_backoff_action(Open_table_context::OT_WAIT_MDL_LOCK);
Konstantin Osipov's avatar
Konstantin Osipov committed
2404 2405 2406 2407 2408 2409 2410
      return 1;
    }
  }
  return 0;
}


2411 2412 2413 2414 2415
/*
  Open a table.

  SYNOPSIS
    open_table()
2416 2417
    thd                 Thread context.
    table_list          Open first table in list.
2418 2419 2420 2421
    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.
2422 2423
    flags               Bitmap of flags to modify how open works:
                          MYSQL_LOCK_IGNORE_FLUSH - Open table even if
2424 2425 2426
                          someone has done a flush or there is a pending
                          exclusive metadata lock requests against it
                          (i.e. request high priority metadata lock).
2427
                          No version number checking is done.
unknown's avatar
unknown committed
2428 2429
                          MYSQL_OPEN_TEMPORARY_ONLY - Open only temporary
                          table not the base table or view.
Konstantin Osipov's avatar
Konstantin Osipov committed
2430 2431 2432
                          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.
2433 2434 2435 2436

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

2437 2438 2439 2440 2441 2442 2443 2444 2445 2446
    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
2447

2448
  RETURN
Konstantin Osipov's avatar
Konstantin Osipov committed
2449 2450 2451 2452 2453
    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).
2454
*/
unknown's avatar
unknown committed
2455 2456


Konstantin Osipov's avatar
Konstantin Osipov committed
2457
bool open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
Konstantin Osipov's avatar
Konstantin Osipov committed
2458
                Open_table_context *ot_ctx, uint flags)
unknown's avatar
unknown committed
2459 2460 2461 2462
{
  reg1	TABLE *table;
  char	key[MAX_DBKEY_LENGTH];
  uint	key_length;
unknown's avatar
VIEW  
unknown committed
2463
  char	*alias= table_list->alias;
Konstantin Osipov's avatar
Konstantin Osipov committed
2464 2465
  MDL_request *mdl_request;
  MDL_ticket *mdl_ticket;
2466 2467
  int error;
  TABLE_SHARE *share;
2468
  my_hash_value_type hash_value;
unknown's avatar
unknown committed
2469 2470
  DBUG_ENTER("open_table");

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

unknown's avatar
unknown committed
2475
  if (thd->killed)
Konstantin Osipov's avatar
Konstantin Osipov committed
2476
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
2477 2478 2479

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

2481 2482 2483 2484 2485 2486 2487
  /*
    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.
  */
2488 2489
  if (table_list->open_type != OT_BASE_ONLY &&
      ! (flags & MYSQL_OPEN_SKIP_TEMPORARY))
unknown's avatar
unknown committed
2490
  {
unknown's avatar
VIEW  
unknown committed
2491
    for (table= thd->temporary_tables; table ; table=table->next)
unknown's avatar
unknown committed
2492
    {
unknown's avatar
unknown committed
2493 2494 2495
      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
2496
		  key_length + TMP_TABLE_KEY_EXTRA))
unknown's avatar
unknown committed
2497
      {
2498 2499 2500 2501 2502 2503
        /*
          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.
        */
2504
	if (table->query_id)
unknown's avatar
VIEW  
unknown committed
2505
	{
unknown's avatar
unknown committed
2506 2507 2508 2509
          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));
2510
	  my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
Konstantin Osipov's avatar
Konstantin Osipov committed
2511
	  DBUG_RETURN(TRUE);
unknown's avatar
VIEW  
unknown committed
2512 2513
	}
	table->query_id= thd->query_id;
unknown's avatar
unknown committed
2514
	thd->thread_specific_used= TRUE;
unknown's avatar
unknown committed
2515 2516
        DBUG_PRINT("info",("Using temporary table"));
        goto reset;
unknown's avatar
unknown committed
2517 2518 2519 2520
      }
    }
  }

2521 2522
  if (table_list->open_type == OT_TEMPORARY_ONLY ||
      (flags & MYSQL_OPEN_TEMPORARY_ONLY))
unknown's avatar
unknown committed
2523
  {
2524 2525 2526 2527 2528 2529 2530
    if (table_list->open_strategy == TABLE_LIST::OPEN_NORMAL)
    {
      my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->db, table_list->table_name);
      DBUG_RETURN(TRUE);
    }
    else
      DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
2531 2532
  }

2533 2534 2535 2536 2537 2538 2539
  /*
    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
2540 2541
  if (thd->locked_tables_mode &&
      ! (flags & MYSQL_OPEN_GET_NEW_TABLE))
unknown's avatar
unknown committed
2542
  {						// Using table locks
2543
    TABLE *best_table= 0;
unknown's avatar
unknown committed
2544
    int best_distance= INT_MIN;
unknown's avatar
unknown committed
2545 2546
    for (table=thd->open_tables; table ; table=table->next)
    {
unknown's avatar
unknown committed
2547 2548
      if (table->s->table_cache_key.length == key_length &&
	  !memcmp(table->s->table_cache_key.str, key, key_length))
unknown's avatar
unknown committed
2549
      {
2550 2551
        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
2552
            (thd->locked_tables_mode == LTM_LOCK_TABLES ||
Konstantin Osipov's avatar
Konstantin Osipov committed
2553
             table->query_id == 0))
2554 2555 2556
        {
          int distance= ((int) table->reginfo.lock_type -
                         (int) table_list->lock_type);
2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567

          /*
            If we are performing DDL operation we also should ensure
            that we will find TABLE instance with upgradable metadata
            lock,
          */
          if ((flags & MYSQL_OPEN_TAKE_UPGRADABLE_MDL) &&
              table_list->lock_type >= TL_WRITE_ALLOW_WRITE &&
              ! table->mdl_ticket->is_upgradable_or_exclusive())
            distance= -1;

2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579
          /*
            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
          */
2580 2581
          if ((best_distance < 0 && distance > best_distance) ||
              (distance >= 0 && distance < best_distance))
2582 2583 2584
          {
            best_distance= distance;
            best_table= table;
2585
            if (best_distance == 0)
2586 2587
            {
              /*
2588 2589 2590 2591
                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().
2592 2593 2594 2595
              */
              break;
            }
          }
2596
        }
unknown's avatar
unknown committed
2597
      }
unknown's avatar
unknown committed
2598
    }
2599 2600
    if (best_table)
    {
2601 2602 2603 2604 2605 2606 2607
      if ((flags & MYSQL_OPEN_TAKE_UPGRADABLE_MDL) &&
          table_list->lock_type >= TL_WRITE_ALLOW_WRITE &&
          ! best_table->mdl_ticket->is_upgradable_or_exclusive())
      {
        my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0), alias);
        DBUG_RETURN(TRUE);
      }
2608 2609 2610 2611 2612
      table= best_table;
      table->query_id= thd->query_id;
      DBUG_PRINT("info",("Using locked table"));
      goto reset;
    }
unknown's avatar
unknown committed
2613
    /*
2614
      Is this table a view and not a base table?
unknown's avatar
unknown committed
2615 2616
      (it is work around to allow to open view with locked tables,
      real fix will be made after definition cache will be made)
2617 2618 2619 2620

      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
2621
    */
2622 2623 2624 2625
    if (thd->mdl_context.is_lock_owner(MDL_key::TABLE,
                                       table_list->db,
                                       table_list->table_name,
                                       MDL_SHARED))
unknown's avatar
unknown committed
2626
    {
2627
      char path[FN_REFLEN + 1];
unknown's avatar
unknown committed
2628
      enum legacy_db_type not_used;
2629
      build_table_filename(path, sizeof(path) - 1,
2630
                           table_list->db, table_list->table_name, reg_ext, 0);
Konstantin Osipov's avatar
Konstantin Osipov committed
2631 2632 2633 2634 2635 2636 2637
      /*
        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).
      */
2638
      if (mysql_frm_type(thd, path, &not_used) == FRMTYPE_VIEW)
unknown's avatar
unknown committed
2639
      {
2640 2641
        if (!tdc_open_view(thd, table_list, alias, key, key_length,
                           mem_root, 0))
unknown's avatar
unknown committed
2642
        {
2643
          DBUG_ASSERT(table_list->view != 0);
Konstantin Osipov's avatar
Konstantin Osipov committed
2644
          DBUG_RETURN(FALSE); // VIEW
unknown's avatar
unknown committed
2645 2646 2647
        }
      }
    }
2648 2649 2650 2651 2652 2653 2654
    /*
      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
2655
    if (thd->locked_tables_mode == LTM_PRELOCKED)
Konstantin Osipov's avatar
Konstantin Osipov committed
2656 2657 2658 2659 2660
      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
2661

Konstantin Osipov's avatar
Konstantin Osipov committed
2662 2663 2664 2665
  /*
    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
2666

Konstantin Osipov's avatar
Konstantin Osipov committed
2667
  mdl_request= &table_list->mdl_request;
Konstantin Osipov's avatar
Konstantin Osipov committed
2668 2669
  if (! (flags & MYSQL_OPEN_HAS_MDL_LOCK))
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
2670 2671 2672
    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
2673
      DBUG_RETURN(TRUE);
Konstantin Osipov's avatar
Konstantin Osipov committed
2674 2675
    }
    DEBUG_SYNC(thd, "after_open_table_mdl_shared");
2676 2677
  }

Konstantin Osipov's avatar
Konstantin Osipov committed
2678 2679 2680 2681 2682
  /*
    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
2683
  mdl_ticket= mdl_request->ticket;
Konstantin Osipov's avatar
Konstantin Osipov committed
2684

2685
  hash_value= my_calc_hash(&table_def_cache, (uchar*) key, key_length);
Marc Alff's avatar
Marc Alff committed
2686
  mysql_mutex_lock(&LOCK_open);
unknown's avatar
unknown committed
2687

2688 2689 2690 2691 2692 2693 2694 2695
  /*
    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
2696 2697
  if (!thd->open_tables)
    thd->version=refresh_version;
2698
  else if ((thd->version != refresh_version) &&
2699
           ! (flags & MYSQL_LOCK_IGNORE_FLUSH))
unknown's avatar
unknown committed
2700 2701
  {
    /* Someone did a refresh while thread was opening tables */
Marc Alff's avatar
Marc Alff committed
2702
    mysql_mutex_unlock(&LOCK_open);
2703
    (void) ot_ctx->request_backoff_action(Open_table_context::OT_WAIT_TDC);
Konstantin Osipov's avatar
Konstantin Osipov committed
2704
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
2705 2706
  }

2707
  if (table_list->open_strategy == TABLE_LIST::OPEN_IF_EXISTS)
unknown's avatar
unknown committed
2708
  {
2709
    bool exists;
2710

2711 2712
    if (check_if_table_exists(thd, table_list, &exists))
      goto err_unlock2;
2713

2714 2715
    if (!exists)
    {
2716
      mysql_mutex_unlock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
2717
      DBUG_RETURN(FALSE);
2718 2719 2720
    }
    /* Table exists. Let us try to open it. */
  }
2721
  else if (table_list->open_strategy == TABLE_LIST::OPEN_STUB)
2722
  {
2723
    mysql_mutex_unlock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
2724
    DBUG_RETURN(FALSE);
2725
  }
unknown's avatar
unknown committed
2726

Konstantin Osipov's avatar
Konstantin Osipov committed
2727
#ifdef DISABLED_UNTIL_GRL_IS_MADE_PART_OF_MDL
Konstantin Osipov's avatar
Konstantin Osipov committed
2728
  if (!(share= (TABLE_SHARE *) mdl_ticket->get_cached_object()))
Konstantin Osipov's avatar
Konstantin Osipov committed
2729
#endif
2730 2731 2732
  {
    if (!(share= get_table_share_with_create(thd, table_list, key,
                                             key_length, OPEN_VIEW,
2733 2734
                                             &error,
                                             hash_value)))
2735 2736 2737 2738
      goto err_unlock2;

    if (share->is_view)
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
2739 2740 2741 2742 2743 2744 2745 2746 2747 2748
      /*
        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
2749
      /*
2750 2751
        This table is a view. Validate its metadata version: in particular,
        that it was a view when the statement was prepared.
2752
      */
2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767
      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
2768
      release_table_share(share);
2769 2770

      if (flags & OPEN_VIEW_NO_PARSE)
2771
      {
2772 2773 2774 2775 2776
        /*
          VIEW not really opened, only frm were read.
          Set 1 as a flag here
        */
        table_list->view= (LEX*)1;
2777
      }
unknown's avatar
unknown committed
2778
      else
unknown's avatar
VIEW  
unknown committed
2779
      {
2780
        DBUG_ASSERT(table_list->view);
unknown's avatar
VIEW  
unknown committed
2781
      }
2782

2783
      mysql_mutex_unlock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
2784
      DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
2785
    }
Konstantin Osipov's avatar
Konstantin Osipov committed
2786 2787 2788 2789 2790 2791
    /*
      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.
    */
2792 2793 2794 2795

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

Konstantin Osipov's avatar
Konstantin Osipov committed
2796
#ifdef DISABLED_UNTIL_GRL_IS_MADE_PART_OF_MDL
2797 2798 2799 2800 2801
    /*
      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
2802
    mdl_ticket->set_cached_object(share, table_share_release_hook);
Konstantin Osipov's avatar
Konstantin Osipov committed
2803
#endif
unknown's avatar
unknown committed
2804
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
2805
#ifdef DISABLED_UNTIL_GRL_IS_MADE_PART_OF_MDL
2806
  else
unknown's avatar
unknown committed
2807
  {
2808 2809 2810 2811 2812 2813 2814
    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
2815
    }
2816 2817 2818 2819 2820 2821 2822 2823 2824 2825
    /* 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);
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
2826
#endif
2827 2828 2829 2830 2831

  if (share->version != refresh_version)
  {
    if (!(flags & MYSQL_LOCK_IGNORE_FLUSH))
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
2832 2833 2834 2835 2836 2837 2838 2839 2840 2841
       /*
         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
2842
      release_table_share(share);
2843
      mysql_mutex_unlock(&LOCK_open);
2844
      (void) ot_ctx->request_backoff_action(Open_table_context::OT_WAIT_TDC);
Konstantin Osipov's avatar
Konstantin Osipov committed
2845
      DBUG_RETURN(TRUE);
2846 2847 2848 2849 2850 2851 2852
    }
    /* Force close at once after usage */
    thd->version= share->version;
  }

  if (!share->free_tables.is_empty())
  {
2853
    table= share->free_tables.front();
2854 2855
    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
2856
    release_table_share(share);
unknown's avatar
unknown committed
2857 2858 2859
  }
  else
  {
2860 2861 2862
    /* 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
2863

2864 2865 2866
    /* make a new table */
    if (!(table=(TABLE*) my_malloc(sizeof(*table),MYF(MY_WME))))
      goto err_unlock;
unknown's avatar
unknown committed
2867

2868 2869 2870 2871 2872 2873 2874 2875
    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
2876

2877 2878 2879 2880
    if (error)
    {
      my_free(table, MYF(0));

Konstantin Osipov's avatar
Konstantin Osipov committed
2881
      if (error == 7)
unknown's avatar
unknown committed
2882
      {
Konstantin Osipov's avatar
Konstantin Osipov committed
2883
        share->version= 0;
Konstantin Osipov's avatar
Konstantin Osipov committed
2884
        (void) ot_ctx->request_backoff_action(Open_table_context::OT_DISCOVER);
Konstantin Osipov's avatar
Konstantin Osipov committed
2885 2886 2887 2888
      }
      else if (share->crashed)
      {
        share->version= 0;
Konstantin Osipov's avatar
Konstantin Osipov committed
2889
        (void) ot_ctx->request_backoff_action(Open_table_context::OT_REPAIR);
unknown's avatar
unknown committed
2890
      }
unknown's avatar
unknown committed
2891

2892
      goto err_unlock;
2893
    }
unknown's avatar
unknown committed
2894

2895
    if (open_table_entry_fini(thd, share, table))
unknown's avatar
unknown committed
2896
    {
2897
      closefrm(table, 0);
2898
      my_free((uchar*)table, MYF(0));
2899
      goto err_unlock;
unknown's avatar
unknown committed
2900
    }
2901

2902 2903
    /* Add table to the share's used tables list. */
    table_def_add_used_table(thd, table);
unknown's avatar
unknown committed
2904 2905
  }

Marc Alff's avatar
Marc Alff committed
2906
  mysql_mutex_unlock(&LOCK_open);
2907

Konstantin Osipov's avatar
Konstantin Osipov committed
2908 2909 2910
  /*
    In CREATE TABLE .. If NOT EXISTS .. SELECT we have found that
    table exists now we should downgrade our exclusive metadata
2911
    lock on this table to SW metadata lock.
Konstantin Osipov's avatar
Konstantin Osipov committed
2912
  */
2913 2914
  if (table_list->lock_strategy == TABLE_LIST::EXCLUSIVE_DOWNGRADABLE_MDL &&
      !(flags & MYSQL_OPEN_HAS_MDL_LOCK))
2915
    mdl_ticket->downgrade_exclusive_lock(MDL_SHARED_WRITE);
2916

Konstantin Osipov's avatar
Konstantin Osipov committed
2917
  table->mdl_ticket= mdl_ticket;
Konstantin Osipov's avatar
Konstantin Osipov committed
2918 2919 2920 2921

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

unknown's avatar
unknown committed
2922 2923 2924
  table->reginfo.lock_type=TL_READ;		/* Assume read */

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

unknown's avatar
unknown committed
2927 2928
  if (thd->lex->need_correct_ident())
    table->alias_name_used= my_strcasecmp(table_alias_charset,
unknown's avatar
unknown committed
2929
                                          table->s->table_name.str, alias);
unknown's avatar
unknown committed
2930
  /* Fix alias if table name changes */
2931
  if (strcmp(table->alias, alias))
unknown's avatar
unknown committed
2932
  {
unknown's avatar
unknown committed
2933
    uint length=(uint) strlen(alias)+1;
2934 2935 2936
    table->alias= (char*) my_realloc((char*) table->alias, length,
                                     MYF(MY_WME));
    memcpy((char*) table->alias, alias, length);
unknown's avatar
unknown committed
2937 2938 2939 2940
  }
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
2941 2942
  table->null_row= table->maybe_null= 0;
  table->force_index= table->force_index_order= table->force_index_group= 0;
unknown's avatar
unknown committed
2943
  table->status=STATUS_NO_RECORD;
2944
  table->insert_values= 0;
unknown's avatar
unknown committed
2945 2946
  table->fulltext_searched= 0;
  table->file->ft_handler= 0;
2947
  table->reginfo.impossible_range= 0;
2948 2949 2950
  /* 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
2951
  if (table->timestamp_field)
2952
    table->timestamp_field_type= table->timestamp_field->get_auto_set_type();
unknown's avatar
unknown committed
2953
  table->pos_in_table_list= table_list;
unknown's avatar
VIEW  
unknown committed
2954
  table_list->updatable= 1; // It is not derived table nor non-updatable VIEW
2955
  table->clear_column_bitmaps();
Konstantin Osipov's avatar
Konstantin Osipov committed
2956
  table_list->table= table;
unknown's avatar
unknown committed
2957
  DBUG_ASSERT(table->key_read == 0);
Konstantin Osipov's avatar
Konstantin Osipov committed
2958 2959 2960
  /* 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
2961
  DBUG_RETURN(FALSE);
2962 2963

err_unlock:
Konstantin Osipov's avatar
Konstantin Osipov committed
2964
  release_table_share(share);
2965
err_unlock2:
2966
  mysql_mutex_unlock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
2967

Konstantin Osipov's avatar
Konstantin Osipov committed
2968
  DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
2969 2970 2971
}


2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982
/**
   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
2983 2984 2985 2986
{
  char	key[MAX_DBKEY_LENGTH];
  uint key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;

2987
  for (TABLE *table= list; table ; table=table->next)
unknown's avatar
unknown committed
2988
  {
unknown's avatar
unknown committed
2989 2990
    if (table->s->table_cache_key.length == key_length &&
	!memcmp(table->s->table_cache_key.str, key, key_length))
unknown's avatar
unknown committed
2991 2992 2993 2994 2995 2996
      return table;
  }
  return(0);
}


2997
/**
2998 2999 3000
   Find instance of TABLE with upgradable or exclusive metadata
   lock from the list of open tables, emit error if no such table
   found.
3001

3002
   @param list       List of TABLE objects to be searched
3003 3004
   @param db         Database name.
   @param table_name Name of table.
3005 3006
   @param no_error   Don't emit error if no suitable TABLE
                     instance were found.
3007

3008 3009 3010
   @return Pointer to TABLE instance with MDL_SHARED_NO_WRITE,
           MDL_SHARED_NO_READ_WRITE, or MDL_EXCLUSIVE metadata
           lock, NULL otherwise.
3011 3012
*/

3013 3014 3015
TABLE *find_table_for_mdl_upgrade(TABLE *list, const char *db,
                                  const char *table_name,
                                  bool no_error)
3016 3017 3018 3019 3020
{
  TABLE *tab= find_locked_table(list, db, table_name);

  if (!tab)
  {
3021 3022 3023
    if (!no_error)
      my_error(ER_TABLE_NOT_LOCKED, MYF(0), table_name);
    return NULL;
3024 3025 3026
  }
  else
  {
3027 3028
    while (tab->mdl_ticket != NULL &&
           !tab->mdl_ticket->is_upgradable_or_exclusive() &&
3029 3030 3031 3032
           (tab= find_locked_table(tab->next, db, table_name)))
      continue;
    if (!tab)
    {
3033 3034
      if (!no_error)
        my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0), table_name);
3035 3036 3037 3038 3039 3040 3041
      return 0;
    }
  }
  return tab;
}


Konstantin Osipov's avatar
Konstantin Osipov committed
3042 3043 3044
/***********************************************************************
  class Locked_tables_list implementation. Declared in sql_class.h
************************************************************************/
unknown's avatar
unknown committed
3045

Konstantin Osipov's avatar
Konstantin Osipov committed
3046 3047
/**
  Enter LTM_LOCK_TABLES mode.
unknown's avatar
unknown committed
3048

Konstantin Osipov's avatar
Konstantin Osipov committed
3049 3050 3051
  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
3052

Konstantin Osipov's avatar
Konstantin Osipov committed
3053 3054 3055
  @param  thd  thread handle

  @return TRUE if out of memory.
unknown's avatar
unknown committed
3056 3057
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
3058 3059
bool
Locked_tables_list::init_locked_tables(THD *thd)
unknown's avatar
unknown committed
3060
{
Konstantin Osipov's avatar
Konstantin Osipov committed
3061 3062
  DBUG_ASSERT(thd->locked_tables_mode == LTM_NONE);
  DBUG_ASSERT(m_locked_tables == NULL);
Konstantin Osipov's avatar
Konstantin Osipov committed
3063 3064
  DBUG_ASSERT(m_reopen_array == NULL);
  DBUG_ASSERT(m_locked_tables_count == 0);
Konstantin Osipov's avatar
Konstantin Osipov committed
3065

Konstantin Osipov's avatar
Konstantin Osipov committed
3066 3067
  for (TABLE *table= thd->open_tables; table;
       table= table->next, m_locked_tables_count++)
Konstantin Osipov's avatar
Konstantin Osipov committed
3068 3069 3070
  {
    TABLE_LIST *src_table_list= table->pos_in_table_list;
    char *db, *table_name, *alias;
Konstantin Osipov's avatar
Konstantin Osipov committed
3071 3072 3073
    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
3074 3075 3076 3077
    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
3078 3079 3080
                           &db, db_len + 1,
                           &table_name, table_name_len + 1,
                           &alias, alias_len + 1,
Konstantin Osipov's avatar
Konstantin Osipov committed
3081
                           NullS))
Konstantin Osipov's avatar
Konstantin Osipov committed
3082 3083 3084 3085 3086
    {
      unlock_locked_tables(0);
      return TRUE;
    }

Konstantin Osipov's avatar
Konstantin Osipov committed
3087 3088 3089
    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
3090 3091 3092 3093 3094 3095 3096
    /**
      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
3097 3098
    dst_table_list->init_one_table(db, db_len, table_name, table_name_len,
                                   alias,
Konstantin Osipov's avatar
Konstantin Osipov committed
3099 3100
                                   src_table_list->table->reginfo.lock_type);
    dst_table_list->table= table;
Konstantin Osipov's avatar
Konstantin Osipov committed
3101 3102
    dst_table_list->mdl_request.ticket= src_table_list->mdl_request.ticket;

Konstantin Osipov's avatar
Konstantin Osipov committed
3103 3104 3105 3106 3107
    /* 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
3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123
  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;
    }
  }
3124
  thd->enter_locked_tables_mode(LTM_LOCK_TABLES);
Konstantin Osipov's avatar
Konstantin Osipov committed
3125

Konstantin Osipov's avatar
Konstantin Osipov committed
3126 3127
  return FALSE;
}
unknown's avatar
unknown committed
3128

Konstantin Osipov's avatar
Konstantin Osipov committed
3129 3130
/**
  Leave LTM_LOCK_TABLES mode if it's been entered.
unknown's avatar
unknown committed
3131

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

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

Konstantin Osipov's avatar
Konstantin Osipov committed
3137 3138
void
Locked_tables_list::unlock_locked_tables(THD *thd)
unknown's avatar
unknown committed
3139

Konstantin Osipov's avatar
Konstantin Osipov committed
3140 3141
{
  if (thd)
3142
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155
    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)
3156
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
3157 3158 3159 3160 3161
      /*
        Clear the position in the list, the TABLE object will be
        returned to the table cache.
      */
      table_list->table->pos_in_locked_tables= NULL;
3162
    }
3163
    thd->leave_locked_tables_mode();
Konstantin Osipov's avatar
Konstantin Osipov committed
3164 3165

    close_thread_tables(thd);
3166
  }
3167
  /*
Konstantin Osipov's avatar
Konstantin Osipov committed
3168 3169
    After closing tables we can free memory used for storing lock
    request for metadata locks and TABLE_LIST elements.
3170
  */
Konstantin Osipov's avatar
Konstantin Osipov committed
3171 3172 3173
  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
3174 3175
  m_reopen_array= NULL;
  m_locked_tables_count= 0;
unknown's avatar
unknown committed
3176 3177 3178
}


3179
/**
Konstantin Osipov's avatar
Konstantin Osipov committed
3180 3181 3182 3183 3184 3185 3186 3187 3188 3189
  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.
Konstantin Osipov's avatar
Konstantin Osipov committed
3190
  @param  remove_from_locked_tables
Konstantin Osipov's avatar
Konstantin Osipov committed
3191 3192 3193 3194 3195 3196
                      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
3197
*/
unknown's avatar
unknown committed
3198

Konstantin Osipov's avatar
Konstantin Osipov committed
3199 3200 3201 3202

void Locked_tables_list::unlink_from_list(THD *thd,
                                          TABLE_LIST *table_list,
                                          bool remove_from_locked_tables)
unknown's avatar
unknown committed
3203
{
Konstantin Osipov's avatar
Konstantin Osipov committed
3204 3205 3206 3207 3208 3209
  /*
    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;
3210

Konstantin Osipov's avatar
Konstantin Osipov committed
3211 3212 3213 3214 3215
  /*
    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);
3216

Konstantin Osipov's avatar
Konstantin Osipov committed
3217 3218 3219 3220 3221
  /* 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
3222

Konstantin Osipov's avatar
Konstantin Osipov committed
3223 3224 3225 3226 3227 3228
  /*
    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
3229
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
3230 3231 3232 3233 3234
    *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
3235 3236 3237
  }
}

unknown's avatar
unknown committed
3238
/**
Konstantin Osipov's avatar
Konstantin Osipov committed
3239 3240 3241 3242
  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.
3243

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

Konstantin Osipov's avatar
Konstantin Osipov committed
3247 3248
void Locked_tables_list::
unlink_all_closed_tables(THD *thd, MYSQL_LOCK *lock, size_t reopen_count)
3249
{
Konstantin Osipov's avatar
Konstantin Osipov committed
3250 3251 3252 3253 3254 3255 3256 3257 3258 3259
  /* 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)
  {
3260
    mysql_mutex_lock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276
    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();
3277
    mysql_mutex_unlock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
3278 3279
  }
  /* Exclude all closed tables from the LOCK TABLES list. */
Konstantin Osipov's avatar
Konstantin Osipov committed
3280 3281
  for (TABLE_LIST *table_list= m_locked_tables; table_list; table_list=
       table_list->next_global)
3282
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
3283
    if (table_list->table == NULL)
3284
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
3285 3286 3287 3288
      /* 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;
3289
      else
Konstantin Osipov's avatar
Konstantin Osipov committed
3290
        table_list->next_global->prev_global= table_list->prev_global;
3291 3292 3293 3294 3295
    }
  }
}


unknown's avatar
unknown committed
3296
/**
Konstantin Osipov's avatar
Konstantin Osipov committed
3297 3298
  Reopen the tables locked with LOCK TABLES and temporarily closed
  by a DDL statement or FLUSH TABLES.
unknown's avatar
unknown committed
3299

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

Konstantin Osipov's avatar
Konstantin Osipov committed
3302 3303 3304 3305
  @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
3306 3307
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
3308 3309
bool
Locked_tables_list::reopen_tables(THD *thd)
unknown's avatar
unknown committed
3310
{
Konstantin Osipov's avatar
Konstantin Osipov committed
3311
  Open_table_context ot_ctx_unused(thd);
Konstantin Osipov's avatar
Konstantin Osipov committed
3312
  bool lt_refresh_unused;
Konstantin Osipov's avatar
Konstantin Osipov committed
3313 3314 3315
  size_t reopen_count= 0;
  MYSQL_LOCK *lock;
  MYSQL_LOCK *merged_lock;
unknown's avatar
unknown committed
3316

Konstantin Osipov's avatar
Konstantin Osipov committed
3317 3318
  for (TABLE_LIST *table_list= m_locked_tables;
       table_list; table_list= table_list->next_global)
unknown's avatar
unknown committed
3319
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
3320 3321 3322 3323
    if (table_list->table)                      /* The table was not closed */
      continue;

    /* Links into thd->open_tables upon success */
Konstantin Osipov's avatar
Konstantin Osipov committed
3324
    if (open_table(thd, table_list, thd->mem_root, &ot_ctx_unused,
Konstantin Osipov's avatar
Konstantin Osipov committed
3325
                   MYSQL_OPEN_REOPEN))
unknown's avatar
unknown committed
3326
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
3327
      unlink_all_closed_tables(thd, 0, reopen_count);
Konstantin Osipov's avatar
Konstantin Osipov committed
3328
      return TRUE;
unknown's avatar
unknown committed
3329
    }
Konstantin Osipov's avatar
Konstantin Osipov committed
3330 3331 3332
    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
3333 3334 3335 3336 3337 3338

    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
3339
    thd->in_lock_tables= 1;
Konstantin Osipov's avatar
Konstantin Osipov committed
3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351
    /*
      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
3352 3353
                            MYSQL_OPEN_REOPEN, &lt_refresh_unused);
    thd->in_lock_tables= 0;
Konstantin Osipov's avatar
Konstantin Osipov committed
3354 3355
    if (lock == NULL || (merged_lock=
                         mysql_lock_merge(thd->lock, lock)) == NULL)
3356
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
3357 3358 3359
      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
3360
      return TRUE;
3361
    }
Konstantin Osipov's avatar
Konstantin Osipov committed
3362
    thd->lock= merged_lock;
unknown's avatar
unknown committed
3363
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
3364
  return FALSE;
unknown's avatar
unknown committed
3365 3366
}

3367

3368
/*
3369
  Function to assign a new table map id to a table share.
3370 3371 3372

  PARAMETERS

3373
    share - Pointer to table share structure
3374

unknown's avatar
unknown committed
3375 3376 3377 3378 3379 3380 3381
  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).

3382 3383
  PRE-CONDITION(S)

3384
    share is non-NULL
3385 3386 3387 3388
    The LOCK_open mutex is locked

  POST-CONDITION(S)

3389 3390 3391
    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
3392 3393
    share opens have been executed while one table was open all the
    time).
3394

3395
    share->table_map_id is not ~0UL.
3396
 */
3397 3398
static ulong last_table_id= ~0UL;

3399
void assign_new_table_id(TABLE_SHARE *share)
3400 3401
{

3402
  DBUG_ENTER("assign_new_table_id");
3403 3404

  /* Preconditions */
3405
  DBUG_ASSERT(share != NULL);
Marc Alff's avatar
Marc Alff committed
3406
  mysql_mutex_assert_owner(&LOCK_open);
3407 3408

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

  /* Post conditions */
3419
  DBUG_ASSERT(share->table_map_id != ~0UL);
3420 3421 3422 3423

  DBUG_VOID_RETURN;
}

3424
#ifndef DBUG_OFF
3425
/* Cause a spurious statement reprepare for debug purposes. */
3426
static bool inject_reprepare(THD *thd)
3427 3428 3429 3430 3431 3432 3433 3434 3435
{
  if (thd->m_reprepare_observer && thd->stmt_arena->is_reprepared == FALSE)
  {
    thd->m_reprepare_observer->report_error(thd);
    return TRUE;
  }

  return FALSE;
}
3436
#endif
3437

unknown's avatar
unknown committed
3438 3439 3440 3441
/**
  Compare metadata versions of an element obtained from the table
  definition cache and its corresponding node in the parse tree.

3442
  @details If the new and the old values mismatch, invoke
unknown's avatar
unknown committed
3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456
  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
3457 3458
  @sa TABLE_LIST::is_table_ref_id_equal()
  @sa TABLE_SHARE::get_table_ref_id()
unknown's avatar
unknown committed
3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469

  @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
*/

3470
static bool
unknown's avatar
unknown committed
3471 3472 3473
check_and_update_table_version(THD *thd,
                               TABLE_LIST *tables, TABLE_SHARE *table_share)
{
3474
  if (! tables->is_table_ref_id_equal(table_share))
unknown's avatar
unknown committed
3475
  {
3476 3477
    if (thd->m_reprepare_observer &&
        thd->m_reprepare_observer->report_error(thd))
unknown's avatar
unknown committed
3478 3479 3480 3481 3482 3483
    {
      /*
        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.
      */
3484
      DBUG_ASSERT(thd->is_error());
unknown's avatar
unknown committed
3485 3486
      return TRUE;
    }
3487
    /* Always maintain the latest version and type */
3488
    tables->set_table_ref_id(table_share);
unknown's avatar
unknown committed
3489
  }
3490

3491
  DBUG_EXECUTE_IF("reprepare_each_statement", return inject_reprepare(thd););
unknown's avatar
unknown committed
3492 3493 3494
  return FALSE;
}

3495

Konstantin Osipov's avatar
Konstantin Osipov committed
3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 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
/**
  Compares versions of a stored routine obtained from the sp cache
  and the version used at prepare.

  @details If the new and the old values mismatch, invoke
  Metadata_version_observer.
  At prepared statement prepare, all Sroutine_hash_entry 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 Sroutine_hash_entry, 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.

  @param[in]      thd         used to report errors
  @param[in/out]  rt          pointer to stored routine entry in the
                              parse tree
  @param[in]      sp          pointer to stored routine cache entry.
                              Can be NULL if there is no such routine.
  @retval  TRUE  an error, which has been reported
  @retval  FALSE success, version in Sroutine_hash_entry has been updated
*/

static bool
check_and_update_routine_version(THD *thd, Sroutine_hash_entry *rt,
                                 sp_head *sp)
{
  ulong spc_version= sp_cache_version();
  /* sp is NULL if there is no such routine. */
  ulong version= sp ? sp->sp_cache_version() : spc_version;
  /*
    If the version in the parse tree is stale,
    or the version in the cache is stale and sp is not used,
    we need to reprepare.
    Sic: version != spc_version <--> sp is not NULL.
  */
  if (rt->m_sp_cache_version != version ||
      (version != spc_version && !sp->is_invoked()))
  {
    if (thd->m_reprepare_observer &&
        thd->m_reprepare_observer->report_error(thd))
    {
      /*
        Version of the sp cache is different from the
        previous execution of the prepared statement, and it is
        unacceptable for this SQLCOM. Error has been reported.
      */
      DBUG_ASSERT(thd->is_error());
      return TRUE;
    }
    /* Always maintain the latest cache version. */
    rt->m_sp_cache_version= version;
  }
  return FALSE;
}


3556 3557
/**
   Open view by getting its definition from disk (and table cache in future).
3558

3559 3560 3561 3562 3563 3564 3565
   @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
3566

3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578
   @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;
3579
  my_hash_value_type hash_value;
3580 3581
  TABLE_SHARE *share;

3582 3583
  hash_value= my_calc_hash(&table_def_cache, (uchar*) cache_key,
                           cache_key_length);
3584
  mysql_mutex_lock(&LOCK_open);
3585 3586 3587

  if (!(share= get_table_share_with_create(thd, table_list, cache_key,
                                           cache_key_length, 
3588 3589
                                           OPEN_VIEW, &error,
                                           hash_value)))
3590 3591 3592 3593 3594 3595 3596 3597 3598 3599
    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
3600
    release_table_share(share);
3601
    mysql_mutex_unlock(&LOCK_open);
3602 3603 3604 3605
    return FALSE;
  }

  my_error(ER_WRONG_OBJECT, MYF(0), share->db.str, share->table_name.str, "VIEW");
Konstantin Osipov's avatar
Konstantin Osipov committed
3606
  release_table_share(share);
3607
err:
3608
  mysql_mutex_unlock(&LOCK_open);
3609 3610 3611 3612 3613
  return TRUE;
}


/**
Konstantin Osipov's avatar
Konstantin Osipov committed
3614 3615
   Finalize the process of TABLE creation by loading table triggers
   and taking action if a HEAP table content was emptied implicitly.
3616 3617 3618 3619 3620 3621 3622 3623
*/

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
3624 3625 3626 3627 3628 3629 3630 3631 3632 3633
  /*
    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
3634 3635
      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
3636
      {
3637
        /* this DELETE FROM is needed even with row-based binlogging */
unknown's avatar
unknown committed
3638
        end = strxmov(strmov(query, "DELETE FROM `"),
unknown's avatar
unknown committed
3639
                      share->db.str,"`.`",share->table_name.str,"`", NullS);
3640
        int errcode= query_error_code(thd, TRUE);
3641 3642
        if (thd->binlog_query(THD::STMT_QUERY_TYPE,
                              query, (ulong)(end-query),
3643
                              FALSE, FALSE, FALSE, errcode))
3644 3645 3646 3647
        {
          my_free(query, MYF(0));
          return TRUE;
        }
unknown's avatar
unknown committed
3648 3649 3650 3651 3652 3653 3654 3655 3656
        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
3657 3658
        sql_print_error("When opening HEAP table, could not allocate memory "
                        "to write 'DELETE FROM `%s`.`%s`' to the binary log",
3659
                        share->db.str, share->table_name.str);
3660
        delete entry->triggers;
3661
        return TRUE;
unknown's avatar
unknown committed
3662 3663
      }
    }
unknown's avatar
unknown committed
3664
  }
3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680
  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;
3681
  my_hash_value_type hash_value;
3682 3683 3684 3685 3686

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

  thd->clear_error();

3687 3688
  hash_value= my_calc_hash(&table_def_cache, (uchar*) cache_key,
                           cache_key_length);
3689
  mysql_mutex_lock(&LOCK_open);
3690 3691 3692

  if (!(share= get_table_share_with_create(thd, table_list, cache_key,
                                           cache_key_length,
3693 3694
                                           OPEN_VIEW, &not_used,
                                           hash_value)))
3695
  {
3696
    mysql_mutex_unlock(&LOCK_open);
3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708
    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;
3709
  mysql_mutex_unlock(&LOCK_open);
unknown's avatar
unknown committed
3710

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

3736
  mysql_mutex_lock(&LOCK_open);
3737 3738

end_with_lock_open:
Konstantin Osipov's avatar
Konstantin Osipov committed
3739
  release_table_share(share);
3740
  mysql_mutex_unlock(&LOCK_open);
3741 3742 3743 3744
  return result;
}


Konstantin Osipov's avatar
Konstantin Osipov committed
3745 3746 3747 3748
/** Open_table_context */

Open_table_context::Open_table_context(THD *thd)
  :m_action(OT_NO_ACTION),
3749
   m_start_of_statement_svp(thd->mdl_context.mdl_savepoint()),
3750 3751 3752
   m_has_locks((thd->in_multi_stmt_transaction() &&
                thd->mdl_context.has_locks()) ||
                thd->mdl_context.trans_sentinel()),
3753
   m_global_mdl_request(NULL)
Konstantin Osipov's avatar
Konstantin Osipov committed
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
/**
  Get MDL_request object for global intention exclusive lock which
  is acquired during opening tables for statements which take
  upgradable shared metadata locks.
*/

MDL_request *Open_table_context::get_global_mdl_request(THD *thd)
{
  if (! m_global_mdl_request)
  {
    char *buff;
    if ((buff= (char*)thd->alloc(sizeof(MDL_request))))
    {
      m_global_mdl_request= new (buff) MDL_request();
      m_global_mdl_request->init(MDL_key::GLOBAL, "", "",
                                 MDL_INTENTION_EXCLUSIVE);
    }
  }
  return m_global_mdl_request;
}


Konstantin Osipov's avatar
Konstantin Osipov committed
3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791
/**
  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)
{
  /*
3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805
    We are inside a transaction that already holds locks and have
    met a broken table or a table which needs re-discovery.
    Performing any recovery action requires acquiring an exclusive
    metadata lock on this table. Doing that with locks breaks the
    metadata locking protocol and might lead to deadlocks,
    so we report an error.

    However, if we have only met a conflicting lock or an old
    TABLE version, and just need to wait for the conflict to
    disappear/old version to go away, allow waiting.
    While waiting, we use a simple empiric to detect
    deadlocks: we never wait on someone who's waiting too.
    Waiting will be done after releasing metadata locks acquired
    by this statement.
Konstantin Osipov's avatar
Konstantin Osipov committed
3806
  */
3807
  if (m_has_locks && action_arg != OT_WAIT_MDL_LOCK)
Konstantin Osipov's avatar
Konstantin Osipov committed
3808 3809 3810 3811 3812 3813 3814 3815 3816
  {
    my_error(ER_LOCK_DEADLOCK, MYF(0));
    return TRUE;
  }
  m_action= action_arg;
  return FALSE;
}


3817
/**
Konstantin Osipov's avatar
Konstantin Osipov committed
3818
   Recover from failed attempt of open table by performing requested action.
3819 3820

   @param  thd     Thread context
Konstantin Osipov's avatar
Konstantin Osipov committed
3821 3822 3823 3824
   @param  mdl_request MDL_request of the object that caused the problem.
   @param  table   Optional (can be NULL). Used only if action is OT_REPAIR.
                   In that case a TABLE_LIST for the table to be repaired.
                   @todo: It's unnecessary and should be removed.
3825

Konstantin Osipov's avatar
Konstantin Osipov committed
3826 3827
   @pre This function should be called only with "action" != OT_NO_ACTION
        and after having called @sa close_tables_for_reopen().
Konstantin Osipov's avatar
Konstantin Osipov committed
3828

3829 3830 3831 3832
   @retval FALSE - Success. One should try to open tables once again.
   @retval TRUE  - Error
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
3833 3834
bool
Open_table_context::
Konstantin Osipov's avatar
Konstantin Osipov committed
3835 3836
recover_from_failed_open(THD *thd, MDL_request *mdl_request,
                         TABLE_LIST *table)
3837 3838
{
  bool result= FALSE;
3839 3840 3841 3842 3843
  /*
    Remove reference to released ticket from MDL_request.
  */
  if (m_global_mdl_request)
    m_global_mdl_request->ticket= NULL;
Konstantin Osipov's avatar
Konstantin Osipov committed
3844 3845
  /* Execute the action. */
  switch (m_action)
3846
  {
3847
    case OT_WAIT_MDL_LOCK:
3848 3849
      result= thd->mdl_context.wait_for_lock(mdl_request,
                                             thd->variables.lock_wait_timeout);
3850 3851 3852
      break;
    case OT_WAIT_TDC:
      result= tdc_wait_for_old_versions(thd, &m_mdl_requests);
3853
      DBUG_ASSERT(thd->mysys_var->current_mutex == NULL);
3854 3855
      break;
    case OT_DISCOVER:
Konstantin Osipov's avatar
Konstantin Osipov committed
3856
      {
3857
        MDL_request mdl_global_request;
Konstantin Osipov's avatar
Konstantin Osipov committed
3858
        MDL_request mdl_xlock_request(mdl_request);
3859
        MDL_request_list mdl_requests;
3860 3861 3862

        mdl_global_request.init(MDL_key::GLOBAL, "", "",
                                MDL_INTENTION_EXCLUSIVE);
Konstantin Osipov's avatar
Konstantin Osipov committed
3863
        mdl_xlock_request.set_type(MDL_EXCLUSIVE);
3864

3865 3866
        mdl_requests.push_front(&mdl_xlock_request);
        mdl_requests.push_front(&mdl_global_request);
3867

3868 3869 3870
        if ((result=
             thd->mdl_context.acquire_locks(&mdl_requests,
                                            thd->variables.lock_wait_timeout)))
Konstantin Osipov's avatar
Konstantin Osipov committed
3871
          break;
Konstantin Osipov's avatar
Konstantin Osipov committed
3872 3873

        DBUG_ASSERT(mdl_request->key.mdl_namespace() == MDL_key::TABLE);
3874
        mysql_mutex_lock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
3875 3876 3877 3878 3879 3880
        tdc_remove_table(thd, TDC_RT_REMOVE_ALL,
                         mdl_request->key.db_name(),
                         mdl_request->key.name());
        ha_create_table_from_engine(thd,
                                    mdl_request->key.db_name(),
                                    mdl_request->key.name());
3881
        mysql_mutex_unlock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
3882 3883 3884

        thd->warning_info->clear_warning_info(thd->query_id);
        thd->clear_error();                 // Clear error message
3885
        thd->mdl_context.release_transactional_locks();
Konstantin Osipov's avatar
Konstantin Osipov committed
3886
        break;
Konstantin Osipov's avatar
Konstantin Osipov committed
3887
      }
3888
    case OT_REPAIR:
Konstantin Osipov's avatar
Konstantin Osipov committed
3889
      {
3890
        MDL_request mdl_global_request;
Konstantin Osipov's avatar
Konstantin Osipov committed
3891
        MDL_request mdl_xlock_request(mdl_request);
3892
        MDL_request_list mdl_requests;
3893 3894 3895

        mdl_global_request.init(MDL_key::GLOBAL, "", "",
                                MDL_INTENTION_EXCLUSIVE);
Konstantin Osipov's avatar
Konstantin Osipov committed
3896
        mdl_xlock_request.set_type(MDL_EXCLUSIVE);
3897

3898 3899
        mdl_requests.push_front(&mdl_xlock_request);
        mdl_requests.push_front(&mdl_global_request);
3900

3901 3902 3903
        if ((result=
             thd->mdl_context.acquire_locks(&mdl_requests,
                                            thd->variables.lock_wait_timeout)))
Konstantin Osipov's avatar
Konstantin Osipov committed
3904
          break;
3905

Konstantin Osipov's avatar
Konstantin Osipov committed
3906
        DBUG_ASSERT(mdl_request->key.mdl_namespace() == MDL_key::TABLE);
3907
        mysql_mutex_lock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
3908 3909 3910
        tdc_remove_table(thd, TDC_RT_REMOVE_ALL,
                         mdl_request->key.db_name(),
                         mdl_request->key.name());
3911
        mysql_mutex_unlock(&LOCK_open);
Konstantin Osipov's avatar
Konstantin Osipov committed
3912 3913

        result= auto_repair_table(thd, table);
3914
        thd->mdl_context.release_transactional_locks();
Konstantin Osipov's avatar
Konstantin Osipov committed
3915 3916
        break;
      }
3917 3918 3919
    default:
      DBUG_ASSERT(0);
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
3920 3921 3922 3923
  /* Remove all old requests, they will be re-added. */
  m_mdl_requests.empty();
  /* Prepare for possible another back-off. */
  m_action= OT_NO_ACTION;
3924
  return result;
unknown's avatar
unknown committed
3925 3926
}

3927

3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949
/*
  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)
{
3950
  bool log_on= mysql_bin_log.is_open() && (thd->variables.option_bits & OPTION_BIN_LOG);
3951 3952
  ulong binlog_format= thd->variables.binlog_format;
  if ((log_on == FALSE) || (binlog_format == BINLOG_FORMAT_ROW) ||
3953
      (table->s->table_category == TABLE_CATEGORY_LOG) ||
3954 3955 3956 3957 3958 3959 3960
      (table->s->table_category == TABLE_CATEGORY_PERFORMANCE))
    return TL_READ;
  else
    return TL_READ_NO_INSERT;
}


unknown's avatar
unknown committed
3961
/*
3962 3963 3964
  Handle element of prelocking set other than table. E.g. cache routine
  and, if prelocking strategy prescribes so, extend the prelocking set
  with tables and routines used by it.
Konstantin Osipov's avatar
Konstantin Osipov committed
3965 3966 3967

  @param[in]  thd                  Thread context.
  @param[in]  prelocking_ctx       Prelocking context.
3968
  @param[in]  rt                   Element of prelocking set to be processed.
Konstantin Osipov's avatar
Konstantin Osipov committed
3969 3970 3971
  @param[in]  prelocking_strategy  Strategy which specifies how the
                                   prelocking set should be extended when
                                   one of its elements is processed.
Konstantin Osipov's avatar
Konstantin Osipov committed
3972 3973 3974 3975 3976
  @param[in]  has_prelocking_list  Indicates that prelocking set/list for
                                   this statement has already been built.
  @param[in]  ot_ctx               Context of open_table used to recover from
                                   locking failures.
  @param[out] need_prelocking      Set to TRUE if it was detected that this
Konstantin Osipov's avatar
Konstantin Osipov committed
3977 3978 3979 3980 3981 3982 3983 3984
                                   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
3985 3986 3987
open_and_process_routine(THD *thd, Query_tables_list *prelocking_ctx,
                         Sroutine_hash_entry *rt,
                         Prelocking_strategy *prelocking_strategy,
Konstantin Osipov's avatar
Konstantin Osipov committed
3988 3989
                         bool has_prelocking_list,
                         Open_table_context *ot_ctx,
3990
                         bool *need_prelocking)
Konstantin Osipov's avatar
Konstantin Osipov committed
3991
{
Konstantin Osipov's avatar
Konstantin Osipov committed
3992
  MDL_key::enum_mdl_namespace mdl_type= rt->mdl_request.key.mdl_namespace();
3993
  DBUG_ENTER("open_and_process_routine");
Konstantin Osipov's avatar
Konstantin Osipov committed
3994

Konstantin Osipov's avatar
Konstantin Osipov committed
3995
  switch (mdl_type)
3996
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
3997 3998
  case MDL_key::FUNCTION:
  case MDL_key::PROCEDURE:
Konstantin Osipov's avatar
Konstantin Osipov committed
3999
    {
4000
      sp_head *sp;
Konstantin Osipov's avatar
Konstantin Osipov committed
4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011
      /*
        Try to get MDL lock on the routine.
        Note that we do not take locks on top-level CALLs as this can
        lead to a deadlock. Not locking top-level CALLs does not break
        the binlog as only the statements in the called procedure show
        up there, not the CALL itself.
      */
      if (rt != (Sroutine_hash_entry*)prelocking_ctx->sroutines_list.first ||
          mdl_type != MDL_key::PROCEDURE)
      {
        ot_ctx->add_request(&rt->mdl_request);
4012 4013 4014 4015 4016 4017 4018

        /*
          Since we acquire only shared lock on routines we don't
          need to care about global intention exclusive locks.
        */
        DBUG_ASSERT(rt->mdl_request.type == MDL_SHARED);

4019
        if (thd->mdl_context.try_acquire_lock(&rt->mdl_request))
Konstantin Osipov's avatar
Konstantin Osipov committed
4020
          DBUG_RETURN(TRUE);
Konstantin Osipov's avatar
Konstantin Osipov committed
4021

Konstantin Osipov's avatar
Konstantin Osipov committed
4022 4023 4024
        if (rt->mdl_request.ticket == NULL)
        {
          /* A lock conflict. Someone's trying to modify SP metadata. */
4025
          ot_ctx->request_backoff_action(Open_table_context::OT_WAIT_MDL_LOCK);
Konstantin Osipov's avatar
Konstantin Osipov committed
4026 4027 4028 4029 4030 4031 4032
          DBUG_RETURN(TRUE);
        }
        DEBUG_SYNC(thd, "after_shared_lock_pname");

        /* Ensures the routine is up-to-date and cached, if exists. */
        if (sp_cache_routine(thd, rt, has_prelocking_list, &sp))
          DBUG_RETURN(TRUE);
Konstantin Osipov's avatar
Konstantin Osipov committed
4033

Konstantin Osipov's avatar
Konstantin Osipov committed
4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045
        /* Remember the version of the routine in the parse tree. */
        if (check_and_update_routine_version(thd, rt, sp))
          DBUG_RETURN(TRUE);

        /* 'sp' is NULL when there is no such routine. */
        if (sp && !has_prelocking_list)
        {
          prelocking_strategy->handle_routine(thd, prelocking_ctx, rt, sp,
                                              need_prelocking);
        }
      }
      else
4046
      {
Konstantin Osipov's avatar
Konstantin Osipov committed
4047 4048 4049 4050 4051 4052
        /*
          If it's a top level call, just make sure we have a recent
          version of the routine, if it exists.
          Validating routine version is unnecessary, since CALL
          does not affect the prepared statement prelocked list.
        */
4053 4054
        if (sp_cache_routine(thd, rt, FALSE, &sp))
          DBUG_RETURN(TRUE);
Konstantin Osipov's avatar
Konstantin Osipov committed
4055 4056
      }
    }
4057
    break;
Konstantin Osipov's avatar
Konstantin Osipov committed
4058
  case MDL_key::TRIGGER:
Konstantin Osipov's avatar
Konstantin Osipov committed
4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088
    /**
      We add trigger entries to lex->sroutines_list, but we don't
      load them here. The trigger entry is only used when building
      a transitive closure of objects used in a statement, to avoid
      adding to this closure objects that are used in the trigger more
      than once.
      E.g. if a trigger trg refers to table t2, and the trigger table t1
      is used multiple times in the statement (say, because it's used in
      function f1() twice), we will only add t2 once to the list of
      tables to prelock.

      We don't take metadata locks on triggers either: they are protected
      by a respective lock on the table, on which the trigger is defined.

      The only two cases which give "trouble" are SHOW CREATE TRIGGER
      and DROP TRIGGER statements. For these, statement syntax doesn't
      specify the table on which this trigger is defined, so we have
      to make a "dirty" read in the data dictionary to find out the
      table name. Once we discover the table name, we take a metadata
      lock on it, and this protects all trigger operations.
      Of course the table, in theory, may disappear between the dirty
      read and metadata lock acquisition, but in that case we just return
      a run-time error.

      Grammar of other trigger DDL statements (CREATE, DROP) requires
      the table to be specified explicitly, so we use the table metadata
      lock to protect trigger metadata in these statements. Similarly, in
      DML we always use triggers together with their tables, and thus don't
      need to take separate metadata locks on them.
    */
4089 4090 4091 4092
    break;
  default:
    /* Impossible type value. */
    DBUG_ASSERT(0);
Konstantin Osipov's avatar
Konstantin Osipov committed
4093 4094 4095 4096 4097
  }
  DBUG_RETURN(FALSE);
}


4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207
/**
  Handle table list element by obtaining metadata lock, opening table or view
  and, if prelocking strategy prescribes so, extending the prelocking set with
  tables and routines used by it.

  @param[in]     thd                  Thread context.
  @param[in]     lex                  LEX structure for statement.
  @param[in]     tables               Table list element to be processed.
  @param[in,out] counter              Number of tables which are 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 the
                                      prelocking set should be extended
                                      when table or view is processed.
  @param[in]     has_prelocking_list  Indicates that prelocking set/list for
                                      this statement has already been built.
  @param[in]     ot_ctx               Context used to recover from a failed
                                      open_table() attempt.
  @param[in]     new_frm_mem          Temporary MEM_ROOT to be used for
                                      parsing .FRMs for views.

  @retval  FALSE  Success.
  @retval  TRUE   Error, reported unless there is a chance to recover from it.
*/

static bool
open_and_process_table(THD *thd, LEX *lex, TABLE_LIST *tables,
                       uint *counter, uint flags,
                       Prelocking_strategy *prelocking_strategy,
                       bool has_prelocking_list,
                       Open_table_context *ot_ctx,
                       MEM_ROOT *new_frm_mem)
{
  bool error= FALSE;
  bool safe_to_ignore_table= FALSE;
  DBUG_ENTER("open_and_process_table");

  /*
    Ignore placeholders for derived tables. After derived tables
    processing, link to created temporary table will be put here.
    If this is derived table for view then we still want to process
    routines used by this view.
  */
  if (tables->derived)
  {
    if (!tables->view)
      goto end;
    /*
      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;
  }
  /*
    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.
  */
  if (tables->schema_table)
  {
    /*
      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, lex, tables) &&
        !check_and_update_table_version(thd, tables, tables->table->s))
    {
      goto end;
    }
    error= TRUE;
    goto end;
  }
  DBUG_PRINT("tcache", ("opening table: '%s'.'%s'  item: %p",
                        tables->db, tables->table_name, tables)); //psergey: invalid read of size 1 here
  (*counter)++;

  /* Not a placeholder: must be a base table or a view. Let us open it. */
  DBUG_ASSERT(!tables->table);

  if (tables->prelocking_placeholder)
  {
    /*
      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);
    error= open_table(thd, tables, new_frm_mem, ot_ctx, flags);
    thd->pop_internal_handler();
    safe_to_ignore_table= prelock_handler.safely_trapped_errors();
  }
  else
    error= open_table(thd, tables, new_frm_mem, ot_ctx, flags);

  free_root(new_frm_mem, MYF(MY_KEEP_PREALLOC));

  if (error)
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
4208
    if (! ot_ctx->can_recover_from_failed_open() && safe_to_ignore_table)
4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 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
    {
      DBUG_PRINT("info", ("open_table: ignoring table '%s'.'%s'",
                          tables->db, tables->alias));
      error= FALSE;
    }
    goto end;
  }

  /*
    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)
  {
    /* VIEW placeholder */
    (*counter)--;

    /*
      tables->next_global list consists of two parts:
      1) Query tables and underlying tables of views.
      2) Tables used by all stored routines that this statement invokes on
         execution.
      We need to know where the bound between these two parts is. If we've
      just opened a view, which was the last table in part #1, and it
      has added its base tables after itself, adjust the boundary pointer
      accordingly.
    */
    if (lex->query_tables_own_last == &(tables->next_global) &&
        tables->view->query_tables)
      lex->query_tables_own_last= 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.
  */
  if (tables->open_strategy && !tables->table)
    goto end;

  /*
    If we are not already in prelocked mode and extended table list is not
    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.
  */
  if (thd->locked_tables_mode <= LTM_LOCK_TABLES &&
      ! has_prelocking_list &&
      tables->lock_type >= TL_WRITE_ALLOW_WRITE)
  {
    bool need_prelocking= FALSE;
    TABLE_LIST **save_query_tables_last= lex->query_tables_last;
    /*
      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, lex, tables,
                                             &need_prelocking);

    if (need_prelocking && ! lex->requires_prelocking())
      lex->mark_as_requiring_prelocking(save_query_tables_last);

    if (error)
      goto end;
  }

  if (tables->lock_type != TL_UNLOCK && ! thd->locked_tables_mode)
  {
    if (tables->lock_type == TL_WRITE_DEFAULT)
      tables->table->reginfo.lock_type= thd->update_lock_default;
    else if (tables->lock_type == TL_READ_DEFAULT)
      tables->table->reginfo.lock_type=
        read_lock_type_for_table(thd, tables->table);
    else
      tables->table->reginfo.lock_type= tables->lock_type;
  }
  tables->table->grant= tables->grant;

  /* Check and update metadata version of a base table. */
  error= check_and_update_table_version(thd, tables, tables->table->s);

  if (error)
    goto end;
  /*
    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))
  {
    error= TRUE;
    goto end;
  }

process_view_routines:
  /*
    Again we may need cache all routines used by this view and add
    tables used by them to table list.
  */
  if (tables->view &&
      thd->locked_tables_mode <= LTM_LOCK_TABLES &&
      ! has_prelocking_list)
  {
    bool need_prelocking= FALSE;
    TABLE_LIST **save_query_tables_last= lex->query_tables_last;

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

    if (need_prelocking && ! lex->requires_prelocking())
      lex->mark_as_requiring_prelocking(save_query_tables_last);

    if (error)
      goto end;
  }

end:
  DBUG_RETURN(error);
}


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
/**
  Acquire upgradable (SNW, SNRW) metadata locks on tables to be opened
  for LOCK TABLES or a DDL statement.

  @param thd           Thread context.
  @param tables_start  Start of list of tables on which upgradable locks
                       should be acquired.
  @param tables_end    End of list of tables.
  @param ot_ctx        Context of open_tables() operation.

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

static bool
open_tables_acquire_upgradable_mdl(THD *thd, TABLE_LIST *tables_start,
                                   TABLE_LIST *tables_end,
                                   Open_table_context *ot_ctx)
{
  MDL_request_list mdl_requests;
  TABLE_LIST *table;

  for (table= tables_start; table && table != tables_end;
       table= table->next_global)
  {
    if (table->lock_type >= TL_WRITE_ALLOW_WRITE)
    {
      table->mdl_request.set_type(table->lock_type > TL_WRITE_ALLOW_READ ?
                                  MDL_SHARED_NO_READ_WRITE :
                                  MDL_SHARED_NO_WRITE);
      mdl_requests.push_front(&table->mdl_request);
    }
  }

  if (! mdl_requests.is_empty())
  {
    MDL_request *global_request= ot_ctx->get_global_mdl_request(thd);

    if (global_request == NULL)
      return TRUE;
    mdl_requests.push_front(global_request);
  }

4391 4392
  if (thd->mdl_context.acquire_locks(&mdl_requests,
                                     thd->variables.lock_wait_timeout))
4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408
    return TRUE;

  for (table= tables_start; table && table != tables_end;
       table= table->next_global)
  {
    if (table->lock_type >= TL_WRITE_ALLOW_WRITE)
    {
      table->mdl_request.ticket= NULL;
      table->mdl_request.set_type(MDL_SHARED_WRITE);
    }
  }

  return FALSE;
}


Konstantin Osipov's avatar
Konstantin Osipov committed
4409
/**
unknown's avatar
unknown committed
4410 4411
  Open all tables in list

Konstantin Osipov's avatar
Konstantin Osipov committed
4412 4413 4414 4415 4416 4417 4418 4419 4420
  @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
4421

Konstantin Osipov's avatar
Konstantin Osipov committed
4422 4423 4424 4425 4426 4427
  @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.
4428 4429 4430 4431 4432 4433
    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
4434 4435
  @retval  FALSE  Success.
  @retval  TRUE   Error, reported.
unknown's avatar
unknown committed
4436 4437
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
4438
bool open_tables(THD *thd, TABLE_LIST **start, uint *counter, uint flags,
Konstantin Osipov's avatar
Konstantin Osipov committed
4439
                Prelocking_strategy *prelocking_strategy)
unknown's avatar
unknown committed
4440
{
4441 4442 4443 4444 4445 4446 4447 4448 4449 4450
  /*
    We use pointers to "next_global" member in the last processed TABLE_LIST
    element and to the "next" member in the last processed Sroutine_hash_entry
    element as iterators over, correspondingly, the table list and stored routines
    list which stay valid and allow to continue iteration when new elements are
    added to the tail of the lists.
  */
  TABLE_LIST **table_to_open;
  Sroutine_hash_entry **sroutine_to_open;
  TABLE_LIST *tables;
Konstantin Osipov's avatar
Konstantin Osipov committed
4451
  Open_table_context ot_ctx(thd);
Konstantin Osipov's avatar
Konstantin Osipov committed
4452
  bool error= FALSE;
unknown's avatar
VIEW  
unknown committed
4453
  MEM_ROOT new_frm_mem;
Konstantin Osipov's avatar
Konstantin Osipov committed
4454
  bool has_prelocking_list;
4455
  DBUG_ENTER("open_tables");
Konstantin Osipov's avatar
Konstantin Osipov committed
4456

4457 4458 4459 4460 4461 4462 4463 4464 4465
  /*
    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).
  */
4466
  if (thd->handler_tables_hash.records)
4467 4468
    mysql_ha_flush(thd);

4469
  /*
4470 4471
    temporary mem_root for new .frm parsing.
    TODO: variables for size
4472
  */
4473
  init_sql_alloc(&new_frm_mem, 8024, 8024);
4474

4475
  thd->current_tablenr= 0;
Konstantin Osipov's avatar
Konstantin Osipov committed
4476 4477
restart:
  has_prelocking_list= thd->lex->requires_prelocking();
4478 4479 4480 4481
  table_to_open= start;
  sroutine_to_open= (Sroutine_hash_entry**) &thd->lex->sroutines_list.first;
  *counter= 0;
  thd_proc_info(thd, "Opening tables");
4482

4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505
  /*
    If we are executing LOCK TABLES statement or a DDL statement
    (in non-LOCK TABLES mode) we might have to acquire upgradable
    semi-exclusive metadata locks (SNW or SNRW) on some of the
    tables to be opened.
    So we acquire all such locks at once here as doing this in one
    by one fashion may lead to deadlocks or starvation. Later when
    we will be opening corresponding table pre-acquired metadata
    lock will be reused (thanks to the fact that in recursive case
    metadata locks are acquired without waiting).
  */
  if ((flags & MYSQL_OPEN_TAKE_UPGRADABLE_MDL) &&
      ! thd->locked_tables_mode)
  {
    if (open_tables_acquire_upgradable_mdl(thd, *start,
                                           thd->lex->first_not_own_table(),
                                           &ot_ctx))
    {
      error= TRUE;
      goto err;
    }
  }

4506
  /*
4507 4508
    Perform steps of prelocking algorithm until there are unprocessed
    elements in prelocking list/set.
4509
  */
4510 4511 4512
  while (*table_to_open  ||
         (thd->locked_tables_mode <= LTM_LOCK_TABLES &&
          *sroutine_to_open))
unknown's avatar
unknown committed
4513
  {
4514
    /*
4515 4516
      For every table in the list of tables to open, try to find or open
      a table.
4517
    */
4518 4519
    for (tables= *table_to_open; tables;
         table_to_open= &tables->next_global, tables= tables->next_global)
4520
    {
4521 4522 4523 4524
      error= open_and_process_table(thd, thd->lex, tables, counter,
                                    flags, prelocking_strategy,
                                    has_prelocking_list, &ot_ctx,
                                    &new_frm_mem);
unknown's avatar
VIEW  
unknown committed
4525

4526
      if (error)
unknown's avatar
unknown committed
4527
      {
Konstantin Osipov's avatar
Konstantin Osipov committed
4528
        if (ot_ctx.can_recover_from_failed_open())
4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545
        {
          /*
            We have met exclusive metadata lock or old version of table.
            Now we have to close all tables and 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
            is possible that one of tables which determined its content
            was changed.

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

            We have to save pointer to table list element for table which we
            have failed to open since closing tables can trigger removal of
            elements from the table list (if MERGE tables are involved),
          */
          TABLE_LIST *failed_table= *table_to_open;
4546
          close_tables_for_reopen(thd, start, ot_ctx.start_of_statement_svp());
Konstantin Osipov's avatar
Konstantin Osipov committed
4547

4548 4549 4550 4551 4552
          /*
            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
4553 4554
          if (ot_ctx.recover_from_failed_open(thd, &failed_table->mdl_request,
                                              failed_table))
4555
            goto err;
4556

4557 4558 4559 4560
          error= FALSE;
          goto restart;
        }
        goto err;
4561
      }
unknown's avatar
unknown committed
4562
    }
Konstantin Osipov's avatar
Konstantin Osipov committed
4563 4564

    /*
4565 4566 4567
      If we are not already in prelocked mode and extended table list is
      not yet built for our statement we need to cache routines it uses
      and build the prelocking list for it.
Konstantin Osipov's avatar
Konstantin Osipov committed
4568 4569 4570
      If we are not in prelocked mode but have built the extended table
      list, we still need to call open_and_process_routine() to take
      MDL locks on the routines.
Konstantin Osipov's avatar
Konstantin Osipov committed
4571
    */
Konstantin Osipov's avatar
Konstantin Osipov committed
4572
    if (thd->locked_tables_mode <= LTM_LOCK_TABLES)
Konstantin Osipov's avatar
Konstantin Osipov committed
4573
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
4574 4575 4576
      bool need_prelocking= FALSE;
      TABLE_LIST **save_query_tables_last= thd->lex->query_tables_last;
      /*
4577 4578 4579
        Process elements of the prelocking set which are present there
        since parsing stage or were added to it by invocations of
        Prelocking_strategy methods in the above loop over tables.
Konstantin Osipov's avatar
Konstantin Osipov committed
4580

4581 4582 4583
        For example, if 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
4584
      */
4585 4586 4587
      for (Sroutine_hash_entry *rt= *sroutine_to_open; rt;
           sroutine_to_open= &rt->next, rt= rt->next)
      {
Konstantin Osipov's avatar
Konstantin Osipov committed
4588 4589
        error= open_and_process_routine(thd, thd->lex, rt, prelocking_strategy,
                                        has_prelocking_list, &ot_ctx,
4590
                                        &need_prelocking);
Konstantin Osipov's avatar
Konstantin Osipov committed
4591

4592 4593
        if (error)
        {
Konstantin Osipov's avatar
Konstantin Osipov committed
4594 4595
          if (ot_ctx.can_recover_from_failed_open())
          {
4596 4597
            close_tables_for_reopen(thd, start,
                                    ot_ctx.start_of_statement_svp());
Konstantin Osipov's avatar
Konstantin Osipov committed
4598 4599 4600 4601 4602 4603
            if (ot_ctx.recover_from_failed_open(thd, &rt->mdl_request, NULL))
              goto err;

            error= FALSE;
            goto restart;
          }
4604 4605 4606 4607 4608 4609 4610 4611
          /*
            Serious error during reading stored routines from mysql.proc table.
            Something is wrong with the table or its contents, and an error has
            been emitted; we must abort.
          */
          goto err;
        }
      }
Konstantin Osipov's avatar
Konstantin Osipov committed
4612

4613 4614
      if (need_prelocking && ! thd->lex->requires_prelocking())
        thd->lex->mark_as_requiring_prelocking(save_query_tables_last);
Konstantin Osipov's avatar
Konstantin Osipov committed
4615

4616 4617
      if (need_prelocking && ! *start)
        *start= thd->lex->query_tables;
4618
    }
unknown's avatar
unknown committed
4619
  }
4620

Konstantin Osipov's avatar
Konstantin Osipov committed
4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637
  /*
    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
4638
        error= TRUE;
Konstantin Osipov's avatar
Konstantin Osipov committed
4639 4640 4641 4642 4643
        goto err;
      }
    }
  }

Konstantin Osipov's avatar
Konstantin Osipov committed
4644
err:
4645
  thd_proc_info(thd, 0);
4646
  free_root(&new_frm_mem, MYF(0));              // Free pre-alloced block
4647

4648
  if (error && *table_to_open)
4649
  {
4650
    (*table_to_open)->table= NULL;
4651
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
4652 4653
  DBUG_PRINT("open_tables", ("returning: %d", (int) error));
  DBUG_RETURN(error);
unknown's avatar
unknown committed
4654 4655 4656
}


Konstantin Osipov's avatar
Konstantin Osipov committed
4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692
/**
  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 ||
Konstantin Osipov's avatar
Konstantin Osipov committed
4693
      rt->mdl_request.key.mdl_namespace() != MDL_key::PROCEDURE)
Konstantin Osipov's avatar
Konstantin Osipov committed
4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870
  {
    *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
4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893
/*
  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)
  {
4894
    my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),table->alias);
unknown's avatar
unknown committed
4895 4896
    DBUG_RETURN(1);
  }
unknown's avatar
unknown committed
4897
  if ((error=table->file->start_stmt(thd, lock_type)))
unknown's avatar
unknown committed
4898 4899 4900 4901 4902 4903 4904 4905
  {
    table->file->print_error(error,MYF(0));
    DBUG_RETURN(1);
  }
  DBUG_RETURN(0);
}


4906 4907 4908 4909 4910 4911
/**
  @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
4912 4913
  @param[in]    flags           options to be used while opening and locking
                                table (see open_table(), mysql_lock_tables())
4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933

  @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
4934
    neither call thd->decide_logging_format() nor handle some other logging
4935 4936 4937 4938
    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
4939
                                thr_lock_type lock_type, uint flags)
4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954
{
  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
4955
  if (open_and_lock_tables_derived(thd, table_l, FALSE, flags))
4956 4957 4958 4959 4960 4961 4962 4963 4964
    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
4965 4966 4967 4968 4969 4970 4971 4972
/*
  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
4973
    lock_flags          Flags passed to mysql_lock_table
unknown's avatar
unknown committed
4974

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

unknown's avatar
unknown committed
4980 4981 4982 4983 4984 4985 4986 4987 4988
  RETURN VALUES
    table		Opened table
    0			Error
  
    If ok, the following are also set:
      table_list->lock_type 	lock_type
      table_list->table		table
*/

4989 4990
TABLE *open_ltable(THD *thd, TABLE_LIST *table_list, thr_lock_type lock_type,
                   uint lock_flags)
unknown's avatar
unknown committed
4991 4992
{
  TABLE *table;
Konstantin Osipov's avatar
Konstantin Osipov committed
4993
  Open_table_context ot_ctx(thd);
unknown's avatar
unknown committed
4994
  bool refresh;
Konstantin Osipov's avatar
Konstantin Osipov committed
4995
  bool error;
unknown's avatar
unknown committed
4996 4997
  DBUG_ENTER("open_ltable");

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

5001
  thd_proc_info(thd, "Opening table");
5002
  thd->current_tablenr= 0;
5003 5004
  /* open_ltable can be used only for BASIC TABLEs */
  table_list->required_type= FRMTYPE_TABLE;
5005 5006

retry:
Konstantin Osipov's avatar
Konstantin Osipov committed
5007
  while ((error= open_table(thd, table_list, thd->mem_root, &ot_ctx, 0)) &&
Konstantin Osipov's avatar
Konstantin Osipov committed
5008
         ot_ctx.can_recover_from_failed_open())
5009 5010
  {
    /*
Konstantin Osipov's avatar
Konstantin Osipov committed
5011
      Even though we have failed to open table we still need to
5012
      call release_transactional_locks() to release metadata locks which
5013 5014
      might have been acquired successfully.
    */
5015
    thd->mdl_context.rollback_to_savepoint(ot_ctx.start_of_statement_svp());
Konstantin Osipov's avatar
Konstantin Osipov committed
5016
    table_list->mdl_request.ticket= 0;
Konstantin Osipov's avatar
Konstantin Osipov committed
5017 5018
    if (ot_ctx.recover_from_failed_open(thd, &table_list->mdl_request,
                                        table_list))
5019 5020
      break;
  }
unknown's avatar
unknown committed
5021

Konstantin Osipov's avatar
Konstantin Osipov committed
5022
  if (!error)
unknown's avatar
unknown committed
5023
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
5024
    /*
5025
      We can't have a view or some special "open_strategy" in this function
Konstantin Osipov's avatar
Konstantin Osipov committed
5026 5027 5028 5029
      so there should be a TABLE instance.
    */
    DBUG_ASSERT(table_list->table);
    table= table_list->table;
Konstantin Osipov's avatar
Konstantin Osipov committed
5030
    if (table->file->ht->db_type == DB_TYPE_MRG_MYISAM)
5031 5032 5033 5034 5035 5036 5037 5038 5039 5040
    {
      /* 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
5041
    table_list->lock_type= lock_type;
unknown's avatar
unknown committed
5042
    table->grant= table_list->grant;
Konstantin Osipov's avatar
Konstantin Osipov committed
5043
    if (thd->locked_tables_mode)
unknown's avatar
unknown committed
5044
    {
unknown's avatar
unknown committed
5045 5046 5047 5048 5049
      if (check_lock_and_start_stmt(thd, table, lock_type))
	table= 0;
    }
    else
    {
5050
      DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
unknown's avatar
unknown committed
5051
      if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)
5052
	if (! (thd->lock= mysql_lock_tables(thd, &table_list->table, 1,
Konstantin Osipov's avatar
Konstantin Osipov committed
5053
                                            lock_flags, &refresh)))
5054 5055 5056
        {
          if (refresh)
          {
5057 5058 5059 5060 5061
            close_thread_tables(thd);
            table_list->table= NULL;
            table_list->mdl_request.ticket= NULL;
            thd->mdl_context.rollback_to_savepoint(ot_ctx.start_of_statement_svp());
            goto retry;
5062 5063 5064 5065
          }
          else
            table= 0;
        }
unknown's avatar
unknown committed
5066 5067
    }
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
5068 5069
  else
    table= 0;
5070

Konstantin Osipov's avatar
Konstantin Osipov committed
5071
end:
5072
  thd_proc_info(thd, 0);
unknown's avatar
unknown committed
5073 5074 5075
  DBUG_RETURN(table);
}

unknown's avatar
unknown committed
5076

Konstantin Osipov's avatar
Konstantin Osipov committed
5077
/**
5078
  Open all tables in list, locks them and optionally process derived tables.
unknown's avatar
unknown committed
5079

Konstantin Osipov's avatar
Konstantin Osipov committed
5080 5081 5082 5083 5084 5085 5086 5087
  @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
5088

Konstantin Osipov's avatar
Konstantin Osipov committed
5089
  @note
5090
    The lock will automaticaly be freed by close_thread_tables()
5091

Konstantin Osipov's avatar
Konstantin Osipov committed
5092 5093
  @note
    There are several convenience functions, e.g. :
5094 5095 5096 5097
    - 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
5098 5099 5100

  @retval FALSE  OK.
  @retval TRUE   Error
unknown's avatar
unknown committed
5101 5102
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
5103 5104 5105
bool open_and_lock_tables_derived(THD *thd, TABLE_LIST *tables,
                                  bool derived, uint flags,
                                  Prelocking_strategy *prelocking_strategy)
unknown's avatar
unknown committed
5106 5107
{
  uint counter;
5108
  bool need_reopen;
5109 5110 5111 5112 5113 5114 5115 5116 5117 5118
  /*
    Remember the set of metadata locks which this connection
    managed to acquire before the start of the current statement.
    It can be either transaction-scope locks, or HANDLER locks,
    or LOCK TABLES locks. If mysql_lock_tables() fails with
    need_reopen request, we'll use it to instruct
    close_tables_for_reopen() to release all locks of this
    statement.
  */
  MDL_ticket *start_of_statement_svp= thd->mdl_context.mdl_savepoint();
5119 5120
  DBUG_ENTER("open_and_lock_tables_derived");
  DBUG_PRINT("enter", ("derived handling: %d", derived));
5121 5122 5123

  for ( ; ; ) 
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
5124
    if (open_tables(thd, &tables, &counter, flags, prelocking_strategy))
Konstantin Osipov's avatar
Konstantin Osipov committed
5125
      DBUG_RETURN(TRUE);
5126 5127 5128 5129 5130 5131
    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
5132 5133
    if (!lock_tables(thd, tables, counter, flags,
                     &need_reopen))
5134 5135
      break;
    if (!need_reopen)
Konstantin Osipov's avatar
Konstantin Osipov committed
5136
      DBUG_RETURN(TRUE);
5137
    close_tables_for_reopen(thd, &tables, start_of_statement_svp);
5138
  }
5139 5140 5141 5142
  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
5143
    DBUG_RETURN(TRUE); /* purecov: inspected */
Konstantin Osipov's avatar
Konstantin Osipov committed
5144
  DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
5145 5146 5147
}


5148 5149 5150 5151 5152 5153
/*
  Open all tables in list and process derived tables

  SYNOPSIS
    open_normal_and_derived_tables
    thd		- thread handler
5154
    tables	- list of tables for open
5155 5156 5157
    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.
5158 5159 5160 5161 5162 5163 5164 5165 5166 5167

  RETURN
    FALSE - ok
    TRUE  - error

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

5168
bool open_normal_and_derived_tables(THD *thd, TABLE_LIST *tables, uint flags)
5169 5170 5171
{
  uint counter;
  DBUG_ENTER("open_normal_and_derived_tables");
unknown's avatar
unknown committed
5172
  DBUG_ASSERT(!thd->fill_derived_tables());
5173
  if (open_tables(thd, &tables, &counter, flags) ||
unknown's avatar
unknown committed
5174 5175 5176
      mysql_handle_derived(thd->lex, &mysql_derived_prepare))
    DBUG_RETURN(TRUE); /* purecov: inspected */
  DBUG_RETURN(0);
5177 5178 5179
}


5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195
/*
  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)
5196
    if (!table->placeholder())
5197 5198 5199 5200
      table->table->query_id= 0;
}


unknown's avatar
unknown committed
5201 5202 5203 5204 5205 5206 5207
/*
  Lock all tables in list

  SYNOPSIS
    lock_tables()
    thd			Thread handler
    tables		Tables to lock
5208
    count		Number of opened tables
Konstantin Osipov's avatar
Konstantin Osipov committed
5209
    flags               Options (see mysql_lock_tables() for details)
5210 5211 5212 5213 5214
    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
5215

5216 5217 5218 5219 5220
  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
5221 5222 5223
    If query for which we are calling this function marked as requiring
    prelocking, this function will change locked_tables_mode to
    LTM_PRELOCKED.
5224

unknown's avatar
unknown committed
5225 5226 5227 5228 5229
  RETURN VALUES
   0	ok
   -1	Error
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
5230 5231
bool lock_tables(THD *thd, TABLE_LIST *tables, uint count,
                 uint flags, bool *need_reopen)
unknown's avatar
unknown committed
5232
{
unknown's avatar
unknown committed
5233
  TABLE_LIST *table;
5234 5235 5236 5237 5238 5239

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

5244
  if (!tables && !thd->lex->requires_prelocking())
5245
    DBUG_RETURN(thd->decide_logging_format(tables));
unknown's avatar
unknown committed
5246

5247
  /*
Konstantin Osipov's avatar
Konstantin Osipov committed
5248 5249 5250 5251
    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
5252
    "drop table t3; create temporary t3 ..; insert into t3 ...;"
Konstantin Osipov's avatar
Konstantin Osipov committed
5253 5254 5255
    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.
5256
  */
Konstantin Osipov's avatar
Konstantin Osipov committed
5257
  if (! thd->locked_tables_mode)
unknown's avatar
unknown committed
5258
  {
5259
    DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
unknown's avatar
unknown committed
5260
    TABLE **start,**ptr;
5261

5262
    if (!(ptr=start=(TABLE**) thd->alloc(sizeof(TABLE*)*count)))
Konstantin Osipov's avatar
Konstantin Osipov committed
5263
      DBUG_RETURN(TRUE);
unknown's avatar
VIEW  
unknown committed
5264
    for (table= tables; table; table= table->next_global)
unknown's avatar
unknown committed
5265
    {
5266
      if (!table->placeholder())
unknown's avatar
unknown committed
5267 5268
	*(ptr++)= table->table;
    }
5269 5270 5271 5272

    /* We have to emulate LOCK TABLES if we are statement needs prelocking. */
    if (thd->lex->requires_prelocking())
    {
unknown's avatar
unknown committed
5273
      /*
5274 5275 5276 5277
        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
5278
      */
5279
      if (thd->variables.binlog_format != BINLOG_FORMAT_ROW && tables && 
5280
          has_write_table_with_auto_increment(thd->lex->first_not_own_table()))
5281
        thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_AUTOINC_COLUMNS);
5282 5283
    }

5284 5285
    DEBUG_SYNC(thd, "before_lock_tables_takes_lock");

5286
    if (! (thd->lock= mysql_lock_tables(thd, start, (uint) (ptr - start),
Konstantin Osipov's avatar
Konstantin Osipov committed
5287
                                        flags, need_reopen)))
Konstantin Osipov's avatar
Konstantin Osipov committed
5288
      DBUG_RETURN(TRUE);
5289

5290 5291
    DEBUG_SYNC(thd, "after_lock_tables_takes_lock");

5292 5293 5294 5295 5296 5297 5298 5299
    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.

5300 5301 5302 5303 5304 5305 5306 5307 5308 5309
        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)
5310
      {
5311
        if (!table->placeholder())
5312 5313 5314 5315
        {
          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
5316
            mysql_unlock_tables(thd, thd->lock);
Konstantin Osipov's avatar
Konstantin Osipov committed
5317
            thd->lock= 0;
Konstantin Osipov's avatar
Konstantin Osipov committed
5318
            DBUG_RETURN(TRUE);
5319 5320 5321 5322 5323 5324 5325 5326
          }
        }
      }
      /*
        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
5327
      DBUG_PRINT("info",("locked_tables_mode= LTM_PRELOCKED"));
5328
      thd->enter_locked_tables_mode(LTM_PRELOCKED);
5329
    }
unknown's avatar
unknown committed
5330
  }
unknown's avatar
unknown committed
5331 5332
  else
  {
5333
    TABLE_LIST *first_not_own= thd->lex->first_not_own_table();
5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344
    /*
      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
5345
    {
5346 5347 5348 5349 5350 5351 5352
      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
5353
      if (thd->locked_tables_mode >= LTM_PRELOCKED &&
5354 5355 5356 5357
          table->lock_type >= TL_WRITE_ALLOW_WRITE)
      {
        for (TABLE* opentab= thd->open_tables; opentab; opentab= opentab->next)
        {
Staale Smedseng's avatar
Staale Smedseng committed
5358 5359
          if (table->table->s == opentab->s && opentab->query_id &&
              table->table->query_id != opentab->query_id)
5360 5361
          {
            my_error(ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG, MYF(0),
Staale Smedseng's avatar
Staale Smedseng committed
5362
                     table->table->s->table_name.str);
Konstantin Osipov's avatar
Konstantin Osipov committed
5363
            DBUG_RETURN(TRUE);
5364 5365 5366 5367 5368
          }
        }
      }

      if (check_lock_and_start_stmt(thd, table->table, table->lock_type))
unknown's avatar
unknown committed
5369
      {
Konstantin Osipov's avatar
Konstantin Osipov committed
5370
	DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
5371 5372
      }
    }
5373 5374 5375 5376 5377 5378 5379 5380
    /*
      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
5381 5382 5383
      DBUG_PRINT("info",
                 ("thd->locked_tables_mode= LTM_PRELOCKED_UNDER_LOCK_TABLES"));
      thd->locked_tables_mode= LTM_PRELOCKED_UNDER_LOCK_TABLES;
5384
    }
unknown's avatar
unknown committed
5385
  }
5386

5387
  DBUG_RETURN(thd->decide_logging_format(tables));
unknown's avatar
unknown committed
5388 5389
}

unknown's avatar
unknown committed
5390

5391
/**
5392 5393 5394
  Prepare statement for reopening of tables and recalculation of set of
  prelocked tables.

5395 5396 5397 5398 5399 5400 5401 5402 5403 5404
  @param[in] thd         Thread context.
  @param[in,out] tables  List of tables which we were trying to open
                         and lock.
  @param[in] start_of_statement_svp MDL savepoint which represents the set
                         of metadata locks which the current transaction
                         managed to acquire before execution of the current
                         statement and to which we should revert before
                         trying to reopen tables. NULL if no metadata locks
                         were held and thus all metadata locks should be
                         released.
5405 5406
*/

5407 5408
void close_tables_for_reopen(THD *thd, TABLE_LIST **tables,
                             MDL_ticket *start_of_statement_svp)
5409
{
Konstantin Osipov's avatar
Konstantin Osipov committed
5410 5411 5412
  TABLE_LIST *first_not_own_table= thd->lex->first_not_own_table();
  TABLE_LIST *tmp;

5413 5414 5415 5416
  /*
    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
5417
  if (first_not_own_table == *tables)
5418
    *tables= 0;
5419
  thd->lex->chop_off_not_own_tables();
Konstantin Osipov's avatar
Konstantin Osipov committed
5420 5421 5422 5423 5424
  /* Reset MDL tickets for procedures/functions */
  for (Sroutine_hash_entry *rt=
         (Sroutine_hash_entry*)thd->lex->sroutines_list.first;
       rt; rt= rt->next)
    rt->mdl_request.ticket= NULL;
5425
  sp_remove_not_own_routines(thd->lex);
Konstantin Osipov's avatar
Konstantin Osipov committed
5426
  for (tmp= *tables; tmp; tmp= tmp->next_global)
Konstantin Osipov's avatar
Konstantin Osipov committed
5427
  {
5428
    tmp->table= 0;
Konstantin Osipov's avatar
Konstantin Osipov committed
5429
    tmp->mdl_request.ticket= NULL;
Konstantin Osipov's avatar
Konstantin Osipov committed
5430 5431
    /* We have to cleanup translation tables of views. */
    tmp->cleanup_items();
Konstantin Osipov's avatar
Konstantin Osipov committed
5432
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
5433 5434 5435 5436 5437 5438 5439 5440 5441
  /*
    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
5442
  close_thread_tables(thd);
5443
  thd->mdl_context.rollback_to_savepoint(start_of_statement_svp);
5444 5445 5446
}


unknown's avatar
unknown committed
5447
/*
unknown's avatar
unknown committed
5448
  Open a single table without table caching and don't set it in open_list
unknown's avatar
unknown committed
5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464

  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
5465 5466 5467 5468 5469 5470
*/

TABLE *open_temporary_table(THD *thd, const char *path, const char *db,
			    const char *table_name, bool link_in_list)
{
  TABLE *tmp_table;
5471
  TABLE_SHARE *share;
unknown's avatar
unknown committed
5472 5473 5474
  char cache_key[MAX_DBKEY_LENGTH], *saved_cache_key, *tmp_path;
  uint key_length;
  TABLE_LIST table_list;
unknown's avatar
unknown committed
5475
  DBUG_ENTER("open_temporary_table");
unknown's avatar
unknown committed
5476 5477 5478 5479 5480
  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));
5481

unknown's avatar
unknown committed
5482 5483 5484 5485 5486 5487 5488 5489
  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
5490 5491
    DBUG_RETURN(0);				/* purecov: inspected */

unknown's avatar
unknown committed
5492 5493 5494 5495 5496
  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);

5497
  init_tmp_table_share(thd, share, saved_cache_key, key_length,
unknown's avatar
unknown committed
5498 5499 5500 5501 5502 5503 5504 5505
                       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
5506
                            tmp_table, FALSE))
unknown's avatar
unknown committed
5507
  {
unknown's avatar
unknown committed
5508 5509
    /* No need to lock share->mutex as this is not needed for tmp tables */
    free_table_share(share);
5510
    my_free((char*) tmp_table,MYF(0));
unknown's avatar
unknown committed
5511 5512 5513
    DBUG_RETURN(0);
  }

unknown's avatar
unknown committed
5514
  tmp_table->reginfo.lock_type= TL_WRITE;	 // Simulate locked
5515
  share->tmp_table= (tmp_table->file->has_transactions() ? 
5516
                     TRANSACTIONAL_TMP_TABLE : NON_TRANSACTIONAL_TMP_TABLE);
5517

unknown's avatar
unknown committed
5518 5519
  if (link_in_list)
  {
5520 5521 5522 5523
    /* 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
5524
    thd->temporary_tables= tmp_table;
5525
    thd->temporary_tables->prev= 0;
unknown's avatar
unknown committed
5526 5527
    if (thd->slave_thread)
      slave_open_temp_tables++;
unknown's avatar
unknown committed
5528
  }
unknown's avatar
unknown committed
5529
  tmp_table->pos_in_table_list= 0;
5530 5531
  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
5532 5533 5534 5535
  DBUG_RETURN(tmp_table);
}


unknown's avatar
unknown committed
5536
bool rm_temporary_table(handlerton *base, char *path)
unknown's avatar
unknown committed
5537 5538
{
  bool error=0;
unknown's avatar
unknown committed
5539 5540
  handler *file;
  char *ext;
5541 5542
  DBUG_ENTER("rm_temporary_table");

unknown's avatar
unknown committed
5543
  strmov(ext= strend(path), reg_ext);
Marc Alff's avatar
Marc Alff committed
5544
  if (mysql_file_delete(key_file_frm, path, MYF(0)))
unknown's avatar
unknown committed
5545
    error=1; /* purecov: inspected */
unknown's avatar
unknown committed
5546 5547
  *ext= 0;				// remove extension
  file= get_new_handler((TABLE_SHARE*) 0, current_thd->mem_root, base);
5548
  if (file && file->ha_delete_table(path))
unknown's avatar
unknown committed
5549
  {
unknown's avatar
unknown committed
5550
    error=1;
unknown's avatar
unknown committed
5551
    sql_print_warning("Could not remove temporary table: '%s', error: %d",
unknown's avatar
unknown committed
5552
                      path, my_errno);
unknown's avatar
unknown committed
5553
  }
unknown's avatar
unknown committed
5554
  delete file;
5555
  DBUG_RETURN(error);
unknown's avatar
unknown committed
5556 5557 5558 5559
}


/*****************************************************************************
unknown's avatar
unknown committed
5560 5561 5562 5563 5564 5565
* 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
5566 5567
******************************************************************************/

unknown's avatar
unknown committed
5568
/* Special Field pointers as return values of find_field_in_XXX functions. */
unknown's avatar
unknown committed
5569 5570
Field *not_found_field= (Field*) 0x1;
Field *view_ref_found= (Field*) 0x2; 
unknown's avatar
VIEW  
unknown committed
5571

unknown's avatar
unknown committed
5572 5573
#define WRONG_GRANT (Field*) -1

unknown's avatar
unknown committed
5574 5575
static void update_field_dependencies(THD *thd, Field *field, TABLE *table)
{
5576 5577
  DBUG_ENTER("update_field_dependencies");
  if (thd->mark_used_columns != MARK_COLUMNS_NONE)
unknown's avatar
unknown committed
5578
  {
5579 5580 5581 5582 5583 5584 5585
    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).
    */
      
5586
    table->covering_keys.intersect(field->part_of_key);
5587 5588 5589
    table->merge_keys.merge(field->part_of_key);

    if (thd->mark_used_columns == MARK_COLUMNS_READ)
unknown's avatar
unknown committed
5590
    {
5591 5592
      current_bitmap= table->read_set;
      other_bitmap=   table->write_set;
unknown's avatar
unknown committed
5593 5594
    }
    else
5595 5596 5597 5598 5599
    {
      current_bitmap= table->write_set;
      other_bitmap=   table->read_set;
    }

5600 5601 5602 5603 5604 5605 5606
    /* 
       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()
    */
5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624
    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)
5625
    field->flags|= GET_FIXED_FIELDS_FLAG;
5626
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
5627 5628
}

unknown's avatar
VIEW  
unknown committed
5629 5630

/*
unknown's avatar
unknown committed
5631
  Find a field by name in a view that uses merge algorithm.
unknown's avatar
VIEW  
unknown committed
5632 5633

  SYNOPSIS
unknown's avatar
unknown committed
5634
    find_field_in_view()
unknown's avatar
VIEW  
unknown committed
5635
    thd				thread handler
unknown's avatar
unknown committed
5636
    table_list			view to search for 'name'
unknown's avatar
VIEW  
unknown committed
5637 5638
    name			name of field
    length			length of name
5639
    item_name                   name of item if it will be created (VIEW)
unknown's avatar
unknown committed
5640 5641
    ref				expression substituted in VIEW should be passed
                                using this reference (return view_ref_found)
unknown's avatar
unknown committed
5642
    register_tree_change        TRUE if ref is not stack variable and we
unknown's avatar
unknown committed
5643
                                need register changes in item tree
unknown's avatar
VIEW  
unknown committed
5644 5645 5646 5647

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

unknown's avatar
unknown committed
5651 5652
static Field *
find_field_in_view(THD *thd, TABLE_LIST *table_list,
5653 5654
                   const char *name, uint length,
                   const char *item_name, Item **ref,
unknown's avatar
unknown committed
5655
                   bool register_tree_change)
unknown's avatar
VIEW  
unknown committed
5656
{
unknown's avatar
unknown committed
5657 5658 5659 5660 5661 5662
  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
5663
  Query_arena *arena= 0, backup;  
5664
  
unknown's avatar
unknown committed
5665 5666 5667
  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
5668
  {
unknown's avatar
unknown committed
5669
    if (!my_strcasecmp(system_charset_info, field_it.name(), name))
5670
    {
5671
      // in PS use own arena or data will be freed after prepare
5672 5673
      if (register_tree_change &&
          thd->stmt_arena->is_stmt_prepare_or_first_stmt_execute())
5674
        arena= thd->activate_stmt_arena_if_needed(&backup);
5675 5676 5677 5678
      /*
        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
5679
      Item *item= field_it.create_item(thd);
unknown's avatar
unknown committed
5680
      if (arena)
5681 5682
        thd->restore_active_arena(arena, &backup);
      
unknown's avatar
unknown committed
5683 5684 5685 5686 5687 5688
      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.
5689
       We need to set alias on both ref itself and on ref real item.
unknown's avatar
unknown committed
5690 5691
      */
      if (*ref && !(*ref)->is_autogenerated_name)
5692
      {
unknown's avatar
unknown committed
5693 5694
        item->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
5695 5696 5697
        item->real_item()->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
      }
unknown's avatar
unknown committed
5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725
      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

5726 5727 5728 5729 5730 5731
  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
5732
  RETURN
5733 5734 5735
    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
5736 5737 5738 5739
*/

static Field *
find_field_in_natural_join(THD *thd, TABLE_LIST *table_ref, const char *name,
5740
                           uint length, Item **ref, bool register_tree_change,
5741
                           TABLE_LIST **actual_table)
unknown's avatar
unknown committed
5742
{
5743 5744
  List_iterator_fast<Natural_join_column>
    field_it(*(table_ref->join_columns));
5745
  Natural_join_column *nj_col, *curr_nj_col;
5746
  Field *found_field;
5747
  Query_arena *arena, backup;
unknown's avatar
unknown committed
5748
  DBUG_ENTER("find_field_in_natural_join");
5749
  DBUG_PRINT("enter", ("field name: '%s', ref 0x%lx",
unknown's avatar
unknown committed
5750 5751
		       name, (ulong) ref));
  DBUG_ASSERT(table_ref->is_natural_join && table_ref->join_columns);
5752
  DBUG_ASSERT(*actual_table == NULL);
unknown's avatar
unknown committed
5753

5754
  LINT_INIT(arena);
5755
  LINT_INIT(found_field);
unknown's avatar
unknown committed
5756

5757 5758
  for (nj_col= NULL, curr_nj_col= field_it++; curr_nj_col; 
       curr_nj_col= field_it++)
unknown's avatar
unknown committed
5759
  {
5760 5761 5762 5763 5764 5765 5766 5767 5768
    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
5769
  }
5770 5771
  if (!nj_col)
    DBUG_RETURN(NULL);
unknown's avatar
unknown committed
5772 5773 5774

  if (nj_col->view_field)
  {
unknown's avatar
unknown committed
5775
    Item *item;
unknown's avatar
unknown committed
5776
    LINT_INIT(arena);
5777 5778
    if (register_tree_change)
      arena= thd->activate_stmt_arena_if_needed(&backup);
5779 5780 5781 5782
    /*
      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
5783
    item= nj_col->create_item(thd);
5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796
    /*
     *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);
    }
5797 5798 5799
    if (register_tree_change && arena)
      thd->restore_active_arena(arena, &backup);

unknown's avatar
unknown committed
5800 5801 5802 5803
    if (!item)
      DBUG_RETURN(NULL);
    DBUG_ASSERT(nj_col->table_field == NULL);
    if (nj_col->table_ref->schema_table_reformed)
5804
    {
unknown's avatar
unknown committed
5805 5806 5807 5808 5809 5810
      /*
        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);
5811
    }
unknown's avatar
unknown committed
5812 5813 5814 5815 5816 5817 5818 5819 5820 5821
    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);
5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836
    /*
      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
5837 5838 5839 5840 5841 5842
    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
5843 5844
}

5845

unknown's avatar
VIEW  
unknown committed
5846
/*
unknown's avatar
unknown committed
5847
  Find field by name in a base table or a view with temp table algorithm.
unknown's avatar
VIEW  
unknown committed
5848 5849

  SYNOPSIS
unknown's avatar
unknown committed
5850
    find_field_in_table()
unknown's avatar
VIEW  
unknown committed
5851
    thd				thread handler
unknown's avatar
unknown committed
5852
    table			table where to search for the field
unknown's avatar
VIEW  
unknown committed
5853 5854 5855
    name			name of field
    length			length of name
    allow_rowid			do allow finding of "_rowid" field?
unknown's avatar
unknown committed
5856 5857
    cached_field_index_ptr	cached position in field list (used to speedup
                                lookup for fields in prepared tables)
unknown's avatar
VIEW  
unknown committed
5858 5859

  RETURN
5860 5861
    0	field is not found
    #	pointer to field
unknown's avatar
VIEW  
unknown committed
5862 5863
*/

unknown's avatar
unknown committed
5864 5865
Field *
find_field_in_table(THD *thd, TABLE *table, const char *name, uint length,
5866
                    bool allow_rowid, uint *cached_field_index_ptr)
unknown's avatar
unknown committed
5867
{
unknown's avatar
unknown committed
5868 5869
  Field **field_ptr, *field;
  uint cached_field_index= *cached_field_index_ptr;
5870 5871
  DBUG_ENTER("find_field_in_table");
  DBUG_PRINT("enter", ("table: '%s', field name: '%s'", table->alias, name));
unknown's avatar
unknown committed
5872 5873

  /* We assume here that table->field < NO_CACHED_FIELD_INDEX = UINT_MAX */
5874
  if (cached_field_index < table->s->fields &&
5875
      !my_strcasecmp(system_charset_info,
unknown's avatar
unknown committed
5876 5877
                     table->field[cached_field_index]->field_name, name))
    field_ptr= table->field + cached_field_index;
5878
  else if (table->s->name_hash.records)
unknown's avatar
unknown committed
5879
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
5880 5881
    field_ptr= (Field**) my_hash_search(&table->s->name_hash, (uchar*) name,
                                        length);
unknown's avatar
unknown committed
5882 5883 5884 5885 5886 5887 5888 5889 5890
    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
5891 5892 5893
  else
  {
    if (!(field_ptr= table->field))
unknown's avatar
unknown committed
5894
      DBUG_RETURN((Field *)0);
unknown's avatar
unknown committed
5895 5896 5897 5898 5899 5900
    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
5901
  {
unknown's avatar
unknown committed
5902 5903
    *cached_field_index_ptr= field_ptr - table->field;
    field= *field_ptr;
unknown's avatar
unknown committed
5904 5905 5906
  }
  else
  {
unknown's avatar
unknown committed
5907 5908
    if (!allow_rowid ||
        my_strcasecmp(system_charset_info, name, "_rowid") ||
unknown's avatar
unknown committed
5909
        table->s->rowid_field_offset == 0)
unknown's avatar
unknown committed
5910
      DBUG_RETURN((Field*) 0);
unknown's avatar
unknown committed
5911
    field= table->field[table->s->rowid_field_offset-1];
unknown's avatar
unknown committed
5912 5913
  }

unknown's avatar
unknown committed
5914 5915 5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927
  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
5928
    length		   [in]  field length of name
unknown's avatar
unknown committed
5929 5930
    item_name              [in]  name of item if it will be created (VIEW)
    db_name                [in]  optional database name that qualifies the
5931
    table_name             [in]  optional table name that qualifies the field
unknown's avatar
unknown committed
5932 5933
    ref		       [in/out] if 'name' is resolved to a view field, ref
                                 is set to point to the found view field
5934
    check_privileges       [in]  check privileges
unknown's avatar
unknown committed
5935 5936 5937 5938 5939 5940 5941 5942 5943
    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
5944 5945 5946 5947 5948 5949 5950 5951 5952 5953 5954 5955
  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
5956 5957 5958 5959 5960 5961 5962 5963
  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,
5964 5965 5966
                        const char *name, uint length,
                        const char *item_name, const char *db_name,
                        const char *table_name, Item **ref,
5967 5968
                        bool check_privileges, bool allow_rowid,
                        uint *cached_field_index_ptr,
unknown's avatar
unknown committed
5969 5970 5971 5972
                        bool register_tree_change, TABLE_LIST **actual_table)
{
  Field *fld;
  DBUG_ENTER("find_field_in_table_ref");
unknown's avatar
unknown committed
5973 5974 5975
  DBUG_ASSERT(table_list->alias);
  DBUG_ASSERT(name);
  DBUG_ASSERT(item_name);
unknown's avatar
unknown committed
5976 5977 5978 5979 5980 5981
  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
5982 5983
    are the same as the table reference we are going to search for the field.

5984 5985 5986 5987
    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
5988 5989 5990 5991 5992 5993

    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'.

5994 5995
    TODO: Ensure that table_name, db_name and tables->db always points to
          something !
unknown's avatar
unknown committed
5996
  */
5997 5998
  if (/* Exclude nested joins. */
      (!table_list->nested_join ||
unknown's avatar
unknown committed
5999 6000 6001 6002 6003 6004
       /* Include merge views and information schema tables. */
       table_list->field_translation) &&
      /*
        Test if the field qualifiers match the table reference we plan
        to search.
      */
6005 6006
      table_name && table_name[0] &&
      (my_strcasecmp(table_alias_charset, table_list->alias, table_name) ||
unknown's avatar
unknown committed
6007
       (db_name && db_name[0] && table_list->db && table_list->db[0] &&
6008 6009 6010
        (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
6011 6012
    DBUG_RETURN(0);

6013
  *actual_table= NULL;
unknown's avatar
unknown committed
6014

unknown's avatar
unknown committed
6015 6016
  if (table_list->field_translation)
  {
unknown's avatar
unknown committed
6017
    /* 'table_list' is a view or an information schema table. */
6018
    if ((fld= find_field_in_view(thd, table_list, name, length, item_name, ref,
6019
                                 register_tree_change)))
unknown's avatar
unknown committed
6020 6021
      *actual_table= table_list;
  }
6022
  else if (!table_list->nested_join)
6023
  {
6024 6025
    /* 'table_list' is a stored table. */
    DBUG_ASSERT(table_list->table);
unknown's avatar
unknown committed
6026
    if ((fld= find_field_in_table(thd, table_list->table, name, length,
6027 6028
                                  allow_rowid,
                                  cached_field_index_ptr)))
unknown's avatar
unknown committed
6029 6030 6031
      *actual_table= table_list;
  }
  else
6032
  {
unknown's avatar
unknown committed
6033
    /*
unknown's avatar
unknown committed
6034 6035 6036 6037 6038
      '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
6039
    */
6040 6041 6042 6043 6044 6045
    if (table_name && table_name[0])
    {
      List_iterator<TABLE_LIST> it(table_list->nested_join->join_list);
      TABLE_LIST *table;
      while ((table= it++))
      {
6046 6047
        if ((fld= find_field_in_table_ref(thd, table, name, length, item_name,
                                          db_name, table_name, ref,
6048 6049
                                          check_privileges, allow_rowid,
                                          cached_field_index_ptr,
6050 6051 6052 6053 6054 6055 6056
                                          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
6057 6058 6059
      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.
6060 6061
    */
    fld= find_field_in_natural_join(thd, table_list, name, length, ref,
unknown's avatar
unknown committed
6062
                                    register_tree_change, actual_table);
6063
  }
unknown's avatar
unknown committed
6064

6065 6066
  if (fld)
  {
6067
#ifndef NO_EMBEDDED_ACCESS_CHECKS
6068 6069 6070 6071 6072
    /* 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
6073
#endif
6074
      if (thd->mark_used_columns != MARK_COLUMNS_NONE)
6075
      {
6076
        /*
6077 6078 6079
          Get rw_set correct for this field so that the handler
          knows that this field is involved in the query and gets
          retrieved/updated
6080
         */
6081 6082 6083 6084 6085 6086
        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;
6087 6088 6089
          else
          {
            if (thd->mark_used_columns == MARK_COLUMNS_READ)
6090
              it->walk(&Item::register_field_in_read_map, 1, (uchar *) 0);
6091
          }
6092 6093 6094 6095
        }
        else
          field_to_set= fld;
        if (field_to_set)
6096 6097 6098 6099 6100 6101 6102
        {
          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);
        }
6103 6104
      }
  }
unknown's avatar
unknown committed
6105
  DBUG_RETURN(fld);
unknown's avatar
unknown committed
6106 6107
}

6108

6109 6110 6111 6112 6113 6114 6115 6116 6117 6118 6119 6120 6121 6122 6123 6124 6125 6126 6127
/*
  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
6128
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
6129 6130
    field_ptr= (Field**)my_hash_search(&table->s->name_hash,(uchar*) name,
                                       strlen(name));
unknown's avatar
unknown committed
6131 6132 6133 6134 6135 6136 6137 6138 6139
    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));
    }
  }
6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154
  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;
}


6155 6156 6157 6158 6159
/*
  Find field in table list.

  SYNOPSIS
    find_field_in_tables()
unknown's avatar
unknown committed
6160 6161 6162 6163 6164 6165
    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
6166
                          point to the found view field
unknown's avatar
unknown committed
6167
    report_error	  Degree of error reporting:
6168 6169
                          - IGNORE_ERRORS then do not report any error
                          - IGNORE_EXCEPT_NON_UNIQUE report only non-unique
unknown's avatar
unknown committed
6170
                            fields, suppress all other errors
6171 6172 6173 6174
                          - 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
6175 6176
    register_tree_change  TRUE if ref is not a stack variable and we
                          to need register changes in item tree
6177 6178

  RETURN VALUES
6179 6180 6181
    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.
6182 6183 6184 6185 6186
    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
6187
*/
unknown's avatar
unknown committed
6188 6189

Field *
unknown's avatar
unknown committed
6190 6191
find_field_in_tables(THD *thd, Item_ident *item,
                     TABLE_LIST *first_table, TABLE_LIST *last_table,
6192
		     Item **ref, find_item_error_report_type report_error,
6193
                     bool check_privileges, bool register_tree_change)
unknown's avatar
unknown committed
6194 6195
{
  Field *found=0;
unknown's avatar
unknown committed
6196 6197 6198
  const char *db= item->db_name;
  const char *table_name= item->table_name;
  const char *name= item->field_name;
unknown's avatar
unknown committed
6199
  uint length=(uint) strlen(name);
6200
  char name_buff[NAME_LEN+1];
unknown's avatar
unknown committed
6201 6202
  TABLE_LIST *cur_table= first_table;
  TABLE_LIST *actual_table;
unknown's avatar
unknown committed
6203 6204 6205 6206 6207 6208 6209 6210 6211
  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
6212

unknown's avatar
unknown committed
6213 6214 6215
  if (item->cached_table)
  {
    /*
unknown's avatar
unknown committed
6216 6217
      This shortcut is used by prepared statements. We assume that
      TABLE_LIST *first_table is not changed during query execution (which
6218
      is true for all queries except RENAME but luckily RENAME doesn't
unknown's avatar
unknown committed
6219
      use fields...) so we can rely on reusing pointer to its member.
unknown's avatar
unknown committed
6220
      With this optimization we also miss case when addition of one more
6221
      field makes some prepared query ambiguous and so erroneous, but we
unknown's avatar
unknown committed
6222 6223
      accept this trade off.
    */
unknown's avatar
unknown committed
6224 6225 6226 6227 6228 6229 6230 6231
    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,
6232
                                 TRUE, &(item->cached_field_index));
6233
    else
6234
      found= find_field_in_table_ref(thd, table_ref, name, length, item->name,
6235 6236
                                     NULL, NULL, ref, check_privileges,
                                     TRUE, &(item->cached_field_index),
unknown's avatar
unknown committed
6237 6238
                                     register_tree_change,
                                     &actual_table);
unknown's avatar
unknown committed
6239 6240 6241
    if (found)
    {
      if (found == WRONG_GRANT)
6242
	return (Field*) 0;
6243 6244 6245 6246 6247 6248

      /*
        Only views fields should be marked as dependent, not an underlying
        fields.
      */
      if (!table_ref->belong_to_view)
6249 6250
      {
        SELECT_LEX *current_sel= thd->lex->current_select;
unknown's avatar
unknown committed
6251
        SELECT_LEX *last_select= table_ref->select_lex;
unknown's avatar
unknown committed
6252 6253
        /*
          If the field was an outer referencee, mark all selects using this
unknown's avatar
unknown committed
6254
          sub query as dependent on the outer query
unknown's avatar
unknown committed
6255
        */
6256
        if (current_sel != last_select)
unknown's avatar
unknown committed
6257
          mark_select_range_as_dependent(thd, last_select, current_sel,
6258 6259
                                         found, *ref, item);
      }
unknown's avatar
unknown committed
6260 6261 6262 6263
      return found;
    }
  }

6264 6265 6266
  if (db && lower_case_table_names)
  {
    /*
unknown's avatar
unknown committed
6267
      convert database to lower case for comparison.
6268 6269 6270 6271
      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
6272
    my_casedn_str(files_charset_info, name_buff);
6273 6274
    db= name_buff;
  }
unknown's avatar
unknown committed
6275

6276 6277 6278 6279 6280
  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
6281
  {
6282 6283
    Field *cur_field= find_field_in_table_ref(thd, cur_table, name, length,
                                              item->name, db, table_name, ref,
6284 6285 6286
                                              (thd->lex->sql_command ==
                                               SQLCOM_SHOW_FIELDS)
                                              ? false : check_privileges,
6287
                                              allow_rowid,
unknown's avatar
unknown committed
6288 6289 6290 6291
                                              &(item->cached_field_index),
                                              register_tree_change,
                                              &actual_table);
    if (cur_field)
6292
    {
unknown's avatar
unknown committed
6293
      if (cur_field == WRONG_GRANT)
6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310
      {
        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);
6311
          nf->init(cur_table->table);
6312 6313 6314
          cur_field= nf;
        }
      }
unknown's avatar
unknown committed
6315 6316 6317 6318 6319 6320 6321 6322

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

6323 6324 6325 6326 6327
      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
6328
      if (db)
6329 6330
        return cur_field;

unknown's avatar
unknown committed
6331 6332
      if (found)
      {
6333 6334
        if (report_error == REPORT_ALL_ERRORS ||
            report_error == IGNORE_EXCEPT_NON_UNIQUE)
6335
          my_error(ER_NON_UNIQ_ERROR, MYF(0),
unknown's avatar
unknown committed
6336
                   table_name ? item->full_name() : name, thd->where);
6337
        return (Field*) 0;
unknown's avatar
unknown committed
6338
      }
unknown's avatar
unknown committed
6339
      found= cur_field;
unknown's avatar
unknown committed
6340 6341
    }
  }
6342

unknown's avatar
unknown committed
6343 6344
  if (found)
    return found;
6345 6346 6347 6348 6349 6350 6351 6352

  /*
    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
6353
  if (table_name && (cur_table == first_table) &&
6354 6355 6356
      (report_error == REPORT_ALL_ERRORS ||
       report_error == REPORT_EXCEPT_NON_UNIQUE))
  {
6357
    char buff[NAME_LEN*2 + 2];
6358 6359 6360 6361 6362 6363 6364
    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);
  }
6365
  else
unknown's avatar
unknown committed
6366
  {
6367 6368 6369 6370 6371
    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
6372
  }
6373
  return found;
unknown's avatar
unknown committed
6374 6375
}

6376 6377 6378

/*
  Find Item in list of items (find_field_in_tables analog)
6379 6380 6381 6382

  TODO
    is it better return only counter?

6383 6384
  SYNOPSIS
    find_item_in_list()
6385 6386 6387
    find			Item to find
    items			List of items
    counter			To return number of found item
6388
    report_error
6389 6390 6391 6392 6393
      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
6394 6395 6396 6397 6398 6399 6400
    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)
                                
6401
  RETURN VALUES
6402 6403 6404 6405 6406
    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
6407
                        found field
6408 6409
*/

6410
/* Special Item pointer to serve as a return value from find_item_in_list(). */
unknown's avatar
unknown committed
6411
Item **not_found_item= (Item**) 0x1;
6412 6413


unknown's avatar
unknown committed
6414
Item **
6415
find_item_in_list(Item *find, List<Item> &items, uint *counter,
unknown's avatar
unknown committed
6416 6417
                  find_item_error_report_type report_error,
                  enum_resolution_type *resolution)
unknown's avatar
unknown committed
6418 6419
{
  List_iterator<Item> li(items);
6420
  Item **found=0, **found_unaliased= 0, *item;
6421
  const char *db_name=0;
unknown's avatar
unknown committed
6422 6423
  const char *field_name=0;
  const char *table_name=0;
6424
  bool found_unaliased_non_uniq= 0;
6425 6426 6427 6428 6429
  /*
    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
6430
  uint unaliased_counter= 0;
6431

unknown's avatar
unknown committed
6432
  *resolution= NOT_RESOLVED;
6433

6434 6435 6436
  is_ref_by_name= (find->type() == Item::FIELD_ITEM  || 
                   find->type() == Item::REF_ITEM);
  if (is_ref_by_name)
unknown's avatar
unknown committed
6437 6438 6439
  {
    field_name= ((Item_ident*) find)->field_name;
    table_name= ((Item_ident*) find)->table_name;
6440
    db_name=    ((Item_ident*) find)->db_name;
unknown's avatar
unknown committed
6441 6442
  }

6443
  for (uint i= 0; (item=li++); i++)
unknown's avatar
unknown committed
6444
  {
6445
    if (field_name && item->real_item()->type() == Item::FIELD_ITEM)
unknown's avatar
unknown committed
6446
    {
6447
      Item_ident *item_field= (Item_ident*) item;
6448

unknown's avatar
unknown committed
6449 6450 6451 6452 6453 6454
      /*
	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
      */ 
6455 6456 6457 6458
      if (!item_field->name)
        continue;

      if (table_name)
unknown's avatar
unknown committed
6459
      {
6460 6461 6462
        /*
          If table name is specified we should find field 'field_name' in
          table 'table_name'. According to SQL-standard we should ignore
6463 6464 6465 6466 6467
          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.
6468

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

	  item_field->field_name and item_field->table_name can be 0x0 if
6474
	  item is not fix_field()'ed yet.
6475
        */
6476 6477
        if (item_field->field_name && item_field->table_name &&
	    !my_strcasecmp(system_charset_info, item_field->field_name,
6478
                           field_name) &&
unknown's avatar
unknown committed
6479 6480
            !my_strcasecmp(table_alias_charset, item_field->table_name, 
                           table_name) &&
6481 6482 6483
            (!db_name || (item_field->db_name &&
                          !strcmp(item_field->db_name, db_name))))
        {
6484
          if (found_unaliased)
6485
          {
6486 6487 6488 6489 6490 6491 6492
            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.
            */
6493
            if (report_error != IGNORE_ERRORS)
6494 6495
              my_error(ER_NON_UNIQ_ERROR, MYF(0),
                       find->full_name(), current_thd->where);
6496 6497
            return (Item**) 0;
          }
6498 6499
          found_unaliased= li.ref();
          unaliased_counter= i;
unknown's avatar
unknown committed
6500
          *resolution= RESOLVED_IGNORING_ALIAS;
6501 6502
          if (db_name)
            break;                              // Perfect match
6503 6504
        }
      }
unknown's avatar
unknown committed
6505
      else
6506
      {
unknown's avatar
unknown committed
6507 6508 6509 6510 6511
        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))
6512
        {
unknown's avatar
unknown committed
6513 6514 6515 6516 6517 6518 6519 6520 6521 6522 6523 6524 6525 6526 6527 6528 6529 6530 6531 6532
          /*
            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;
6533
        }
unknown's avatar
unknown committed
6534
        else if (!fname_cmp)
6535
        {
unknown's avatar
unknown committed
6536 6537 6538 6539 6540 6541 6542 6543 6544 6545 6546 6547
          /*
            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;
          }
6548 6549 6550
          found_unaliased= li.ref();
          unaliased_counter= i;
        }
unknown's avatar
unknown committed
6551 6552
      }
    }
unknown's avatar
unknown committed
6553 6554 6555 6556 6557 6558 6559 6560 6561 6562 6563 6564 6565 6566 6567 6568 6569
    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;
      }
6570 6571 6572 6573 6574 6575 6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589 6590 6591 6592 6593 6594 6595 6596 6597 6598 6599
    }
    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
6600
  }
6601 6602 6603 6604 6605
  if (!found)
  {
    if (found_unaliased_non_uniq)
    {
      if (report_error != IGNORE_ERRORS)
6606 6607
        my_error(ER_NON_UNIQ_ERROR, MYF(0),
                 find->full_name(), current_thd->where);
6608 6609 6610 6611 6612 6613
      return (Item **) 0;
    }
    if (found_unaliased)
    {
      found= found_unaliased;
      *counter= unaliased_counter;
unknown's avatar
unknown committed
6614
      *resolution= RESOLVED_BEHIND_ALIAS;
6615 6616
    }
  }
6617 6618
  if (found)
    return found;
6619
  if (report_error != REPORT_EXCEPT_NOT_FOUND)
6620 6621
  {
    if (report_error == REPORT_ALL_ERRORS)
6622 6623
      my_error(ER_BAD_FIELD_ERROR, MYF(0),
               find->full_name(), current_thd->where);
6624 6625 6626 6627
    return (Item **) 0;
  }
  else
    return (Item **) not_found_item;
unknown's avatar
unknown committed
6628 6629
}

unknown's avatar
unknown committed
6630 6631 6632 6633 6634 6635 6636 6637 6638 6639 6640 6641 6642 6643 6644 6645 6646 6647 6648 6649 6650 6651 6652 6653 6654 6655 6656 6657

/*
  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;
6658
    if (!my_strcasecmp(system_charset_info, find, curr_str->ptr()))
unknown's avatar
unknown committed
6659 6660 6661 6662 6663 6664 6665 6666 6667 6668 6669 6670 6671 6672 6673 6674 6675 6676 6677 6678 6679
      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
6680 6681
    FALSE  if all OK
    TRUE   otherwise
unknown's avatar
unknown committed
6682 6683 6684 6685 6686 6687
*/

static bool
set_new_item_local_context(THD *thd, Item_ident *item, TABLE_LIST *table_ref)
{
  Name_resolution_context *context;
6688
  if (!(context= new (thd->mem_root) Name_resolution_context))
unknown's avatar
unknown committed
6689 6690
    return TRUE;
  context->init();
6691 6692
  context->first_name_resolution_table=
    context->last_name_resolution_table= table_ref;
unknown's avatar
unknown committed
6693 6694 6695 6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712 6713 6714 6715 6716 6717 6718 6719 6720 6721 6722 6723 6724
  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
6725 6726
    TRUE   error when some common column is non-unique, or out of memory
    FALSE  OK
unknown's avatar
unknown committed
6727 6728 6729 6730 6731 6732 6733 6734 6735 6736
*/

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
6737 6738 6739 6740 6741 6742 6743 6744 6745 6746 6747
  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
6748 6749

  DBUG_ENTER("mark_common_columns");
6750
  DBUG_PRINT("info", ("operand_1: %s  operand_2: %s",
unknown's avatar
unknown committed
6751 6752
                      table_ref_1->alias, table_ref_2->alias));

6753
  *found_using_fields= 0;
unknown's avatar
unknown committed
6754
  arena= thd->activate_stmt_arena_if_needed(&backup);
unknown's avatar
unknown committed
6755 6756 6757

  for (it_1.set(table_ref_1); !it_1.end_of_fields(); it_1.next())
  {
6758
    bool found= FALSE;
unknown's avatar
unknown committed
6759
    const char *field_name_1;
6760 6761
    /* true if field_name_1 is a member of using_fields */
    bool is_using_column_1;
6762
    if (!(nj_col_1= it_1.get_or_create_column_ref(thd, leaf_1)))
unknown's avatar
unknown committed
6763 6764
      goto err;
    field_name_1= nj_col_1->name();
6765 6766 6767 6768 6769
    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
6770

6771 6772 6773 6774 6775 6776 6777
    /*
      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
6778 6779 6780 6781
    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;
6782
      const char *cur_field_name_2;
6783
      if (!(cur_nj_col_2= it_2.get_or_create_column_ref(thd, leaf_2)))
unknown's avatar
unknown committed
6784
        goto err;
6785
      cur_field_name_2= cur_nj_col_2->name();
6786 6787 6788 6789
      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
6790

unknown's avatar
unknown committed
6791 6792 6793 6794 6795 6796
      /*
        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).
6797 6798 6799 6800
        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
6801
      */
unknown's avatar
unknown committed
6802 6803
      if (!my_strcasecmp(system_charset_info, field_name_1, cur_field_name_2))
      {
6804 6805 6806
        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
6807 6808 6809 6810 6811 6812 6813 6814
        {
          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
6815 6816 6817 6818 6819 6820 6821 6822 6823
    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
6824
    if (!found)
6825
      continue;                                 // No matching field
unknown's avatar
unknown committed
6826 6827 6828 6829 6830 6831

    /*
      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.
    */
6832
    if (nj_col_2 && (!using_fields ||is_using_column_1))
unknown's avatar
unknown committed
6833 6834 6835 6836 6837 6838
    {
      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;
6839 6840 6841 6842 6843
      Item_func_eq *eq_cond;

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

unknown's avatar
unknown committed
6844
      /*
6845
        The following assert checks that the two created items are of
unknown's avatar
unknown committed
6846 6847 6848 6849 6850 6851 6852 6853 6854 6855 6856 6857 6858 6859 6860 6861 6862 6863 6864 6865 6866 6867 6868 6869
        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.
      */
6870 6871
      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
6872 6873
        goto err;

6874 6875
      if (!(eq_cond= new Item_func_eq(item_ident_1, item_ident_2)))
        goto err;                               /* Out of memory. */
unknown's avatar
unknown committed
6876 6877 6878 6879 6880 6881

      /*
        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.
       */
6882 6883 6884
      add_join_on((table_ref_1->outer_join & JOIN_TYPE_RIGHT ?
                   table_ref_1 : table_ref_2),
                  eq_cond);
unknown's avatar
unknown committed
6885 6886

      nj_col_1->is_common= nj_col_2->is_common= TRUE;
6887 6888 6889 6890 6891 6892 6893
      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
6894 6895 6896

      if (field_1)
      {
unknown's avatar
unknown committed
6897
        TABLE *table_1= nj_col_1->table_ref->table;
unknown's avatar
unknown committed
6898
        /* Mark field_1 used for table cache. */
6899
        bitmap_set_bit(table_1->read_set, field_1->field_index);
6900
        table_1->covering_keys.intersect(field_1->part_of_key);
6901
        table_1->merge_keys.merge(field_1->part_of_key);
unknown's avatar
unknown committed
6902 6903 6904
      }
      if (field_2)
      {
unknown's avatar
unknown committed
6905
        TABLE *table_2= nj_col_2->table_ref->table;
unknown's avatar
unknown committed
6906
        /* Mark field_2 used for table cache. */
6907
        bitmap_set_bit(table_2->read_set, field_2->field_index);
6908
        table_2->covering_keys.intersect(field_2->part_of_key);
6909
        table_2->merge_keys.merge(field_2->part_of_key);
unknown's avatar
unknown committed
6910 6911 6912 6913 6914 6915
      }

      if (using_fields != NULL)
        ++(*found_using_fields);
    }
  }
unknown's avatar
unknown committed
6916 6917
  if (leaf_1)
    leaf_1->is_join_columns_complete= TRUE;
unknown's avatar
unknown committed
6918 6919 6920 6921 6922 6923 6924 6925 6926 6927 6928 6929

  /*
    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
6930
    thd->restore_active_arena(arena, &backup);
unknown's avatar
unknown committed
6931 6932 6933 6934 6935 6936 6937 6938 6939 6940 6941 6942 6943 6944 6945 6946 6947 6948 6949 6950 6951 6952 6953 6954 6955 6956 6957 6958 6959 6960 6961 6962 6963 6964 6965 6966
  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
6967 6968
    TRUE    error: Some common column is ambiguous
    FALSE   OK
unknown's avatar
unknown committed
6969 6970 6971 6972 6973 6974 6975 6976 6977 6978 6979 6980 6981
*/

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;
6982
  List<Natural_join_column> *non_join_columns;
unknown's avatar
unknown committed
6983 6984
  DBUG_ENTER("store_natural_using_join_columns");

6985 6986
  DBUG_ASSERT(!natural_using_join->join_columns);

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

6989 6990
  if (!(non_join_columns= new List<Natural_join_column>) ||
      !(natural_using_join->join_columns= new List<Natural_join_column>))
unknown's avatar
unknown committed
6991 6992 6993 6994 6995
    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())
  {
6996
    nj_col_1= it_1.get_natural_column_ref();
unknown's avatar
unknown committed
6997 6998 6999 7000 7001 7002 7003 7004 7005 7006 7007 7008 7009 7010 7011 7012 7013 7014 7015 7016 7017
    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++))
    {
7018
      const char *using_field_name_ptr= using_field_name->c_ptr();
unknown's avatar
unknown committed
7019 7020 7021
      List_iterator_fast<Natural_join_column>
        it(*(natural_using_join->join_columns));
      Natural_join_column *common_field;
7022 7023

      for (;;)
unknown's avatar
unknown committed
7024
      {
7025 7026 7027 7028 7029 7030 7031
        /* 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
7032 7033
        if (!my_strcasecmp(system_charset_info,
                           common_field->name(), using_field_name_ptr))
7034
          break;                                // Found match
unknown's avatar
unknown committed
7035 7036 7037 7038 7039 7040 7041
      }
    }
  }

  /* 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())
  {
7042
    nj_col_2= it_2.get_natural_column_ref();
unknown's avatar
unknown committed
7043 7044 7045
    if (!nj_col_2->is_common)
      non_join_columns->push_back(nj_col_2);
    else
7046
    {
unknown's avatar
unknown committed
7047 7048
      /* Reset the common columns for the next call to mark_common_columns. */
      nj_col_2->is_common= FALSE;
7049
    }
unknown's avatar
unknown committed
7050 7051 7052 7053 7054 7055 7056 7057 7058 7059
  }

  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
7060
    thd->restore_active_arena(arena, &backup);
unknown's avatar
unknown committed
7061 7062 7063
  DBUG_RETURN(result);
}

7064

unknown's avatar
unknown committed
7065 7066 7067 7068 7069 7070 7071 7072 7073 7074 7075 7076 7077 7078 7079 7080 7081 7082 7083 7084 7085 7086 7087 7088 7089 7090
/*
  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
7091 7092
    TRUE   Error
    FALSE  OK
unknown's avatar
unknown committed
7093 7094 7095 7096 7097 7098 7099
*/

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
7100 7101 7102
  Query_arena *arena, backup;
  bool result= TRUE;

unknown's avatar
unknown committed
7103
  DBUG_ENTER("store_top_level_join_columns");
7104

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

unknown's avatar
unknown committed
7107 7108 7109 7110
  /* 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
7111 7112 7113 7114
    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;
7115

unknown's avatar
unknown committed
7116
    while (same_level_left_neighbor)
unknown's avatar
unknown committed
7117
    {
unknown's avatar
unknown committed
7118 7119
      TABLE_LIST *cur_table_ref= same_level_left_neighbor;
      same_level_left_neighbor= nested_it++;
7120 7121 7122 7123
      /*
        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
7124 7125 7126 7127 7128
        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
7129 7130
        swapped in the first loop.
      */
unknown's avatar
unknown committed
7131
      if (same_level_left_neighbor &&
7132 7133 7134 7135
          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
7136
        swap_variables(TABLE_LIST*, same_level_left_neighbor, cur_table_ref);
7137 7138
      }

unknown's avatar
unknown committed
7139 7140 7141 7142 7143 7144 7145 7146 7147
      /*
        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;

7148 7149
      if (cur_table_ref->nested_join &&
          store_top_level_join_columns(thd, cur_table_ref,
unknown's avatar
unknown committed
7150
                                       real_left_neighbor, real_right_neighbor))
unknown's avatar
unknown committed
7151
        goto err;
unknown's avatar
unknown committed
7152
      same_level_right_neighbor= cur_table_ref;
unknown's avatar
unknown committed
7153 7154 7155 7156 7157 7158 7159 7160 7161 7162 7163 7164 7165 7166 7167 7168 7169 7170 7171 7172 7173 7174 7175 7176 7177 7178 7179 7180 7181 7182
    }
  }

  /*
    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
7183
      goto err;
unknown's avatar
unknown committed
7184 7185 7186 7187 7188 7189 7190 7191 7192 7193 7194

    /*
      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
7195
      goto err;
unknown's avatar
unknown committed
7196 7197 7198 7199 7200 7201 7202 7203 7204

    /*
      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
7205 7206 7207 7208 7209
    /* 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
7210 7211 7212
    /* Change this table reference to become a leaf for name resolution. */
    if (left_neighbor)
    {
7213
      TABLE_LIST *last_leaf_on_the_left;
unknown's avatar
unknown committed
7214 7215 7216 7217 7218
      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)
    {
7219
      TABLE_LIST *first_leaf_on_the_right;
unknown's avatar
unknown committed
7220 7221 7222 7223 7224 7225
      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
7226 7227 7228 7229
  result= FALSE; /* All is OK. */

err:
  if (arena)
unknown's avatar
unknown committed
7230
    thd->restore_active_arena(arena, &backup);
unknown's avatar
unknown committed
7231
  DBUG_RETURN(result);
unknown's avatar
unknown committed
7232 7233 7234 7235 7236 7237 7238 7239 7240 7241 7242 7243 7244 7245 7246 7247 7248 7249 7250 7251 7252 7253 7254 7255
}


/*
  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
7256 7257
    TRUE   Error
    FALSE  OK
unknown's avatar
unknown committed
7258
*/
7259 7260
static bool setup_natural_join_row_types(THD *thd,
                                         List<TABLE_LIST> *from_clause,
unknown's avatar
unknown committed
7261 7262 7263 7264 7265 7266 7267 7268 7269
                                         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. */
7270
  TABLE_LIST *left_neighbor;
unknown's avatar
unknown committed
7271 7272
  /* Table reference to the right of the current. */
  TABLE_LIST *right_neighbor= NULL;
7273 7274 7275 7276
  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
7277

7278 7279
  /* Note that tables in the list are in reversed order */
  for (left_neighbor= table_ref_it++; left_neighbor ; )
unknown's avatar
unknown committed
7280 7281 7282
  {
    table_ref= left_neighbor;
    left_neighbor= table_ref_it++;
7283 7284 7285 7286 7287 7288
    /* 
      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
7289
    {
7290
      context->select_lex->first_natural_join_processing= FALSE;
7291 7292 7293 7294 7295 7296 7297 7298 7299
      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
7300 7301 7302 7303 7304 7305 7306
    }
    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
7307
    right_neighbor points to the left-most top-level table reference in the
unknown's avatar
unknown committed
7308 7309 7310 7311 7312 7313 7314 7315 7316 7317
    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
7318
/****************************************************************************
7319
** Expand all '*' in given fields
unknown's avatar
unknown committed
7320 7321
****************************************************************************/

7322 7323 7324
int setup_wild(THD *thd, TABLE_LIST *tables, List<Item> &fields,
	       List<Item> *sum_func_list,
	       uint wild_num)
unknown's avatar
unknown committed
7325
{
7326
  if (!wild_num)
7327
    return(0);
7328

7329
  Item *item;
unknown's avatar
unknown committed
7330
  List_iterator<Item> it(fields);
unknown's avatar
unknown committed
7331
  Query_arena *arena, backup;
7332
  DBUG_ENTER("setup_wild");
unknown's avatar
unknown committed
7333 7334

  /*
7335 7336
    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
7337
  */
unknown's avatar
unknown committed
7338
  arena= thd->activate_stmt_arena_if_needed(&backup);
7339

7340
  thd->lex->current_select->cur_pos_in_select_list= 0;
unknown's avatar
unknown committed
7341
  while (wild_num && (item= it++))
unknown's avatar
VIEW  
unknown committed
7342
  {
7343 7344
    if (item->type() == Item::FIELD_ITEM &&
        ((Item_field*) item)->field_name &&
7345 7346
	((Item_field*) item)->field_name[0] == '*' &&
	!((Item_field*) item)->field)
7347
    {
7348
      uint elem= fields.elements;
unknown's avatar
VIEW  
unknown committed
7349
      bool any_privileges= ((Item_field *) item)->any_privileges;
unknown's avatar
unknown committed
7350 7351 7352 7353 7354 7355 7356 7357 7358
      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.
        */
7359 7360
        it.replace(new Item_int("Not_used", (longlong) 1,
                                MY_INT64_NUM_DECIMAL_DIGITS));
unknown's avatar
unknown committed
7361
      }
7362 7363
      else if (insert_fields(thd, ((Item_field*) item)->context,
                             ((Item_field*) item)->db_name,
unknown's avatar
unknown committed
7364
                             ((Item_field*) item)->table_name, &it,
7365
                             any_privileges))
unknown's avatar
unknown committed
7366 7367
      {
	if (arena)
unknown's avatar
unknown committed
7368
	  thd->restore_active_arena(arena, &backup);
7369
	DBUG_RETURN(-1);
unknown's avatar
unknown committed
7370
      }
7371
      if (sum_func_list)
7372 7373 7374 7375 7376 7377 7378 7379
      {
	/*
	  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;
      }
7380
      wild_num--;
7381
    }
7382 7383
    else
      thd->lex->current_select->cur_pos_in_select_list++;
7384
  }
7385
  thd->lex->current_select->cur_pos_in_select_list= UNDEF_POS;
unknown's avatar
unknown committed
7386 7387 7388 7389 7390
  if (arena)
  {
    /* make * substituting permanent */
    SELECT_LEX *select_lex= thd->lex->current_select;
    select_lex->with_wild= 0;
7391 7392 7393 7394 7395 7396 7397
    /*   
      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
7398

unknown's avatar
unknown committed
7399
    thd->restore_active_arena(arena, &backup);
unknown's avatar
unknown committed
7400
  }
7401
  DBUG_RETURN(0);
7402 7403
}

7404 7405 7406 7407
/****************************************************************************
** Check that all given fields exists and fill struct with current data
****************************************************************************/

7408
bool setup_fields(THD *thd, Item **ref_pointer_array,
7409
                  List<Item> &fields, enum_mark_columns mark_used_columns,
unknown's avatar
unknown committed
7410
                  List<Item> *sum_func_list, bool allow_sum_func)
7411 7412
{
  reg2 Item *item;
7413
  enum_mark_columns save_mark_used_columns= thd->mark_used_columns;
unknown's avatar
unknown committed
7414
  nesting_map save_allow_sum_func= thd->lex->allow_sum_func;
7415
  List_iterator<Item> it(fields);
7416
  bool save_is_item_list_lookup;
7417 7418
  DBUG_ENTER("setup_fields");

7419 7420
  thd->mark_used_columns= mark_used_columns;
  DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
unknown's avatar
unknown committed
7421 7422
  if (allow_sum_func)
    thd->lex->allow_sum_func|= 1 << thd->lex->current_select->nest_level;
7423
  thd->where= THD::DEFAULT_WHERE;
7424 7425
  save_is_item_list_lookup= thd->lex->current_select->is_item_list_lookup;
  thd->lex->current_select->is_item_list_lookup= 0;
7426

7427 7428 7429 7430 7431 7432 7433 7434 7435 7436 7437 7438 7439 7440
  /*
    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);

7441 7442 7443 7444 7445 7446 7447 7448 7449 7450 7451 7452 7453 7454 7455 7456
  /*
    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
7457
  Item **ref= ref_pointer_array;
7458
  thd->lex->current_select->cur_pos_in_select_list= 0;
unknown's avatar
unknown committed
7459
  while ((item= it++))
7460
  {
7461
    if ((!item->fixed && item->fix_fields(thd, it.ref())) ||
unknown's avatar
unknown committed
7462
	(item= *(it.ref()))->check_cols(1))
unknown's avatar
unknown committed
7463
    {
7464
      thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
unknown's avatar
unknown committed
7465
      thd->lex->allow_sum_func= save_allow_sum_func;
7466 7467
      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
7468
      DBUG_RETURN(TRUE); /* purecov: inspected */
unknown's avatar
unknown committed
7469
    }
unknown's avatar
unknown committed
7470 7471
    if (ref)
      *(ref++)= item;
7472 7473
    if (item->with_sum_func && item->type() != Item::SUM_FUNC_ITEM &&
	sum_func_list)
7474
      item->split_sum_func(thd, ref_pointer_array, *sum_func_list);
unknown's avatar
unknown committed
7475
    thd->used_tables|= item->used_tables();
7476
    thd->lex->current_select->cur_pos_in_select_list++;
7477
  }
7478
  thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
7479 7480
  thd->lex->current_select->cur_pos_in_select_list= UNDEF_POS;

unknown's avatar
unknown committed
7481
  thd->lex->allow_sum_func= save_allow_sum_func;
7482 7483
  thd->mark_used_columns= save_mark_used_columns;
  DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
7484
  DBUG_RETURN(test(thd->is_error()));
7485
}
7486

7487

7488 7489 7490 7491 7492 7493 7494 7495 7496 7497 7498 7499 7500 7501 7502
/*
  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)
  {
7503 7504 7505 7506 7507 7508
    if (table->merge_underlying_list)
    {
      DBUG_ASSERT(table->view &&
                  table->effective_algorithm == VIEW_ALGORITHM_MERGE);
      list= make_leaves_list(list, table->merge_underlying_list);
    }
7509 7510 7511 7512 7513 7514 7515 7516 7517
    else
    {
      *list= table;
      list= &table->next_leaf;
    }
  }
  return list;
}

7518
/*
unknown's avatar
unknown committed
7519 7520 7521 7522
  prepare tables

  SYNOPSIS
    setup_tables()
unknown's avatar
unknown committed
7523
    thd		  Thread handler
7524
    context       name resolution contest to setup table list there
unknown's avatar
unknown committed
7525 7526 7527
    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
7528 7529
    refresh       It is onle refresh for subquery
    select_insert It is SELECT ... INSERT command
unknown's avatar
unknown committed
7530

unknown's avatar
unknown committed
7531 7532
  NOTE
    Check also that the 'used keys' and 'ignored keys' exists and set up the
unknown's avatar
unknown committed
7533 7534 7535 7536
    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.
7537

unknown's avatar
unknown committed
7538 7539
    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
7540

unknown's avatar
unknown committed
7541
  RETURN
unknown's avatar
unknown committed
7542
    FALSE ok;  In this case *map will includes the chosen index
unknown's avatar
unknown committed
7543
    TRUE  error
7544 7545
*/

7546
bool setup_tables(THD *thd, Name_resolution_context *context,
unknown's avatar
unknown committed
7547
                  List<TABLE_LIST> *from_clause, TABLE_LIST *tables,
7548
                  TABLE_LIST **leaves, bool select_insert)
7549
{
unknown's avatar
unknown committed
7550
  uint tablenr= 0;
7551
  DBUG_ENTER("setup_tables");
7552

7553 7554
  DBUG_ASSERT ((select_insert && !tables->next_name_resolution_table) || !tables || 
               (context->table_list && context->first_name_resolution_table));
unknown's avatar
unknown committed
7555 7556
  /*
    this is used for INSERT ... SELECT.
7557
    For select we setup tables except first (and its underlying tables)
unknown's avatar
unknown committed
7558 7559 7560 7561
  */
  TABLE_LIST *first_select_table= (select_insert ?
                                   tables->next_local:
                                   0);
7562 7563 7564
  if (!(*leaves))
    make_leaves_list(leaves, tables);

unknown's avatar
unknown committed
7565 7566
  TABLE_LIST *table_list;
  for (table_list= *leaves;
unknown's avatar
VIEW  
unknown committed
7567
       table_list;
7568
       table_list= table_list->next_leaf, tablenr++)
unknown's avatar
unknown committed
7569
  {
unknown's avatar
unknown committed
7570
    TABLE *table= table_list->table;
unknown's avatar
unknown committed
7571
    table->pos_in_table_list= table_list;
unknown's avatar
unknown committed
7572
    if (first_select_table &&
7573
        table_list->top_table() == first_select_table)
unknown's avatar
unknown committed
7574 7575 7576 7577 7578
    {
      /* new counting for SELECT of INSERT ... SELECT command */
      first_select_table= 0;
      tablenr= 0;
    }
unknown's avatar
unknown committed
7579
    setup_table_map(table, table_list, tablenr);
7580 7581
    if (table_list->process_index_hints(table))
      DBUG_RETURN(1);
unknown's avatar
unknown committed
7582 7583 7584 7585
  }
  if (tablenr > MAX_TABLES)
  {
    my_error(ER_TOO_MANY_TABLES,MYF(0),MAX_TABLES);
7586
    DBUG_RETURN(1);
unknown's avatar
unknown committed
7587
  }
unknown's avatar
unknown committed
7588
  for (table_list= tables;
7589 7590
       table_list;
       table_list= table_list->next_local)
7591
  {
7592
    if (table_list->merge_underlying_list)
7593
    {
7594 7595
      DBUG_ASSERT(table_list->view &&
                  table_list->effective_algorithm == VIEW_ALGORITHM_MERGE);
unknown's avatar
unknown committed
7596
      Query_arena *arena= thd->stmt_arena, backup;
7597 7598 7599 7600
      bool res;
      if (arena->is_conventional())
        arena= 0;                                   // For easier test
      else
unknown's avatar
unknown committed
7601
        thd->set_n_backup_active_arena(arena, &backup);
7602
      res= table_list->setup_underlying(thd);
7603
      if (arena)
unknown's avatar
unknown committed
7604
        thd->restore_active_arena(arena, &backup);
7605 7606 7607
      if (res)
        DBUG_RETURN(1);
    }
7608
  }
unknown's avatar
unknown committed
7609 7610 7611 7612 7613

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

7614
  DBUG_RETURN(0);
unknown's avatar
unknown committed
7615
}
7616

unknown's avatar
unknown committed
7617

7618 7619 7620 7621 7622 7623 7624 7625 7626 7627 7628 7629 7630 7631 7632 7633 7634 7635 7636 7637 7638 7639 7640 7641 7642 7643 7644
/*
  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
7645
                                   TABLE_LIST **leaves,
7646
                                   bool select_insert,
7647
                                   ulong want_access_first,
7648 7649
                                   ulong want_access)
{
unknown's avatar
unknown committed
7650
  TABLE_LIST *leaves_tmp= NULL;
7651
  bool first_table= true;
7652

unknown's avatar
unknown committed
7653 7654
  if (setup_tables(thd, context, from_clause, tables,
                   &leaves_tmp, select_insert))
7655 7656
    return TRUE;

unknown's avatar
unknown committed
7657 7658
  if (leaves)
    *leaves= leaves_tmp;
7659 7660

  for (; leaves_tmp; leaves_tmp= leaves_tmp->next_leaf)
unknown's avatar
unknown committed
7661
  {
7662
    if (leaves_tmp->belong_to_view && 
7663
        check_single_table_access(thd, first_table ? want_access_first :
7664
                                  want_access, leaves_tmp, FALSE))
7665 7666 7667 7668
    {
      tables->hide_view_error(thd);
      return TRUE;
    }
7669
    first_table= 0;
unknown's avatar
unknown committed
7670
  }
7671 7672 7673 7674
  return FALSE;
}


7675 7676 7677 7678 7679 7680 7681 7682 7683 7684 7685 7686 7687 7688 7689
/*
   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,
7690
                               List<String> *index_list)
unknown's avatar
unknown committed
7691
{
unknown's avatar
unknown committed
7692
  List_iterator_fast<String> it(*index_list);
unknown's avatar
unknown committed
7693 7694
  String *name;
  uint pos;
7695 7696

  map->clear_all();
unknown's avatar
unknown committed
7697 7698
  while ((name=it++))
  {
7699 7700 7701
    if (table->s->keynames.type_names == 0 ||
        (pos= find_type(&table->s->keynames, name->ptr(),
                        name->length(), 1)) <=
7702
        0)
unknown's avatar
unknown committed
7703
    {
7704
      my_error(ER_KEY_DOES_NOT_EXITS, MYF(0), name->c_ptr(),
unknown's avatar
unknown committed
7705
	       table->pos_in_table_list->alias);
7706
      map->set_all();
7707
      return 1;
unknown's avatar
unknown committed
7708
    }
7709
    map->set_bit(pos-1);
unknown's avatar
unknown committed
7710
  }
7711
  return 0;
unknown's avatar
unknown committed
7712 7713
}

7714

7715 7716 7717 7718 7719 7720
/*
  Drops in all fields instead of current '*' field

  SYNOPSIS
    insert_fields()
    thd			Thread handler
7721
    context             Context for name resolution
7722 7723 7724 7725 7726 7727 7728
    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
7729
    0	ok     'it' is updated to point at last inserted
unknown's avatar
unknown committed
7730
    1	error.  Error message is generated but not sent to client
7731
*/
unknown's avatar
unknown committed
7732

unknown's avatar
unknown committed
7733
bool
7734
insert_fields(THD *thd, Name_resolution_context *context, const char *db_name,
unknown's avatar
VIEW  
unknown committed
7735
	      const char *table_name, List_iterator<Item> *it,
7736
              bool any_privileges)
unknown's avatar
unknown committed
7737
{
unknown's avatar
unknown committed
7738 7739
  Field_iterator_table_ref field_iterator;
  bool found;
unknown's avatar
unknown committed
7740
  char name_buff[NAME_LEN+1];
unknown's avatar
unknown committed
7741
  DBUG_ENTER("insert_fields");
unknown's avatar
unknown committed
7742
  DBUG_PRINT("arena", ("stmt arena: 0x%lx", (ulong)thd->stmt_arena));
unknown's avatar
unknown committed
7743

7744 7745
  if (db_name && lower_case_table_names)
  {
unknown's avatar
unknown committed
7746 7747 7748 7749 7750
    /*
      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
7751
    strmake(name_buff, db_name, sizeof(name_buff)-1);
unknown's avatar
unknown committed
7752
    my_casedn_str(files_charset_info, name_buff);
unknown's avatar
unknown committed
7753
    db_name= name_buff;
7754 7755
  }

unknown's avatar
unknown committed
7756
  found= FALSE;
7757 7758 7759 7760 7761 7762 7763 7764

  /*
    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);
7765
       tables;
7766 7767 7768
       tables= (table_name ? tables->next_local :
                tables->next_name_resolution_table)
       )
unknown's avatar
unknown committed
7769
  {
7770 7771 7772
    Field *field;
    TABLE *table= tables->table;

unknown's avatar
unknown committed
7773 7774
    DBUG_ASSERT(tables->is_leaf_for_name_resolution());

7775 7776
    if ((table_name && my_strcasecmp(table_alias_charset, table_name,
                                    tables->alias)) ||
7777 7778
        (db_name && strcmp(tables->db,db_name)))
      continue;
unknown's avatar
unknown committed
7779

unknown's avatar
unknown committed
7780
#ifndef NO_EMBEDDED_ACCESS_CHECKS
7781 7782 7783 7784 7785 7786 7787 7788 7789 7790 7791 7792 7793 7794 7795 7796 7797 7798 7799 7800 7801 7802 7803 7804 7805 7806
    /* 
       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.
    */
7807
    if (!((table && !tables->view && (table->grant.privilege & SELECT_ACL)) ||
Staale Smedseng's avatar
Staale Smedseng committed
7808
          (tables->view && (tables->grant.privilege & SELECT_ACL))) &&
unknown's avatar
unknown committed
7809 7810 7811
        !any_privileges)
    {
      field_iterator.set(tables);
7812
      if (check_grant_all_columns(thd, SELECT_ACL, &field_iterator))
unknown's avatar
unknown committed
7813 7814
        DBUG_RETURN(TRUE);
    }
unknown's avatar
unknown committed
7815
#endif
unknown's avatar
VIEW  
unknown committed
7816

unknown's avatar
unknown committed
7817 7818 7819 7820 7821 7822 7823 7824 7825 7826 7827 7828 7829 7830 7831 7832 7833 7834 7835 7836 7837
    /*
      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);
7838 7839 7840 7841
      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
7842 7843

      if (!found)
7844
      {
unknown's avatar
unknown committed
7845
        found= TRUE;
7846
        it->replace(item); /* Replace '*' with the first found item. */
7847
      }
unknown's avatar
VIEW  
unknown committed
7848
      else
unknown's avatar
unknown committed
7849 7850 7851 7852 7853 7854 7855
        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,
7856 7857 7858
        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
7859 7860
      */
      if (any_privileges)
7861
      {
7862
        DBUG_ASSERT((tables->field_translation == NULL && table) ||
unknown's avatar
unknown committed
7863 7864 7865
                    tables->is_natural_join);
        DBUG_ASSERT(item->type() == Item::FIELD_ITEM);
        Item_field *fld= (Item_field*) item;
7866
        const char *field_table_name= field_iterator.get_table_name();
7867

unknown's avatar
unknown committed
7868 7869 7870
        if (!tables->schema_table && 
            !(fld->have_privileges=
              (get_column_grant(thd, field_iterator.grant(),
7871
                                field_iterator.get_db_name(),
7872
                                field_table_name, fld->field_name) &
unknown's avatar
unknown committed
7873 7874
               VIEW_ANY_ACL)))
        {
7875
          my_error(ER_TABLEACCESS_DENIED_ERROR, MYF(0), "ANY",
7876 7877
                   thd->security_ctx->priv_user,
                   thd->security_ctx->host_or_ip,
7878
                   field_table_name);
unknown's avatar
unknown committed
7879 7880
          DBUG_RETURN(TRUE);
        }
7881
      }
unknown's avatar
unknown committed
7882
#endif
7883

unknown's avatar
unknown committed
7884
      if ((field= field_iterator.field()))
unknown's avatar
unknown committed
7885
      {
7886 7887
        /* 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
7888
        if (table)
7889
        {
7890
          table->covering_keys.intersect(field->part_of_key);
7891 7892
          table->merge_keys.merge(field->part_of_key);
        }
unknown's avatar
unknown committed
7893
        if (tables->is_natural_join)
unknown's avatar
unknown committed
7894
        {
unknown's avatar
unknown committed
7895 7896
          TABLE *field_table;
          /*
7897
            In this case we are sure that the column ref will not be created
unknown's avatar
unknown committed
7898
            because it was already created and stored with the natural join.
7899
          */
unknown's avatar
unknown committed
7900
          Natural_join_column *nj_col;
unknown's avatar
unknown committed
7901
          if (!(nj_col= field_iterator.get_natural_column_ref()))
unknown's avatar
unknown committed
7902
            DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7903
          DBUG_ASSERT(nj_col->table_field);
unknown's avatar
unknown committed
7904 7905
          field_table= nj_col->table_ref->table;
          if (field_table)
unknown's avatar
VIEW  
unknown committed
7906
          {
unknown's avatar
unknown committed
7907
            thd->used_tables|= field_table->map;
7908
            field_table->covering_keys.intersect(field->part_of_key);
7909
            field_table->merge_keys.merge(field->part_of_key);
unknown's avatar
unknown committed
7910
            field_table->used_fields++;
unknown's avatar
VIEW  
unknown committed
7911
          }
unknown's avatar
unknown committed
7912
        }
unknown's avatar
unknown committed
7913
      }
unknown's avatar
unknown committed
7914 7915
      else
        thd->used_tables|= item->used_tables();
7916
      thd->lex->current_select->cur_pos_in_select_list++;
unknown's avatar
unknown committed
7917
    }
unknown's avatar
unknown committed
7918 7919 7920 7921 7922 7923 7924 7925
    /*
      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
7926
  }
7927
  if (found)
unknown's avatar
unknown committed
7928
    DBUG_RETURN(FALSE);
7929

unknown's avatar
unknown committed
7930
  /*
7931 7932 7933
    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
7934
  */
7935
  if (!table_name)
unknown's avatar
unknown committed
7936
    my_message(ER_NO_TABLES_USED, ER(ER_NO_TABLES_USED), MYF(0));
7937 7938
  else
    my_error(ER_BAD_TABLE_ERROR, MYF(0), table_name);
unknown's avatar
unknown committed
7939 7940

  DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7941 7942 7943 7944
}


/*
unknown's avatar
unknown committed
7945
  Fix all conditions and outer join expressions.
7946 7947 7948 7949

  SYNOPSIS
    setup_conds()
    thd     thread handler
unknown's avatar
unknown committed
7950 7951 7952 7953 7954 7955 7956 7957 7958 7959
    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
7960 7961
*/

7962 7963
int setup_conds(THD *thd, TABLE_LIST *tables, TABLE_LIST *leaves,
                COND **conds)
unknown's avatar
unknown committed
7964
{
unknown's avatar
unknown committed
7965
  SELECT_LEX *select_lex= thd->lex->current_select;
unknown's avatar
unknown committed
7966
  TABLE_LIST *table= NULL;	// For HP compilers
7967 7968 7969 7970 7971 7972 7973 7974 7975 7976
  /*
    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();
7977 7978
  bool save_is_item_list_lookup= select_lex->is_item_list_lookup;
  select_lex->is_item_list_lookup= 0;
unknown's avatar
unknown committed
7979
  DBUG_ENTER("setup_conds");
unknown's avatar
unknown committed
7980

7981 7982
  thd->mark_used_columns= MARK_COLUMNS_READ;
  DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
unknown's avatar
unknown committed
7983
  select_lex->cond_count= 0;
7984
  select_lex->between_count= 0;
unknown's avatar
unknown committed
7985
  select_lex->max_equal_elems= 0;
unknown's avatar
VIEW  
unknown committed
7986

7987 7988 7989 7990 7991 7992
  for (table= tables; table; table= table->next_local)
  {
    if (table->prepare_where(thd, conds, FALSE))
      goto err_no_arena;
  }

unknown's avatar
unknown committed
7993 7994 7995
  if (*conds)
  {
    thd->where="where clause";
7996
    if ((!(*conds)->fixed && (*conds)->fix_fields(thd, conds)) ||
unknown's avatar
unknown committed
7997
	(*conds)->check_cols(1))
7998
      goto err_no_arena;
unknown's avatar
unknown committed
7999 8000
  }

unknown's avatar
unknown committed
8001 8002 8003 8004
  /*
    Apply fix_fields() to all ON clauses at all levels of nesting,
    including the ones inside view definitions.
  */
unknown's avatar
merge  
unknown committed
8005
  for (table= leaves; table; table= table->next_leaf)
unknown's avatar
unknown committed
8006
  {
unknown's avatar
unknown committed
8007 8008
    TABLE_LIST *embedded; /* The table at the current level of nesting. */
    TABLE_LIST *embedding= table; /* The parent nested table reference. */
8009
    do
unknown's avatar
VIEW  
unknown committed
8010
    {
8011 8012
      embedded= embedding;
      if (embedded->on_expr)
8013
      {
8014 8015
        /* Make a join an a expression */
        thd->where="on clause";
8016 8017
        if ((!embedded->on_expr->fixed &&
            embedded->on_expr->fix_fields(thd, &embedded->on_expr)) ||
8018
	    embedded->on_expr->check_cols(1))
8019
	  goto err_no_arena;
unknown's avatar
unknown committed
8020
        select_lex->cond_count++;
8021
      }
8022
      embedding= embedded->embedding;
unknown's avatar
unknown committed
8023
    }
8024 8025
    while (embedding &&
           embedding->nested_join->join_list.head() == embedded);
8026 8027 8028 8029

    /* process CHECK OPTION */
    if (it_is_update)
    {
unknown's avatar
unknown committed
8030
      TABLE_LIST *view= table->top_table();
8031 8032 8033 8034 8035 8036 8037
      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
8038
  }
unknown's avatar
unknown committed
8039

unknown's avatar
unknown committed
8040
  if (!thd->stmt_arena->is_conventional())
unknown's avatar
unknown committed
8041 8042 8043 8044 8045 8046 8047 8048 8049
  {
    /*
      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;
  }
8050
  thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
8051
  DBUG_RETURN(test(thd->is_error()));
unknown's avatar
unknown committed
8052

8053
err_no_arena:
8054
  select_lex->is_item_list_lookup= save_is_item_list_lookup;
unknown's avatar
unknown committed
8055
  DBUG_RETURN(1);
unknown's avatar
unknown committed
8056 8057 8058 8059 8060 8061 8062 8063
}


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

unknown's avatar
unknown committed
8064 8065 8066 8067 8068 8069 8070 8071 8072 8073 8074

/*
  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

8075 8076 8077 8078 8079
  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
8080 8081 8082 8083 8084
  RETURN
    FALSE   OK
    TRUE    error occured
*/

unknown's avatar
unknown committed
8085
static bool
unknown's avatar
unknown committed
8086 8087
fill_record(THD * thd, List<Item> &fields, List<Item> &values,
            bool ignore_errors)
unknown's avatar
unknown committed
8088
{
unknown's avatar
unknown committed
8089
  List_iterator_fast<Item> f(fields),v(values);
8090
  Item *value, *fld;
unknown's avatar
unknown committed
8091
  Item_field *field;
8092
  TABLE *table= 0;
unknown's avatar
unknown committed
8093 8094
  DBUG_ENTER("fill_record");

8095 8096 8097 8098 8099 8100 8101 8102 8103 8104 8105 8106 8107 8108 8109 8110 8111 8112 8113 8114
  /*
    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();
  }
8115
  while ((fld= f++))
unknown's avatar
unknown committed
8116
  {
8117 8118 8119
    if (!(field= fld->filed_for_view_update()))
    {
      my_error(ER_NONUPDATEABLE_COLUMN, MYF(0), fld->name);
8120
      goto err;
8121
    }
unknown's avatar
unknown committed
8122
    value=v++;
8123
    Field *rfield= field->field;
8124
    table= rfield->table;
unknown's avatar
unknown committed
8125
    if (rfield == table->next_number_field)
unknown's avatar
unknown committed
8126
      table->auto_increment_field_not_null= TRUE;
unknown's avatar
unknown committed
8127
    if ((value->save_in_field(rfield, 0) < 0) && !ignore_errors)
unknown's avatar
unknown committed
8128 8129
    {
      my_message(ER_UNKNOWN_ERROR, ER(ER_UNKNOWN_ERROR), MYF(0));
8130
      goto err;
unknown's avatar
unknown committed
8131
    }
unknown's avatar
unknown committed
8132
  }
8133
  DBUG_RETURN(thd->is_error());
8134 8135 8136 8137
err:
  if (table)
    table->auto_increment_field_not_null= FALSE;
  DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
8138 8139 8140
}


unknown's avatar
unknown committed
8141 8142 8143 8144 8145 8146 8147 8148 8149 8150 8151 8152 8153 8154 8155 8156 8157 8158 8159 8160 8161 8162 8163 8164 8165 8166 8167 8168 8169 8170
/*
  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) ||
8171 8172
          (triggers && triggers->process_triggers(thd, event,
                                                 TRG_ACTION_BEFORE, TRUE)));
unknown's avatar
unknown committed
8173 8174 8175
}


unknown's avatar
unknown committed
8176 8177 8178 8179 8180 8181 8182 8183 8184 8185
/*
  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

8186 8187 8188 8189 8190
  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
8191 8192 8193 8194 8195 8196 8197
  RETURN
    FALSE   OK
    TRUE    error occured
*/

bool
fill_record(THD *thd, Field **ptr, List<Item> &values, bool ignore_errors)
unknown's avatar
unknown committed
8198
{
unknown's avatar
unknown committed
8199
  List_iterator_fast<Item> v(values);
unknown's avatar
unknown committed
8200
  Item *value;
8201
  TABLE *table= 0;
unknown's avatar
unknown committed
8202 8203 8204
  DBUG_ENTER("fill_record");

  Field *field;
8205 8206 8207 8208 8209 8210 8211 8212 8213 8214 8215 8216 8217
  /*
    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;
  }
8218
  while ((field = *ptr++) && ! thd->is_error())
unknown's avatar
unknown committed
8219 8220
  {
    value=v++;
8221
    table= field->table;
unknown's avatar
unknown committed
8222
    if (field == table->next_number_field)
unknown's avatar
unknown committed
8223
      table->auto_increment_field_not_null= TRUE;
8224
    if (value->save_in_field(field, 0) < 0)
8225
      goto err;
unknown's avatar
unknown committed
8226
  }
8227
  DBUG_RETURN(thd->is_error());
8228 8229 8230 8231 8232

err:
  if (table)
    table->auto_increment_field_not_null= FALSE;
  DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
8233 8234 8235
}


unknown's avatar
unknown committed
8236 8237 8238 8239 8240 8241 8242 8243 8244 8245 8246 8247 8248 8249 8250 8251 8252 8253 8254 8255 8256 8257 8258 8259 8260 8261 8262 8263 8264 8265
/*
  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) ||
8266 8267
          (triggers && triggers->process_triggers(thd, event,
                                                 TRG_ACTION_BEFORE, TRUE)));
unknown's avatar
unknown committed
8268 8269 8270
}


8271
my_bool mysql_rm_tmp_tables(void)
unknown's avatar
unknown committed
8272
{
unknown's avatar
unknown committed
8273
  uint i, idx;
8274
  char	filePath[FN_REFLEN], *tmpdir, filePathCopy[FN_REFLEN];
unknown's avatar
unknown committed
8275 8276
  MY_DIR *dirp;
  FILEINFO *file;
unknown's avatar
unknown committed
8277
  TABLE_SHARE share;
8278
  THD *thd;
unknown's avatar
unknown committed
8279 8280
  DBUG_ENTER("mysql_rm_tmp_tables");

8281 8282
  if (!(thd= new THD))
    DBUG_RETURN(1);
unknown's avatar
unknown committed
8283
  thd->thread_stack= (char*) &thd;
8284 8285
  thd->store_globals();

unknown's avatar
unknown committed
8286 8287 8288
  for (i=0; i<=mysql_tmpdir_list.max; i++)
  {
    tmpdir=mysql_tmpdir_list.list[i];
unknown's avatar
unknown committed
8289
    /* See if the directory exists */
unknown's avatar
unknown committed
8290 8291
    if (!(dirp = my_dir(tmpdir,MYF(MY_WME | MY_DONT_SORT))))
      continue;
unknown's avatar
unknown committed
8292

unknown's avatar
unknown committed
8293
    /* Remove all SQLxxx tables from directory */
unknown's avatar
unknown committed
8294

unknown's avatar
unknown committed
8295 8296 8297
    for (idx=0 ; idx < (uint) dirp->number_off_files ; idx++)
    {
      file=dirp->dir_entry+idx;
unknown's avatar
unknown committed
8298

unknown's avatar
unknown committed
8299 8300 8301 8302
      /* skiping . and .. */
      if (file->name[0] == '.' && (!file->name[1] ||
                                   (file->name[1] == '.' &&  !file->name[2])))
        continue;
unknown's avatar
unknown committed
8303

8304 8305
      if (!bcmp((uchar*) file->name, (uchar*) tmp_file_prefix,
                tmp_file_prefix_length))
unknown's avatar
unknown committed
8306
      {
unknown's avatar
unknown committed
8307 8308 8309 8310 8311
        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);
8312
        if (!bcmp((uchar*) reg_ext, (uchar*) ext, ext_len))
8313
        {
unknown's avatar
unknown committed
8314 8315 8316 8317
          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;
8318
          init_tmp_table_share(thd, &share, "", 0, "", filePathCopy);
unknown's avatar
unknown committed
8319 8320
          if (!open_table_def(thd, &share, 0) &&
              ((handler_file= get_new_handler(&share, thd->mem_root,
unknown's avatar
unknown committed
8321
                                              share.db_type()))))
unknown's avatar
unknown committed
8322
          {
8323
            handler_file->ha_delete_table(filePathCopy);
unknown's avatar
unknown committed
8324 8325 8326
            delete handler_file;
          }
          free_table_share(&share);
8327
        }
unknown's avatar
unknown committed
8328 8329 8330 8331 8332
        /*
          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)).
        */
Marc Alff's avatar
Marc Alff committed
8333
        (void) mysql_file_delete(key_file_misc, filePath, MYF(0));
unknown's avatar
unknown committed
8334
      }
unknown's avatar
unknown committed
8335
    }
unknown's avatar
unknown committed
8336
    my_dirend(dirp);
unknown's avatar
unknown committed
8337
  }
8338 8339 8340
  delete thd;
  my_pthread_setspecific_ptr(THR_THD,  0);
  DBUG_RETURN(0);
unknown's avatar
unknown committed
8341 8342 8343 8344 8345 8346 8347 8348 8349
}



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

/*
unknown's avatar
unknown committed
8350 8351 8352 8353 8354
  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
8355 8356 8357 8358
*/

void flush_tables()
{
Marc Alff's avatar
Marc Alff committed
8359
  mysql_mutex_lock(&LOCK_open);
unknown's avatar
unknown committed
8360
  while (unused_tables)
8361
    free_cache_entry(unused_tables);
8362
  (void) mysql_mutex_unlock(&LOCK_open);
unknown's avatar
unknown committed
8363 8364 8365
}


8366 8367 8368 8369 8370 8371 8372 8373 8374 8375 8376 8377 8378 8379 8380 8381 8382
/**
   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
8383 8384 8385
   @param needs_thr_lock_abort Indicates that to wake up thread
                               this call needs to abort its waiting
                               on table-level lock.
8386 8387

   @retval  TRUE  if the thread was woken up
8388
   @retval  FALSE otherwise.
8389 8390 8391 8392 8393

   @note It is one of two places where border between MDL and the
         rest of the server is broken.
*/

8394 8395
bool mysql_notify_thread_having_shared_lock(THD *thd, THD *in_use,
                                            bool needs_thr_lock_abort)
8396 8397 8398 8399 8400 8401
{
  bool signalled= FALSE;
  if ((in_use->system_thread & SYSTEM_THREAD_DELAYED_INSERT) &&
      !in_use->killed)
  {
    in_use->killed= THD::KILL_CONNECTION;
8402
    mysql_mutex_lock(&in_use->mysys_var->mutex);
8403
    if (in_use->mysys_var->current_cond)
8404 8405
      mysql_cond_broadcast(in_use->mysys_var->current_cond);
    mysql_mutex_unlock(&in_use->mysys_var->mutex);
8406 8407
    signalled= TRUE;
  }
8408
  mysql_mutex_lock(&LOCK_open);
8409 8410

  if (needs_thr_lock_abort)
8411
  {
8412 8413 8414 8415 8416 8417 8418 8419 8420 8421 8422 8423 8424 8425
    for (TABLE *thd_table= in_use->open_tables;
         thd_table ;
         thd_table= thd_table->next)
    {
      /*
        Check for TABLE::needs_reopen() 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).
        */
      if (!thd_table->needs_reopen())
        signalled|= mysql_lock_abort_for_thread(thd, thd_table);
    }
8426
  }
8427 8428 8429 8430 8431 8432 8433
  /*
    Wake up threads waiting in tdc_wait_for_old_versions().
    Normally such threads would already get blocked
    in MDL subsystem, when trying to acquire a shared lock.
    But in case a thread has an open HANDLER statement,
    (and thus already grabbed a metadata lock), it gets
    blocked only too late -- at the table cache level.
8434 8435
    Starting from 5.5, this could also easily happen in
    a multi-statement transaction.
8436 8437
  */
  broadcast_refresh();
8438
  mysql_mutex_unlock(&LOCK_open);
8439 8440 8441 8442 8443
  return signalled;
}


/**
Konstantin Osipov's avatar
Konstantin Osipov committed
8444 8445 8446 8447 8448 8449 8450 8451 8452 8453 8454 8455 8456 8457 8458 8459 8460 8461 8462 8463 8464 8465 8466
   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
8467 8468 8469 8470 8471 8472

   @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
8473 8474
void tdc_remove_table(THD *thd, enum_tdc_remove_table_type remove_type,
                      const char *db, const char *table_name)
8475 8476 8477 8478 8479 8480
{
  char key[MAX_DBKEY_LENGTH];
  uint key_length;
  TABLE *table;
  TABLE_SHARE *share;

8481
  mysql_mutex_assert_owner(&LOCK_open);
8482

Konstantin Osipov's avatar
Konstantin Osipov committed
8483
  DBUG_ASSERT(remove_type == TDC_RT_REMOVE_UNUSED ||
8484 8485
              thd->mdl_context.is_lock_owner(MDL_key::TABLE, db, table_name,
                                             MDL_EXCLUSIVE));
8486

Konstantin Osipov's avatar
Konstantin Osipov committed
8487
  key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
8488 8489 8490 8491

  if ((share= (TABLE_SHARE*) my_hash_search(&table_def_cache,(uchar*) key,
                                            key_length)))
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
8492 8493 8494 8495 8496 8497 8498 8499 8500 8501 8502 8503 8504 8505 8506 8507 8508 8509 8510 8511 8512 8513 8514 8515 8516 8517 8518 8519
    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);
8520 8521 8522 8523 8524 8525 8526 8527 8528 8529 8530 8531
  }
}


/**
   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
8532 8533
static bool
tdc_wait_for_old_versions(THD *thd, MDL_request_list *mdl_requests)
8534 8535 8536
{
  TABLE_SHARE *share;
  const char *old_msg;
Konstantin Osipov's avatar
Konstantin Osipov committed
8537
  MDL_request *mdl_request;
8538 8539 8540
  struct timespec abstime;
  set_timespec(abstime, thd->variables.lock_wait_timeout);
  int wait_result= 0;
8541 8542 8543 8544 8545 8546 8547 8548 8549 8550

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

8552
    mysql_mutex_lock(&LOCK_open);
8553

Konstantin Osipov's avatar
Konstantin Osipov committed
8554
    MDL_request_list::Iterator it(*mdl_requests);
Konstantin Osipov's avatar
Konstantin Osipov committed
8555
    while ((mdl_request= it++))
8556
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
8557 8558 8559 8560
      /* Skip requests on non-TDC objects. */
      if (mdl_request->key.mdl_namespace() != MDL_key::TABLE)
        continue;

Konstantin Osipov's avatar
Konstantin Osipov committed
8561
      if ((share= get_cached_table_share(mdl_request->key.db_name(),
Konstantin Osipov's avatar
Konstantin Osipov committed
8562
                                         mdl_request->key.name())) &&
Konstantin Osipov's avatar
Konstantin Osipov committed
8563
          share->version != refresh_version)
8564 8565
        break;
    }
Konstantin Osipov's avatar
Konstantin Osipov committed
8566
    if (!mdl_request)
8567
    {
8568 8569 8570 8571 8572 8573 8574 8575 8576 8577 8578 8579 8580 8581 8582
      /*
        Reset wait_result here in case this was the final check
        after getting a timeout from mysql_cond_timedwait().
      */
      wait_result= 0;
      mysql_mutex_unlock(&LOCK_open);
      break;
    }
    if (wait_result == ETIMEDOUT || wait_result == ETIME)
    {
      /*
        Test for timeout here instead of right after mysql_cond_timedwait().
        This allows for a final iteration and a final check before reporting
        ER_LOCK_WAIT_TIMEOUT.
      */
8583
      mysql_mutex_unlock(&LOCK_open);
8584
      my_error(ER_LOCK_WAIT_TIMEOUT, MYF(0));
8585 8586 8587
      break;
    }
    old_msg= thd->enter_cond(&COND_refresh, &LOCK_open, "Waiting for table");
8588
    wait_result= mysql_cond_timedwait(&COND_refresh, &LOCK_open, &abstime);
8589 8590 8591
    /* LOCK_open mutex is unlocked by THD::exit_cond() as side-effect. */
    thd->exit_cond(old_msg);
  }
8592
  return thd->killed || wait_result == ETIMEDOUT || wait_result == ETIME;
8593 8594 8595
}


8596
int setup_ftfuncs(SELECT_LEX *select_lex)
unknown's avatar
unknown committed
8597
{
8598 8599
  List_iterator<Item_func_match> li(*(select_lex->ftfunc_list)),
                                 lj(*(select_lex->ftfunc_list));
8600
  Item_func_match *ftf, *ftf2;
unknown's avatar
unknown committed
8601 8602

  while ((ftf=li++))
8603
  {
unknown's avatar
unknown committed
8604 8605
    if (ftf->fix_index())
      return 1;
8606 8607
    lj.rewind();
    while ((ftf2=lj++) != ftf)
8608
    {
8609
      if (ftf->eq(ftf2,1) && !ftf2->master)
8610 8611 8612
        ftf2->master=ftf;
    }
  }
unknown's avatar
unknown committed
8613 8614 8615

  return 0;
}
8616

8617

8618
int init_ftfuncs(THD *thd, SELECT_LEX *select_lex, bool no_order)
8619
{
8620
  if (select_lex->ftfunc_list->elements)
8621
  {
8622
    List_iterator<Item_func_match> li(*(select_lex->ftfunc_list));
unknown's avatar
unknown committed
8623 8624
    Item_func_match *ifm;
    DBUG_PRINT("info",("Performing FULLTEXT search"));
8625
    thd_proc_info(thd, "FULLTEXT initialization");
8626

unknown's avatar
unknown committed
8627 8628 8629
    while ((ifm=li++))
      ifm->init_search(no_order);
  }
8630 8631
  return 0;
}
unknown's avatar
VIEW  
unknown committed
8632 8633 8634 8635 8636 8637 8638


/*
  open new .frm format table

  SYNOPSIS
    open_new_frm()
8639
    THD		  thread handler
unknown's avatar
unknown committed
8640
    path	  path to .frm file (without extension)
unknown's avatar
VIEW  
unknown committed
8641
    alias	  alias for table
8642 8643
    db            database
    table_name    name of table
8644
    db_stat	  open flags (for example ->OPEN_KEYFILE|HA_OPEN_RNDFILE..)
unknown's avatar
VIEW  
unknown committed
8645 8646 8647 8648 8649 8650 8651
		  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
*/
8652

Sergey Glukhov's avatar
Sergey Glukhov committed
8653
bool
unknown's avatar
unknown committed
8654
open_new_frm(THD *thd, TABLE_SHARE *share, const char *alias,
8655
             uint db_stat, uint prgflag,
unknown's avatar
VIEW  
unknown committed
8656 8657 8658 8659
	     uint ha_open_flags, TABLE *outparam, TABLE_LIST *table_desc,
	     MEM_ROOT *mem_root)
{
  LEX_STRING pathstr;
8660
  File_parser *parser;
unknown's avatar
unknown committed
8661
  char path[FN_REFLEN];
8662 8663
  DBUG_ENTER("open_new_frm");

unknown's avatar
unknown committed
8664 8665 8666 8667
  /* Create path with extension */
  pathstr.length= (uint) (strxmov(path, share->normalized_path.str, reg_ext,
                                  NullS)- path);
  pathstr.str=    path;
8668

8669
  if ((parser= sql_parse_prepare(&pathstr, mem_root, 1)))
unknown's avatar
VIEW  
unknown committed
8670
  {
8671
    if (is_equal(&view_type, parser->type()))
unknown's avatar
VIEW  
unknown committed
8672
    {
8673
      if (table_desc == 0 || table_desc->required_type == FRMTYPE_TABLE)
unknown's avatar
VIEW  
unknown committed
8674
      {
unknown's avatar
unknown committed
8675 8676
        my_error(ER_WRONG_OBJECT, MYF(0), share->db.str, share->table_name.str,
                 "BASE TABLE");
8677
        goto err;
unknown's avatar
VIEW  
unknown committed
8678
      }
8679 8680
      if (mysql_make_view(thd, parser, table_desc,
                          (prgflag & OPEN_VIEW_NO_PARSE)))
8681
        goto err;
unknown's avatar
VIEW  
unknown committed
8682 8683 8684 8685
    }
    else
    {
      /* only VIEWs are supported now */
8686
      my_error(ER_FRM_UNKNOWN_TYPE, MYF(0), share->path.str,  parser->type()->str);
8687
      goto err;
unknown's avatar
VIEW  
unknown committed
8688
    }
8689
    DBUG_RETURN(0);
unknown's avatar
VIEW  
unknown committed
8690
  }
unknown's avatar
unknown committed
8691
 
8692 8693
err:
  DBUG_RETURN(1);
unknown's avatar
VIEW  
unknown committed
8694
}
8695 8696 8697 8698 8699 8700


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
8701 8702 8703 8704 8705 8706 8707


/*
  SYNOPSIS
    abort_and_upgrade_lock()
    lpt                           Parameter passing struct
    All parameters passed through the ALTER_PARTITION_PARAM_TYPE object
8708 8709
  RETURN VALUE
    0
unknown's avatar
unknown committed
8710 8711 8712 8713 8714 8715 8716 8717 8718 8719 8720 8721 8722
  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
*/

8723
int abort_and_upgrade_lock(ALTER_PARTITION_PARAM_TYPE *lpt)
unknown's avatar
unknown committed
8724
{
Konstantin Osipov's avatar
Konstantin Osipov committed
8725 8726 8727
  DBUG_ENTER("abort_and_upgrade_lock");

  if (wait_while_table_is_used(lpt->thd, lpt->table, HA_EXTRA_FORCE_REOPEN))
8728
    DBUG_RETURN(1);
8729
  DBUG_RETURN(0);
unknown's avatar
unknown committed
8730 8731 8732 8733
}


/*
8734 8735
  Tells if two (or more) tables have auto_increment columns and we want to
  lock those tables with a write lock.
8736

8737 8738 8739
  SYNOPSIS
    has_two_write_locked_tables_with_auto_increment
      tables        Table list
unknown's avatar
unknown committed
8740 8741 8742 8743 8744 8745 8746 8747

  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
8748
has_write_table_with_auto_increment(TABLE_LIST *tables)
unknown's avatar
unknown committed
8749 8750 8751 8752
{
  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
8753
    if (!table->placeholder() &&
unknown's avatar
unknown committed
8754 8755
        table->table->found_next_number_field &&
        (table->lock_type >= TL_WRITE_ALLOW_WRITE))
8756
      return 1;
unknown's avatar
unknown committed
8757
  }
8758

unknown's avatar
unknown committed
8759 8760
  return 0;
}
8761 8762 8763 8764 8765 8766 8767 8768 8769 8770 8771 8772 8773 8774 8775 8776 8777 8778 8779 8780 8781 8782 8783 8784 8785 8786 8787 8788


/*
  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,
8789
                            Open_tables_backup *backup)
8790
{
Konstantin Osipov's avatar
Konstantin Osipov committed
8791 8792 8793
  Query_tables_list query_tables_list_backup;
  LEX *lex= thd->lex;

8794 8795
  DBUG_ENTER("open_system_tables_for_read");

Konstantin Osipov's avatar
Konstantin Osipov committed
8796 8797 8798 8799 8800 8801 8802 8803
  /*
    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);
8804 8805
  thd->reset_n_backup_open_tables_state(backup);

Konstantin Osipov's avatar
Konstantin Osipov committed
8806 8807
  if (open_and_lock_tables_derived(thd, table_list, FALSE,
                                   MYSQL_LOCK_IGNORE_FLUSH))
8808
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
8809 8810
    lex->restore_backup_query_tables_list(&query_tables_list_backup);
    goto error;
8811 8812
  }

Konstantin Osipov's avatar
Konstantin Osipov committed
8813
  for (TABLE_LIST *tables= table_list; tables; tables= tables->next_global)
8814
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
8815 8816
    DBUG_ASSERT(tables->table->s->table_category == TABLE_CATEGORY_SYSTEM);
    tables->table->use_all_columns();
8817
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
8818 8819 8820
  lex->restore_backup_query_tables_list(&query_tables_list_backup);

  DBUG_RETURN(FALSE);
8821 8822 8823 8824 8825 8826 8827 8828 8829 8830 8831 8832 8833 8834

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
8835
      backup  Pointer to Open_tables_backup instance which holds
8836 8837 8838 8839 8840
              information about tables which were open before we
              decided to access system tables.
*/

void
8841
close_system_tables(THD *thd, Open_tables_backup *backup)
8842 8843 8844 8845 8846 8847 8848 8849 8850 8851 8852 8853 8854 8855 8856 8857 8858 8859 8860 8861 8862 8863 8864 8865 8866 8867 8868
{
  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");

8869
  TABLE *table= open_ltable(thd, one_table, one_table->lock_type, 0);
8870 8871
  if (table)
  {
8872
    DBUG_ASSERT(table->s->table_category == TABLE_CATEGORY_SYSTEM);
8873 8874 8875 8876 8877
    table->use_all_columns();
  }

  DBUG_RETURN(table);
}
8878 8879

/**
Marc Alff's avatar
Marc Alff committed
8880
  Open a log table.
8881 8882 8883 8884
  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
Marc Alff's avatar
Marc Alff committed
8885
  when calling close_log_table().
8886
  @param thd The current thread
Marc Alff's avatar
Marc Alff committed
8887
  @param one_table Log table to open
8888 8889 8890
  @param backup [out] Temporary storage used to save the thread context
*/
TABLE *
8891
open_log_table(THD *thd, TABLE_LIST *one_table, Open_tables_backup *backup)
8892
{
8893 8894 8895 8896 8897 8898 8899
  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;
Marc Alff's avatar
Marc Alff committed
8900
  DBUG_ENTER("open_log_table");
8901 8902 8903

  thd->reset_n_backup_open_tables_state(backup);

8904
  if ((table= open_ltable(thd, one_table, one_table->lock_type, flags)))
8905
  {
Marc Alff's avatar
Marc Alff committed
8906
    DBUG_ASSERT(table->s->table_category == TABLE_CATEGORY_LOG);
8907
    /* Make sure all columns get assigned to a default value */
8908
    table->use_all_columns();
8909
    table->no_replicate= 1;
8910 8911 8912 8913 8914
    /*
      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;
8915
  }
8916
  else
8917 8918 8919 8920 8921 8922 8923 8924 8925
  {
    /*
      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);
8926
    thd->restore_backup_open_tables_state(backup);
8927
  }
8928

8929
  thd->utime_after_lock= save_utime_after_lock;
8930 8931
  DBUG_RETURN(table);
}
8932 8933

/**
Marc Alff's avatar
Marc Alff committed
8934 8935
  Close a log table.
  The last table opened by open_log_table()
8936 8937 8938 8939
  is closed, then the thread context is restored.
  @param thd The current thread
  @param backup [in] the context to restore.
*/
8940
void close_log_table(THD *thd, Open_tables_backup *backup)
8941
{
8942
  close_system_tables(thd, backup);
8943 8944
}

8945 8946 8947
/**
  @} (end of group Data_Dictionary)
*/