sql_base.cc 283 KB
Newer Older
1
/* Copyright (C) 2000-2006 MySQL AB
2

bk@work.mysql.com's avatar
bk@work.mysql.com 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
5
   the Free Software Foundation; version 2 of the License.
6

bk@work.mysql.com's avatar
bk@work.mysql.com 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

bk@work.mysql.com's avatar
bk@work.mysql.com 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 */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
18 19

#include "mysql_priv.h"
20
#include "sql_select.h"
21
#include "sp_head.h"
22
#include "sp.h"
23
#include "sql_trigger.h"
bk@work.mysql.com's avatar
bk@work.mysql.com committed
24 25 26
#include <m_ctype.h>
#include <my_dir.h>
#include <hash.h>
27
#ifdef  __WIN__
bk@work.mysql.com's avatar
bk@work.mysql.com committed
28 29 30
#include <io.h>
#endif

31 32
#define FLAGSTR(S,F) ((S) & (F) ? #F " " : "")

33 34 35 36 37 38 39 40 41 42 43 44 45 46
/**
  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() {}

47
  virtual bool handle_error(uint sql_errno, const char *message,
48 49 50 51 52 53 54 55 56 57 58 59 60
                            MYSQL_ERROR::enum_warning_level level,
                            THD *thd);

  bool safely_trapped_errors();

private:
  int m_handled_errors;
  int m_unhandled_errors;
};


bool
Prelock_error_handler::handle_error(uint sql_errno,
61
                                    const char * /* message */,
62 63 64 65 66 67
                                    MYSQL_ERROR::enum_warning_level /* level */,
                                    THD * /* thd */)
{
  if (sql_errno == ER_NO_SUCH_TABLE)
  {
    m_handled_errors++;
68
    return TRUE;
69 70 71
  }

  m_unhandled_errors++;
72
  return FALSE;
73 74 75 76 77 78 79 80 81 82 83 84 85
}


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

86 87 88 89
/**
  @defgroup Data_Dictionary Data Dictionary
  @{
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
90 91
TABLE *unused_tables;				/* Used by mysql_test */
HASH open_cache;				/* Used by mysql_test */
92 93 94 95 96 97 98
static HASH table_def_cache;
static TABLE_SHARE *oldest_unused_share, end_of_unused_share;
static pthread_mutex_t LOCK_table_share;
static bool table_def_inited= 0;

static int open_unireg_entry(THD *thd, TABLE *entry, TABLE_LIST *table_list,
			     const char *alias,
99
                             char *cache_key, uint cache_key_length,
100
			     MEM_ROOT *mem_root, uint flags);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
101
static void free_cache_entry(TABLE *entry);
102
static bool open_new_frm(THD *thd, TABLE_SHARE *share, const char *alias,
103 104 105
                         uint db_stat, uint prgflag,
                         uint ha_open_flags, TABLE *outparam,
                         TABLE_LIST *table_desc, MEM_ROOT *mem_root);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
106
static void close_old_data_files(THD *thd, TABLE *table, bool morph_locks,
107
                                 bool send_refresh);
108 109
static bool
has_two_write_locked_tables_with_auto_increment(TABLE_LIST *tables);
110

bk@work.mysql.com's avatar
bk@work.mysql.com committed
111

112
extern "C" uchar *table_cache_key(const uchar *record, size_t *length,
113
				 my_bool not_used __attribute__((unused)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
114 115
{
  TABLE *entry=(TABLE*) record;
116
  *length= entry->s->table_cache_key.length;
117
  return (uchar*) entry->s->table_cache_key.str;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
118 119
}

120

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
121
bool table_cache_init(void)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
122
{
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
123
  return hash_init(&open_cache, &my_charset_bin, table_cache_size+16,
124
		   0, 0, table_cache_key,
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
125
		   (hash_free_key) free_cache_entry, 0) != 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
126 127 128 129 130
}

void table_cache_free(void)
{
  DBUG_ENTER("table_cache_free");
131 132
  if (table_def_inited)
  {
133
    close_cached_tables(NULL, NULL, FALSE, FALSE, FALSE);
134 135 136
    if (!open_cache.records)			// Safety first
      hash_free(&open_cache);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
137 138 139
  DBUG_VOID_RETURN;
}

140
uint cached_open_tables(void)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
141 142 143 144
{
  return open_cache.records;
}

145

bk@work.mysql.com's avatar
bk@work.mysql.com committed
146 147 148
#ifdef EXTRA_DEBUG
static void check_unused(void)
{
149
  uint count= 0, open_files= 0, idx= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172
  TABLE *cur_link,*start_link;

  if ((start_link=cur_link=unused_tables))
  {
    do
    {
      if (cur_link != cur_link->next->prev || cur_link != cur_link->prev->next)
      {
	DBUG_PRINT("error",("Unused_links aren't linked properly")); /* purecov: inspected */
	return; /* purecov: inspected */
      }
    } while (count++ < open_cache.records &&
	     (cur_link=cur_link->next) != start_link);
    if (cur_link != start_link)
    {
      DBUG_PRINT("error",("Unused_links aren't connected")); /* purecov: inspected */
    }
  }
  for (idx=0 ; idx < open_cache.records ; idx++)
  {
    TABLE *entry=(TABLE*) hash_element(&open_cache,idx);
    if (!entry->in_use)
      count--;
173 174
    if (entry->file)
      open_files++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
175 176 177
  }
  if (count != 0)
  {
178
    DBUG_PRINT("error",("Unused_links doesn't match open_cache: diff: %d", /* purecov: inspected */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
179 180
			count)); /* purecov: inspected */
  }
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199

#ifdef NOT_SAFE_FOR_REPAIR
  /*
    check that open cache and table definition cache has same number of
    aktive tables
  */
  count= 0;
  for (idx=0 ; idx < table_def_cache.records ; idx++)
  {
    TABLE_SHARE *entry= (TABLE_SHARE*) hash_element(&table_def_cache,idx);
    count+= entry->ref_count;
  }
  if (count != open_files)
  {
    DBUG_PRINT("error", ("table_def ref_count: %u  open_cache: %u",
                         count, open_files));
    DBUG_ASSERT(count == open_files);
  }
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
200 201 202 203 204
}
#else
#define check_unused()
#endif

205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230

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

231
uint create_table_def_key(THD *thd, char *key, TABLE_LIST *table_list,
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250
                          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)
*****************************************************************************/

251
extern "C" uchar *table_def_key(const uchar *record, size_t *length,
252 253 254 255
                               my_bool not_used __attribute__((unused)))
{
  TABLE_SHARE *entry=(TABLE_SHARE*) record;
  *length= entry->table_cache_key.length;
256
  return (uchar*) entry->table_cache_key.str;
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
}


static void table_def_free_entry(TABLE_SHARE *share)
{
  DBUG_ENTER("table_def_free_entry");
  if (share->prev)
  {
    /* remove from old_unused_share list */
    pthread_mutex_lock(&LOCK_table_share);
    *share->prev= share->next;
    share->next->prev= share->prev;
    pthread_mutex_unlock(&LOCK_table_share);
  }
  free_table_share(share);
  DBUG_VOID_RETURN;
}


bool table_def_init(void)
{
  table_def_inited= 1;
  pthread_mutex_init(&LOCK_table_share, MY_MUTEX_INIT_FAST);
  oldest_unused_share= &end_of_unused_share;
  end_of_unused_share.prev= &oldest_unused_share;

  return hash_init(&table_def_cache, &my_charset_bin, table_def_size,
		   0, 0, table_def_key,
		   (hash_free_key) table_def_free_entry, 0) != 0;
}


void table_def_free(void)
{
  DBUG_ENTER("table_def_free");
  if (table_def_inited)
  {
    table_def_inited= 0;
    pthread_mutex_destroy(&LOCK_table_share);
    hash_free(&table_def_cache);
  }
  DBUG_VOID_RETURN;
}


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


/*
  Get TABLE_SHARE for a table.

  get_table_share()
312
  thd			Thread handle
313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
  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
*/

333
TABLE_SHARE *get_table_share(THD *thd, TABLE_LIST *table_list, char *key,
334 335 336 337 338 339 340 341
                             uint key_length, uint db_flags, int *error)
{
  TABLE_SHARE *share;
  DBUG_ENTER("get_table_share");

  *error= 0;

  /* Read table definition from cache */
342
  if ((share= (TABLE_SHARE*) hash_search(&table_def_cache,(uchar*) key,
343 344 345 346 347 348 349 350 351 352 353 354 355
                                         key_length)))
    goto found;

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

  /*
    Lock mutex to be able to read table definition from file without
    conflicts
  */
  (void) pthread_mutex_lock(&share->mutex);
356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371

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

372
  if (my_hash_insert(&table_def_cache, (uchar*) share))
373 374 375 376 377 378 379
  {
    free_table_share(share);
    DBUG_RETURN(0);				// return error
  }
  if (open_table_def(thd, share, db_flags))
  {
    *error= share->error;
380
    (void) hash_delete(&table_def_cache, (uchar*) share);
381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431
    DBUG_RETURN(0);
  }
  share->ref_count++;				// Mark in use
  DBUG_PRINT("exit", ("share: 0x%lx  ref_count: %u",
                      (ulong) share, share->ref_count));
  (void) pthread_mutex_unlock(&share->mutex);
  DBUG_RETURN(share);

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

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

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

   /* Free cache if too big */
  while (table_def_cache.records > table_def_size &&
         oldest_unused_share->next)
  {
    pthread_mutex_lock(&oldest_unused_share->mutex);
432
    VOID(hash_delete(&table_def_cache, (uchar*) oldest_unused_share));
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448
  }

  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,
449
                             char *key, uint key_length,
450 451 452 453 454 455
                             uint db_flags, int *error)
{
  TABLE_SHARE *share;
  int tmp;
  DBUG_ENTER("get_table_share_with_create");

456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477
  share= get_table_share(thd, table_list, key, key_length, db_flags, error);
  /*
    If share is not NULL, we found an existing share.

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

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

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

    @todo Rework alternative ways to deal with ER_NO_SUCH TABLE.
  */
  if (share || thd->is_error() && thd->main_da.sql_errno() != ER_NO_SUCH_TABLE)

478 479 480 481 482 483 484 485
    DBUG_RETURN(share);

  /* Table didn't exist. Check if some engine can provide it */
  if ((tmp= ha_create_table_from_engine(thd, table_list->db,
                                        table_list->table_name)) < 0)
  {
    /*
      No such table in any engine.
486 487 488 489 490
      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.
491
    */
492
    if (thd->is_error() && table_list->belong_to_view)
493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 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 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577
    {
      TABLE_LIST *view= table_list->belong_to_view;
      thd->clear_error();
      my_error(ER_VIEW_INVALID, MYF(0),
               view->view_db.str, view->view_name.str);
    }
    DBUG_RETURN(0);
  }
  if (tmp)
  {
    /* Give right error message */
    thd->clear_error();
    DBUG_PRINT("error", ("Discovery of %s/%s failed", table_list->db,
                         table_list->table_name));
    my_printf_error(ER_UNKNOWN_ERROR,
                    "Failed to open '%-.64s', error while "
                    "unpacking from engine",
                    MYF(0), table_list->table_name);
    DBUG_RETURN(0);
  }
  /* Table existed in engine. Let's open it */
  mysql_reset_errors(thd, 1);                   // Clear warnings
  thd->clear_error();                           // Clear error message
  DBUG_RETURN(get_table_share(thd, table_list, key, key_length,
                              db_flags, error));
}


/* 
   Mark that we are not using table share anymore.

   SYNOPSIS
     release_table_share()
     share		Table share
     release_type	How the release should be done:
     			RELEASE_NORMAL
                         - Release without checking
                        RELEASE_WAIT_FOR_DROP
                         - Don't return until we get a signal that the
                           table is deleted or the thread is killed.

   IMPLEMENTATION
     If ref_count goes to zero and (we have done a refresh or if we have
     already too many open table shares) then delete the definition.

     If type == RELEASE_WAIT_FOR_DROP then don't return until we get a signal
     that the table is deleted or the thread is killed.
*/

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

  safe_mutex_assert_owner(&LOCK_open);

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

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

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

  if (to_be_deleted)
  {
    DBUG_PRINT("info", ("Deleting share"));
578
    hash_delete(&table_def_cache, (uchar*) share);
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
    DBUG_VOID_RETURN;
  }
  pthread_mutex_unlock(&share->mutex);
  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)
{
601
  char key[NAME_LEN*2+2];
602 603 604 605 606 607 608
  TABLE_LIST table_list;
  uint key_length;
  safe_mutex_assert_owner(&LOCK_open);

  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
  key_length= create_table_def_key((THD*) 0, key, &table_list, 0);
609
  return (TABLE_SHARE*) hash_search(&table_def_cache,(uchar*) key, key_length);
610 611 612 613 614 615 616 617 618 619 620 621 622 623 624
}  


/*
  Close file handle, but leave the table in the table cache

  SYNOPSIS
    close_handle_and_leave_table_as_lock()
    table		Table handler

  NOTES
    By leaving the table in the table cache, it disallows any other thread
    to open the table

    thd->killed will be set if we run out of memory
625 626 627

    If closing a MERGE child, the calling function has to take care for
    closing the parent too, if necessary.
628 629 630
*/


631
void close_handle_and_leave_table_as_lock(TABLE *table)
632 633
{
  TABLE_SHARE *share, *old_share= table->s;
634
  char *key_buff;
635 636 637
  MEM_ROOT *mem_root= &table->mem_root;
  DBUG_ENTER("close_handle_and_leave_table_as_lock");

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
638 639
  DBUG_ASSERT(table->db_stat);

640 641 642 643 644
  /*
    Make a local copy of the table share and free the current one.
    This has to be done to ensure that the table share is removed from
    the table defintion cache as soon as the last instance is removed
  */
645 646 647 648
  if (multi_alloc_root(mem_root,
                       &share, sizeof(*share),
                       &key_buff, old_share->table_cache_key.length,
                       NULL))
649 650
  {
    bzero((char*) share, sizeof(*share));
651 652
    share->set_table_cache_key(key_buff, old_share->table_cache_key.str,
                               old_share->table_cache_key.length);
653 654 655
    share->tmp_table= INTERNAL_TMP_TABLE;       // for intern_close_table()
  }

656 657 658 659 660 661
  /*
    When closing a MERGE parent or child table, detach the children first.
    Do not clear child table references to allow for reopen.
  */
  if (table->child_l || table->parent)
    detach_merge_children(table, FALSE);
662 663 664 665
  table->file->close();
  table->db_stat= 0;                            // Mark file closed
  release_table_share(table->s, RELEASE_NORMAL);
  table->s= share;
666
  table->file->change_table_ptr(table, table->s);
667 668 669 670 671 672

  DBUG_VOID_RETURN;
}



monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690
/*
  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.
*/

691
OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *db, const char *wild)
692 693
{
  int result = 0;
694
  OPEN_TABLE_LIST **start_list, *open_list;
695 696
  TABLE_LIST table_list;
  DBUG_ENTER("list_open_tables");
697

698 699
  VOID(pthread_mutex_lock(&LOCK_open));
  bzero((char*) &table_list,sizeof(table_list));
700 701
  start_list= &open_list;
  open_list=0;
702

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

709
    if (db && my_strcasecmp(system_charset_info, db, share->db.str))
710
      continue;
711
    if (wild && wild_compare(share->table_name.str, wild, 0))
712
      continue;
713

714
    /* Check if user has SELECT privilege for any column in the table */
715 716
    table_list.db=         share->db.str;
    table_list.table_name= share->table_name.str;
717
    table_list.grant.privilege=0;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
718

719
    if (check_table_access(thd,SELECT_ACL | EXTRA_ACL,&table_list, 1, TRUE))
720 721 722
      continue;
    /* need to check if we haven't already listed it */
    for (table= open_list  ; table ; table=table->next)
723
    {
724 725
      if (!strcmp(table->table, share->table_name.str) &&
	  !strcmp(table->db,    share->db.str))
726 727 728 729 730 731 732
      {
	if (entry->in_use)
	  table->in_use++;
	if (entry->locked_by_name)
	  table->locked++;
	break;
      }
733
    }
734
    if (table)
735
      continue;
736
    if (!(*start_list = (OPEN_TABLE_LIST *)
737
	  sql_alloc(sizeof(**start_list)+share->table_cache_key.length)))
738
    {
739
      open_list=0;				// Out of memory
740
      break;
741
    }
742 743
    strmov((*start_list)->table=
	   strmov(((*start_list)->db= (char*) ((*start_list)+1)),
744 745
		  share->db.str)+1,
	   share->table_name.str);
746 747 748
    (*start_list)->in_use= entry->in_use ? 1 : 0;
    (*start_list)->locked= entry->locked_by_name ? 1 : 0;
    start_list= &(*start_list)->next;
749
    *start_list=0;
750 751
  }
  VOID(pthread_mutex_unlock(&LOCK_open));
752
  DBUG_RETURN(open_list);
753
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
754 755 756 757 758 759 760 761

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


void intern_close_table(TABLE *table)
{						// Free all structures
762
  DBUG_ENTER("intern_close_table");
763 764 765 766
  DBUG_PRINT("tcache", ("table: '%s'.'%s' 0x%lx",
                        table->s ? table->s->db.str : "?",
                        table->s ? table->s->table_name.str : "?",
                        (long) table));
767

bk@work.mysql.com's avatar
bk@work.mysql.com committed
768
  free_io_cache(table);
769
  delete table->triggers;
770 771 772
  if (table->file)                              // Not true if name lock
    VOID(closefrm(table, 1));			// close file
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
773 774
}

775 776 777 778 779 780 781 782 783 784
/*
  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
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
785 786 787 788 789

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

790 791 792
  /* Assert that MERGE children are not attached before final close. */
  DBUG_ASSERT(!table->is_children_attached());

bk@work.mysql.com's avatar
bk@work.mysql.com committed
793 794 795 796 797 798 799 800 801 802 803 804 805
  intern_close_table(table);
  if (!table->in_use)
  {
    table->next->prev=table->prev;		/* remove from used chain */
    table->prev->next=table->next;
    if (table == unused_tables)
    {
      unused_tables=unused_tables->next;
      if (table == unused_tables)
	unused_tables=0;
    }
    check_unused();				// consisty check
  }
806
  my_free((uchar*) table,MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
807 808 809
  DBUG_VOID_RETURN;
}

810
/* Free resources allocated by filesort() and read_record() */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
811 812 813

void free_io_cache(TABLE *table)
{
814
  DBUG_ENTER("free_io_cache");
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
815
  if (table->sort.io_cache)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
816
  {
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
817
    close_cached_file(table->sort.io_cache);
818
    my_free((uchar*) table->sort.io_cache,MYF(0));
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
819
    table->sort.io_cache=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
820
  }
821
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
822 823
}

824

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

828 829 830 831 832 833 834 835 836 837
  @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
  @param wait_for_placeholders Wait for tables being reopened so that the GRL
         won't proceed while write-locked tables are being reopened by other
         threads.

  @remark THD can be NULL, but then wait_for_refresh must be FALSE
          and tables must be NULL.
838
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
839

840 841
bool close_cached_tables(THD *thd, TABLE_LIST *tables, bool have_lock,
                         bool wait_for_refresh, bool wait_for_placeholders)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
842 843 844
{
  bool result=0;
  DBUG_ENTER("close_cached_tables");
845
  DBUG_ASSERT(thd || (!wait_for_refresh && !tables));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
846

tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
847 848
  if (!have_lock)
    VOID(pthread_mutex_lock(&LOCK_open));
849
  if (!tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
850
  {
851
    refresh_version++;				// Force close of open tables
852 853
    while (unused_tables)
    {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
854
#ifdef EXTRA_DEBUG
855
      if (hash_delete(&open_cache,(uchar*) unused_tables))
856
	printf("Warning: Couldn't delete open table from hash\n");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
857
#else
858
      VOID(hash_delete(&open_cache,(uchar*) unused_tables));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
859
#endif
860
    }
861 862 863 864
    /* Free table shares */
    while (oldest_unused_share->next)
    {
      pthread_mutex_lock(&oldest_unused_share->mutex);
865
      VOID(hash_delete(&table_def_cache, (uchar*) oldest_unused_share));
866
    }
867 868
    DBUG_PRINT("tcache", ("incremented global refresh_version to: %lu",
                          refresh_version));
869
    if (wait_for_refresh)
870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914
    {
      /*
        Other threads could wait in a loop in open_and_lock_tables(),
        trying to lock one or more of our tables.

        If they wait for the locks in thr_multi_lock(), their lock
        request is aborted. They loop in open_and_lock_tables() and
        enter open_table(). Here they notice the table is refreshed and
        wait for COND_refresh. Then they loop again in
        open_and_lock_tables() and this time open_table() succeeds. At
        this moment, if we (the FLUSH TABLES thread) are scheduled and
        on another FLUSH TABLES enter close_cached_tables(), they could
        awake while we sleep below, waiting for others threads (us) to
        close their open tables. If this happens, the other threads
        would find the tables unlocked. They would get the locks, one
        after the other, and could do their destructive work. This is an
        issue if we have LOCK TABLES in effect.

        The problem is that the other threads passed all checks in
        open_table() before we refresh the table.

        The fix for this problem is to set some_tables_deleted for all
        threads with open tables. These threads can still get their
        locks, but will immediately release them again after checking
        this variable. They will then loop in open_and_lock_tables()
        again. There they will wait until we update all tables version
        below.

        Setting some_tables_deleted is done by remove_table_from_cache()
        in the other branch.

        In other words (reviewer suggestion): You need this setting of
        some_tables_deleted for the case when table was opened and all
        related checks were passed before incrementing refresh_version
        (which you already have) but attempt to lock the table happened
        after the call to close_old_data_files() i.e. after removal of
        current thread locks.
      */
      for (uint idx=0 ; idx < open_cache.records ; idx++)
      {
        TABLE *table=(TABLE*) hash_element(&open_cache,idx);
        if (table->in_use)
          table->in_use->some_tables_deleted= 1;
      }
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
915
  }
916
  else
bk@work.mysql.com's avatar
bk@work.mysql.com committed
917
  {
918
    bool found=0;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
919
    for (TABLE_LIST *table= tables; table; table= table->next_local)
920
    {
921
      if (remove_table_from_cache(thd, table->db, table->table_name,
922
                                  RTFC_OWNED_BY_THD_FLAG))
923 924 925
	found=1;
    }
    if (!found)
926
      wait_for_refresh=0;			// Nothing to wait for
bk@work.mysql.com's avatar
bk@work.mysql.com committed
927
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
928
#ifndef EMBEDDED_LIBRARY
929 930
  if (!tables)
    kill_delayed_threads();
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
931
#endif
932
  if (wait_for_refresh)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
933 934 935 936 937 938 939
  {
    /*
      If there is any table that has a lower refresh_version, wait until
      this is closed (or this thread is killed) before returning
    */
    thd->mysys_var->current_mutex= &LOCK_open;
    thd->mysys_var->current_cond= &COND_refresh;
940
    thd_proc_info(thd, "Flushing tables");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
941

942
    close_old_data_files(thd,thd->open_tables,1,1);
943 944
    mysql_ha_flush(thd);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
945 946
    bool found=1;
    /* Wait until all threads has closed all the tables we had locked */
947
    DBUG_PRINT("info",
monty@mysql.com's avatar
monty@mysql.com committed
948
	       ("Waiting for other threads to close their open tables"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
949 950 951 952 953 954
    while (found && ! thd->killed)
    {
      found=0;
      for (uint idx=0 ; idx < open_cache.records ; idx++)
      {
	TABLE *table=(TABLE*) hash_element(&open_cache,idx);
955 956 957
        /* Avoid a self-deadlock. */
        if (table->in_use == thd)
          continue;
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
958 959 960 961 962 963 964 965 966 967 968 969 970 971
        /*
          Note that we wait here only for tables which are actually open, and
          not for placeholders with TABLE::open_placeholder set. Waiting for
          latter will cause deadlock in the following scenario, for example:

          conn1: lock table t1 write;
          conn2: lock table t2 write;
          conn1: flush tables;
          conn2: flush tables;

          It also does not make sense to wait for those of placeholders that
          are employed by CREATE TABLE as in this case table simply does not
          exist yet.
        */
972 973
	if (table->needs_reopen_or_name_lock() && (table->db_stat ||
            (table->open_placeholder && wait_for_placeholders)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
974 975
	{
	  found=1;
monty@mysql.com's avatar
monty@mysql.com committed
976
          DBUG_PRINT("signal", ("Waiting for COND_refresh"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
977 978 979 980 981 982 983 984 985 986 987 988 989
	  pthread_cond_wait(&COND_refresh,&LOCK_open);
	  break;
	}
      }
    }
    /*
      No other thread has the locked tables open; reopen them and get the
      old locks. This should always succeed (unless some external process
      has removed the tables)
    */
    thd->in_lock_tables=1;
    result=reopen_tables(thd,1,1);
    thd->in_lock_tables=0;
990
    /* Set version for table */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
991
    for (TABLE *table=thd->open_tables; table ; table= table->next)
992 993 994 995 996 997 998 999
    {
      /*
        Preserve the version (0) of write locked tables so that a impending
        global read lock won't sneak in.
      */
      if (table->reginfo.lock_type < TL_WRITE_ALLOW_WRITE)
        table->s->version= refresh_version;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1000
  }
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
1001 1002
  if (!have_lock)
    VOID(pthread_mutex_unlock(&LOCK_open));
1003
  if (wait_for_refresh)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1004 1005 1006 1007
  {
    pthread_mutex_lock(&thd->mysys_var->mutex);
    thd->mysys_var->current_mutex= 0;
    thd->mysys_var->current_cond= 0;
1008
    thd_proc_info(thd, 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1009 1010 1011 1012 1013 1014
    pthread_mutex_unlock(&thd->mysys_var->mutex);
  }
  DBUG_RETURN(result);
}


1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
/*
  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));
1030

1031 1032
  if (!have_lock)
    VOID(pthread_mutex_lock(&LOCK_open));
1033

1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061
  for (idx= 0; idx < table_def_cache.records; idx++)
  {
    TABLE_SHARE *share= (TABLE_SHARE *) hash_element(&table_def_cache, idx);

    /* 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)
1062 1063
    result= close_cached_tables(thd, tables, TRUE, FALSE, FALSE);

1064 1065
  if (!have_lock)
    VOID(pthread_mutex_unlock(&LOCK_open));
1066

1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079
  if (if_wait_for_refresh)
  {
    pthread_mutex_lock(&thd->mysys_var->mutex);
    thd->mysys_var->current_mutex= 0;
    thd->mysys_var->current_cond= 0;
    thd->proc_info=0;
    pthread_mutex_unlock(&thd->mysys_var->mutex);
  }

  DBUG_RETURN(result);
}


1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097
/**
  Mark all temporary tables which were used by the current statement or
  substatement as free for reuse, but only if the query_id can be cleared.

  @param thd thread context

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

static void mark_temp_tables_as_free_for_reuse(THD *thd)
{
  for (TABLE *table= thd->temporary_tables ; table ; table= table->next)
  {
    if ((table->query_id == thd->query_id) && ! table->open_by_handler)
    {
      table->query_id= 0;
      table->file->ha_reset();
1098 1099 1100 1101 1102 1103 1104 1105
      /*
        Detach temporary MERGE children from temporary parent to allow new
        attach at next open. Do not do the detach, if close_thread_tables()
        is called from a sub-statement. The temporary table might still be
        used in the top-level statement.
      */
      if (table->child_l || table->parent)
        detach_merge_children(table, TRUE);
1106 1107 1108 1109 1110
    }
  }
}


1111
/*
1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122
  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.
1123 1124 1125 1126 1127 1128 1129 1130 1131

  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.
1132 1133 1134 1135 1136
*/

static void mark_used_tables_as_free_for_reuse(THD *thd, TABLE *table)
{
  for (; table ; table= table->next)
1137
  {
1138
    if (table->query_id == thd->query_id)
1139
    {
1140
      table->query_id= 0;
1141 1142 1143
      table->file->ha_reset();
    }
  }
1144 1145 1146
}


1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182
/**
  Auxiliary function to close all tables in the open_tables list.

  @param thd Thread context.

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

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

  safe_mutex_assert_not_owner(&LOCK_open);

  VOID(pthread_mutex_lock(&LOCK_open));

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

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

  /* Free tables to hold down open files */
  while (open_cache.records > table_cache_size && unused_tables)
    VOID(hash_delete(&open_cache,(uchar*) unused_tables)); /* purecov: tested */
  check_unused();
  if (found_old_table)
  {
    /* Tell threads waiting for refresh that something has happened */
    broadcast_refresh();
  }

  VOID(pthread_mutex_unlock(&LOCK_open));
}


1183 1184 1185
/*
  Close all tables used by the current substatement, or all tables
  used by this thread if we are on the upper level.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1186

1187 1188 1189 1190 1191 1192 1193
  SYNOPSIS
    close_thread_tables()
    thd			Thread handler

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

1195 1196 1197 1198
    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.
1199
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1200

1201
void close_thread_tables(THD *thd)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1202
{
1203
  TABLE *table;
1204
  prelocked_mode_type prelocked_mode= thd->prelocked_mode;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1205 1206
  DBUG_ENTER("close_thread_tables");

1207 1208 1209 1210 1211 1212 1213
#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

1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224
  /*
    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.
  */
1225
  if (thd->derived_tables)
1226
  {
1227
    TABLE *next;
1228
    /*
1229 1230
      Close all derived tables generated in queries like
      SELECT * FROM (SELECT * FROM t1)
1231 1232 1233 1234 1235 1236 1237 1238
    */
    for (table= thd->derived_tables ; table ; table= next)
    {
      next= table->next;
      free_tmp_table(thd, table);
    }
    thd->derived_tables= 0;
  }
1239

1240 1241 1242 1243
  /*
    Mark all temporary tables used by this statement as free for reuse.
  */
  mark_temp_tables_as_free_for_reuse(thd);
1244 1245 1246 1247 1248 1249 1250 1251 1252
  /*
    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))
1253
  {
1254 1255 1256 1257
    thd->main_da.can_overwrite_status= TRUE;
    ha_autocommit_or_rollback(thd, thd->is_error());
    thd->main_da.can_overwrite_status= FALSE;

1258
    /*
1259 1260
      Reset transaction state, but only if we're not inside a
      sub-statement of a prelocked statement.
1261
    */
1262 1263 1264 1265 1266 1267
    if (! prelocked_mode || thd->lex->requires_prelocking())
      thd->transaction.stmt.reset();
  }

  if (thd->locked_tables || prelocked_mode)
  {
1268

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

1272 1273 1274 1275
    /*
      We are under simple LOCK TABLES or we're inside a sub-statement
      of a prelocked statement, so should not do anything else.
    */
1276
    if (!prelocked_mode || !thd->lex->requires_prelocking())
1277 1278 1279
      DBUG_VOID_RETURN;

    /*
1280 1281 1282
      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.
1283
    */
1284
    DBUG_PRINT("info",("thd->prelocked_mode= NON_PRELOCKED"));
1285 1286 1287 1288 1289 1290 1291 1292
    thd->prelocked_mode= NON_PRELOCKED;

    if (prelocked_mode == PRELOCKED_UNDER_LOCK_TABLES)
      DBUG_VOID_RETURN;

    thd->lock= thd->locked_tables;
    thd->locked_tables= 0;
    /* Fallthrough */
1293
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1294 1295 1296

  if (thd->lock)
  {
1297 1298 1299 1300 1301 1302 1303 1304 1305
    /*
      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.
     */
1306
    thd->binlog_flush_pending_rows_event(TRUE);
1307 1308
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1309
  }
1310 1311 1312 1313 1314 1315 1316
  /*
    Note that we need to hold LOCK_open while changing the
    open_tables list. Another thread may work on it.
    (See: remove_table_from_cache(), mysql_wait_completed_table())
    Closing a MERGE child before the parent would be fatal if the
    other thread tries to abort the MERGE lock in between.
  */
1317 1318
  if (thd->open_tables)
    close_open_tables(thd);
1319 1320 1321 1322 1323 1324 1325 1326

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1330 1331 1332
  DBUG_VOID_RETURN;
}

1333

1334 1335 1336 1337
/* move one table to free list */

bool close_thread_table(THD *thd, TABLE **table_ptr)
{
1338 1339
  bool found_old_table= 0;
  TABLE *table= *table_ptr;
1340
  DBUG_ENTER("close_thread_table");
1341
  DBUG_ASSERT(table->key_read == 0);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
1342
  DBUG_ASSERT(!table->file || table->file->inited == handler::NONE);
1343 1344
  DBUG_PRINT("tcache", ("table: '%s'.'%s' 0x%lx", table->s->db.str,
                        table->s->table_name.str, (long) table));
1345 1346

  *table_ptr=table->next;
1347 1348 1349 1350 1351 1352 1353
  /*
    When closing a MERGE parent or child table, detach the children first.
    Clear child table references to force new assignment at next open.
  */
  if (table->child_l || table->parent)
    detach_merge_children(table, TRUE);

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
1354
  if (table->needs_reopen_or_name_lock() ||
1355 1356
      thd->version != refresh_version || !table->db_stat)
  {
1357
    VOID(hash_delete(&open_cache,(uchar*) table));
1358 1359 1360 1361
    found_old_table=1;
  }
  else
  {
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
1362 1363 1364 1365 1366 1367
    /*
      Open placeholders have TABLE::db_stat set to 0, so they should be
      handled by the first alternative.
    */
    DBUG_ASSERT(!table->open_placeholder);

1368 1369 1370
    /* Assert that MERGE children are not attached in unused_tables. */
    DBUG_ASSERT(!table->is_children_attached());

1371
    /* Free memory and reset for next loop */
1372 1373
    free_field_buffers_larger_than(table,MAX_TDC_BLOB_SIZE);
    
1374
    table->file->ha_reset();
1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388
    table->in_use=0;
    if (unused_tables)
    {
      table->next=unused_tables;		/* Link in last */
      table->prev=unused_tables->prev;
      unused_tables->prev=table;
      table->prev->next=table;
    }
    else
      unused_tables=table->next=table->prev=table;
  }
  DBUG_RETURN(found_old_table);
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1389

1390 1391 1392 1393 1394 1395 1396
/* 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);
}


1397 1398
/*
  Close all temporary tables created by 'CREATE TEMPORARY TABLE' for thread
1399
  creates one DROP TEMPORARY TABLE binlog event for each pseudo-thread 
1400
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1401 1402 1403

void close_temporary_tables(THD *thd)
{
1404
  TABLE *table;
1405 1406 1407 1408
  TABLE *next;
  TABLE *prev_table;
  /* Assume thd->options has OPTION_QUOTE_SHOW_CREATE */
  bool was_quote_show= TRUE;
1409
  LINT_INIT(next);
1410

1411 1412
  if (!thd->temporary_tables)
    return;
1413

1414 1415
  if (!mysql_bin_log.is_open() || thd->current_stmt_binlog_row_based)
  {
1416 1417
    TABLE *tmp_next;
    for (table= thd->temporary_tables; table; table= tmp_next)
1418
    {
1419
      tmp_next= table->next;
1420 1421 1422 1423 1424 1425
      close_temporary(table, 1, 1);
    }
    thd->temporary_tables= 0;
    return;
  }

1426
  /* Better add "if exists", in case a RESET MASTER has been done */
1427 1428 1429 1430
  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);
1431
  bool found_user_tables= FALSE;
1432

1433 1434
  memcpy(buf, stub, stub_len);

1435
  /*
1436 1437
    Insertion sort of temp tables by pseudo_thread_id to build ordered list
    of sublists of equal pseudo_thread_id
1438
  */
1439 1440

  for (prev_table= thd->temporary_tables, table= prev_table->next;
1441 1442
       table;
       prev_table= table, table= table->next)
1443
  {
1444 1445
    TABLE *prev_sorted /* same as for prev_table */, *sorted;
    if (is_user_table(table))
1446
    {
1447 1448 1449 1450
      if (!found_user_tables)
        found_user_tables= true;
      for (prev_sorted= NULL, sorted= thd->temporary_tables; sorted != table;
           prev_sorted= sorted, sorted= sorted->next)
1451
      {
1452 1453
        if (!is_user_table(sorted) ||
            tmpkeyval(thd, sorted) > tmpkeyval(thd, table))
1454
        {
1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467
          /* 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;
1468 1469 1470
        }
      }
    }
1471
  }
1472 1473 1474

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

1480
  /* scan sorted tmps to generate sequence of DROP */
1481
  for (table= thd->temporary_tables; table; table= next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1482
  {
1483
    if (is_user_table(table))
1484
    {
1485
      my_thread_id save_pseudo_thread_id= thd->variables.pseudo_thread_id;
1486 1487
      /* Set pseudo_thread_id to be that of the processed table */
      thd->variables.pseudo_thread_id= tmpkeyval(thd, table);
1488 1489 1490 1491
      /*
        Loop forward through all tables within the sublist of
        common pseudo_thread_id to create single DROP query.
      */
1492 1493
      for (s_query.length(stub_len);
           table && is_user_table(table) &&
1494 1495 1496
             tmpkeyval(thd, table) == thd->variables.pseudo_thread_id;
           table= next)
      {
1497 1498 1499 1500 1501
        /*
          We are going to add 4 ` around the db/table names and possible more
          due to special characters in the names
        */
        append_identifier(thd, &s_query, table->s->db.str, strlen(table->s->db.str));
1502
        s_query.append('.');
1503 1504
        append_identifier(thd, &s_query, table->s->table_name.str,
                          strlen(table->s->table_name.str));
1505
        s_query.append(',');
1506 1507 1508 1509
        next= table->next;
        close_temporary(table, 1, 1);
      }
      thd->clear_error();
1510 1511 1512 1513 1514 1515
      CHARSET_INFO *cs_save= thd->variables.character_set_client;
      thd->variables.character_set_client= system_charset_info;
      Query_log_event qinfo(thd, s_query.ptr(),
                            s_query.length() - 1 /* to remove trailing ',' */,
                            0, FALSE);
      thd->variables.character_set_client= cs_save;
1516
      /*
1517 1518 1519 1520 1521 1522 1523 1524
        Imagine the thread had created a temp table, then was doing a
        SELECT, and the SELECT was killed. Then it's not clever to
        mark the statement above as "killed", because it's not really
        a statement updating data, and there are 99.99% chances it
        will succeed on slave.  If a real update (one updating a
        persistent table) was killed on the master, then this real
        update will be logged with error_code=killed, rightfully
        causing the slave to stop.
1525 1526 1527
      */
      qinfo.error_code= 0;
      mysql_bin_log.write(&qinfo);
1528
      thd->variables.pseudo_thread_id= save_pseudo_thread_id;
1529
    }
1530
    else
1531 1532 1533
    {
      next= table->next;
      close_temporary(table, 1, 1);
1534
    }
1535
  }
1536
  if (!was_quote_show)
1537
    thd->options&= ~OPTION_QUOTE_SHOW_CREATE; /* restore option */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1538 1539 1540
  thd->temporary_tables=0;
}

1541
/*
1542
  Find table in list.
1543 1544

  SYNOPSIS
1545
    find_table_in_list()
1546
    table		Pointer to table list
1547
    offset		Offset to which list in table structure to use
1548 1549
    db_name		Data base name
    table_name		Table name
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1550

1551 1552 1553
  NOTES:
    This is called by find_table_in_local_list() and
    find_table_in_global_list().
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1554 1555 1556 1557 1558 1559

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

1560
TABLE_LIST *find_table_in_list(TABLE_LIST *table,
1561
                               TABLE_LIST *TABLE_LIST::*link,
1562 1563
                               const char *db_name,
                               const char *table_name)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1564
{
1565
  for (; table; table= table->*link )
1566
  {
1567 1568 1569 1570
    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;
1571
  }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1572 1573 1574 1575
  return table;
}


1576
/*
1577
  Test that table is unique (It's only exists once in the table list)
1578 1579 1580

  SYNOPSIS
    unique_table()
1581
    thd                   thread handle
1582
    table                 table which should be checked
1583
    table_list            list of tables
1584
    check_alias           whether to check tables' aliases
1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599

  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

1600 1601 1602 1603
    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.

1604 1605
    TODO: when we will have table/view change detection we can do this check
          only once for PS/SP
1606 1607

  RETURN
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1608 1609
    found duplicate
    0 if table is unique
1610 1611
*/

1612 1613
TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list,
                         bool check_alias)
1614
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1615
  TABLE_LIST *res;
1616
  const char *d_name, *t_name, *t_alias;
serg@serg.mylan's avatar
serg@serg.mylan committed
1617 1618
  DBUG_ENTER("unique_table");
  DBUG_PRINT("enter", ("table alias: %s", table->alias));
1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630

  /*
    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)
1631
  {
1632 1633 1634 1635 1636 1637 1638 1639 1640
    /* 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);
1641
  }
1642 1643
  d_name= table->db;
  t_name= table->table_name;
1644
  t_alias= table->alias;
1645 1646

  DBUG_PRINT("info", ("real table: %s.%s", d_name, t_name));
1647
  for (;;)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1648
  {
1649 1650 1651
    if (((! (res= find_table_in_global_list(table_list, d_name, t_name))) &&
         (! (res= mysql_lock_have_duplicate(thd, table, table_list)))) ||
        ((!res->table || res->table != table->table) &&
1652
         (!check_alias || !(lower_case_table_names ?
evgen@sunlight.local's avatar
evgen@sunlight.local committed
1653 1654
          my_strcasecmp(files_charset_info, t_alias, res->alias) :
          strcmp(t_alias, res->alias))) &&
1655 1656
         res->select_lex && !res->select_lex->exclude_from_table_unique_test &&
         !res->prelocking_placeholder))
1657
      break;
1658
    /*
1659
      If we found entry of this table or table of SELECT which already
1660
      processed in derived table or top select of multi-update/multi-delete
1661
      (exclude_from_table_unique_test) or prelocking placeholder.
1662
    */
1663
    table_list= res->next_global;
1664 1665
    DBUG_PRINT("info",
               ("found same copy of table or table which we should skip"));
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1666
  }
1667
  DBUG_RETURN(res);
1668 1669 1670
}


1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705
/*
  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)
    {
1706
      /* Issue the ER_NON_INSERTABLE_TABLE error for an INSERT */
1707
      if (update->view == duplicate->view)
1708 1709 1710
        my_error(!strncmp(operation, "INSERT", 6) ?
                 ER_NON_INSERTABLE_TABLE : ER_NON_UPDATABLE_TABLE, MYF(0),
                 update->alias, operation);
1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727
      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);
}


1728
TABLE *find_temporary_table(THD *thd, const char *db, const char *table_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1729
{
1730
  TABLE_LIST table_list;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1731

1732 1733 1734 1735
  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
  return find_temporary_table(thd, &table_list);
}
1736

1737 1738 1739 1740 1741 1742

TABLE *find_temporary_table(THD *thd, TABLE_LIST *table_list)
{
  char	key[MAX_DBKEY_LENGTH];
  uint	key_length;
  TABLE *table;
1743 1744 1745
  DBUG_ENTER("find_temporary_table");
  DBUG_PRINT("enter", ("table: '%s'.'%s'",
                       table_list->db, table_list->table_name));
1746 1747 1748

  key_length= create_table_def_key(thd, key, table_list, 1);
  for (table=thd->temporary_tables ; table ; table= table->next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1749
  {
1750 1751
    if (table->s->table_cache_key.length == key_length &&
	!memcmp(table->s->table_cache_key.str, key, key_length))
1752 1753 1754 1755 1756
    {
      DBUG_PRINT("info",
                 ("Found table. server_id: %u  pseudo_thread_id: %lu",
                  (uint) thd->server_id,
                  (ulong) thd->variables.pseudo_thread_id));
1757
      DBUG_RETURN(table);
1758
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1759
  }
1760
  DBUG_RETURN(0);                               // Not a temporary table
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1761 1762
}

1763

1764 1765 1766 1767 1768
/**
  Drop a temporary table.

  Try to locate the table in the list of thd->temporary_tables.
  If the table is found:
1769
   - if the table is being used by some outer statement, fail.
1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783
   - if the table is in thd->locked_tables, unlock it and
     remove it from the list of locked tables. Currently only transactional
     temporary tables are present in the locked_tables list.
   - 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.

1784 1785 1786 1787
  @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
1788 1789
*/

1790
int drop_temporary_table(THD *thd, TABLE_LIST *table_list)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1791
{
1792
  TABLE *table;
1793
  DBUG_ENTER("drop_temporary_table");
1794 1795
  DBUG_PRINT("tmptable", ("closing table: '%s'.'%s'",
                          table_list->db, table_list->table_name));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1796

1797
  if (!(table= find_temporary_table(thd, table_list)))
1798 1799 1800 1801 1802 1803 1804 1805 1806
    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);
  }

1807 1808 1809 1810 1811
  /*
    If LOCK TABLES list is not empty and contains this table,
    unlock the table and remove the table from this list.
  */
  mysql_lock_remove(thd, thd->locked_tables, table, FALSE);
1812
  close_temporary_table(thd, table, 1, 1);
1813
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1814 1815
}

1816
/*
1817
  unlink from thd->temporary tables and close temporary table
1818 1819 1820 1821 1822
*/

void close_temporary_table(THD *thd, TABLE *table,
                           bool free_share, bool delete_table)
{
1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840
  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));

  /*
    When closing a MERGE parent or child table, detach the children
    first. Clear child table references as MERGE table cannot be
    reopened after final close of one of its tables.

    This is necessary here because it is sometimes called with attached
    tables and without prior close_thread_tables(). E.g. in
    mysql_alter_table(), mysql_rm_table_part2(), mysql_truncate(),
    drop_open_table().
  */
  if (table->child_l || table->parent)
    detach_merge_children(table, TRUE);

1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859
  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;
  }
1860
  if (thd->slave_thread)
1861 1862 1863
  {
    /* natural invariant of temporary_tables */
    DBUG_ASSERT(slave_open_temp_tables || !thd->temporary_tables);
1864
    slave_open_temp_tables--;
1865
  }
1866
  close_temporary(table, free_share, delete_table);
1867
  DBUG_VOID_RETURN;
1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880
}


/*
  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)
{
antony@ppcg5.local's avatar
antony@ppcg5.local committed
1881
  handlerton *table_type= table->s->db_type();
1882
  DBUG_ENTER("close_temporary");
1883 1884
  DBUG_PRINT("tmptable", ("closing table: '%s'.'%s'",
                          table->s->db.str, table->s->table_name.str));
1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898

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


guilhem@mysql.com's avatar
guilhem@mysql.com committed
1899 1900 1901 1902 1903 1904 1905
/*
  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'.
*/
1906

1907
bool rename_temporary_table(THD* thd, TABLE *table, const char *db,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1908 1909 1910
			    const char *table_name)
{
  char *key;
1911
  uint key_length;
1912
  TABLE_SHARE *share= table->s;
1913 1914 1915
  TABLE_LIST table_list;
  DBUG_ENTER("rename_temporary_table");

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

  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
1921 1922
  key_length= create_table_def_key(thd, key, &table_list, 1);
  share->set_table_cache_key(key, key_length);
1923
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1924 1925 1926 1927 1928 1929 1930
}


	/* move table first in unused links */

static void relink_unused(TABLE *table)
{
1931 1932 1933
  /* Assert that MERGE children are not attached in unused_tables. */
  DBUG_ASSERT(!table->is_children_attached());

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947
  if (table != unused_tables)
  {
    table->prev->next=table->next;		/* Remove from unused list */
    table->next->prev=table->prev;
    table->next=unused_tables;			/* Link in unused tables */
    table->prev=unused_tables->prev;
    unused_tables->prev->next=table;
    unused_tables->prev=table;
    unused_tables=table;
    check_unused();
  }
}


dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
1948
/**
1949
  Prepare an open merge table for close.
1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018

  @param[in]     thd             thread context
  @param[in]     table           table to prepare
  @param[in,out] prev_pp         pointer to pointer of previous table

  @detail
    If the table is a MERGE parent, just detach the children.
    If the table is a MERGE child, close the parent (incl. detach).
*/

static void unlink_open_merge(THD *thd, TABLE *table, TABLE ***prev_pp)
{
  DBUG_ENTER("unlink_open_merge");

  if (table->parent)
  {
    /*
      If MERGE child, close parent too. Closing includes detaching.

      This is used for example in ALTER TABLE t1 RENAME TO t5 under
      LOCK TABLES where t1 is a MERGE child:
      CREATE TABLE t1 (c1 INT);
      CREATE TABLE t2 (c1 INT) ENGINE=MRG_MYISAM UNION=(t1);
      LOCK TABLES t1 WRITE, t2 WRITE;
      ALTER TABLE t1 RENAME TO t5;
    */
    TABLE *parent= table->parent;
    TABLE **prv_p;

    /* Find parent in open_tables list. */
    for (prv_p= &thd->open_tables;
         *prv_p && (*prv_p != parent);
         prv_p= &(*prv_p)->next) {}
    if (*prv_p)
    {
      /* Special treatment required if child follows parent in list. */
      if (*prev_pp == &parent->next)
        *prev_pp= prv_p;
      /*
        Remove parent from open_tables list and close it.
        This includes detaching and hence clearing parent references.
      */
      close_thread_table(thd, prv_p);
    }
  }
  else if (table->child_l)
  {
    /*
      When closing a MERGE parent, detach the children first. It is
      not necessary to clear the child or parent table reference of
      this table because the TABLE is freed. But we need to clear
      the child or parent references of the other belonging tables
      so that they cannot be moved into the unused_tables chain with
      these pointers set.

      This is used for example in ALTER TABLE t2 RENAME TO t5 under
      LOCK TABLES where t2 is a MERGE parent:
      CREATE TABLE t1 (c1 INT);
      CREATE TABLE t2 (c1 INT) ENGINE=MRG_MYISAM UNION=(t1);
      LOCK TABLES t1 WRITE, t2 WRITE;
      ALTER TABLE t2 RENAME TO t5;
    */
    detach_merge_children(table, TRUE);
  }

  DBUG_VOID_RETURN;
}


dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2019
/**
2020 2021
    Remove all instances of table from thread's open list and
    table cache.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2022 2023 2024 2025 2026 2027 2028 2029

    @param  thd     Thread context
    @param  find    Table to remove
    @param  unlock  TRUE  - free all locks on tables removed that are
                            done with LOCK TABLES
                    FALSE - otherwise

    @note When unlock parameter is FALSE or current thread doesn't have
2030
          any tables locked with LOCK TABLES, tables are assumed to be
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2031 2032
          not locked (for example already unlocked).
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2033

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2034
void unlink_open_table(THD *thd, TABLE *find, bool unlock)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2035 2036
{
  char key[MAX_DBKEY_LENGTH];
2037
  uint key_length= find->s->table_cache_key.length;
2038
  TABLE *list, **prev;
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2039 2040 2041
  DBUG_ENTER("unlink_open_table");

  safe_mutex_assert_owner(&LOCK_open);
2042

2043
  memcpy(key, find->s->table_cache_key.str, key_length);
2044 2045 2046 2047 2048 2049 2050 2051
  /*
    Note that we need to hold LOCK_open while changing the
    open_tables list. Another thread may work on it.
    (See: remove_table_from_cache(), mysql_wait_completed_table())
    Closing a MERGE child before the parent would be fatal if the
    other thread tries to abort the MERGE lock in between.
  */
  for (prev= &thd->open_tables; *prev; )
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2052
  {
2053 2054
    list= *prev;

2055 2056
    if (list->s->table_cache_key.length == key_length &&
	!memcmp(list->s->table_cache_key.str, key, key_length))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2057
    {
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2058
      if (unlock && thd->locked_tables)
2059 2060 2061 2062 2063 2064 2065 2066 2067
        mysql_lock_remove(thd, thd->locked_tables,
                          list->parent ? list->parent : list, TRUE);

      /* Prepare MERGE table for close. Close parent if necessary. */
      unlink_open_merge(thd, list, &prev);

      /* Remove table from open_tables list. */
      *prev= list->next;
      /* Close table. */
2068
      VOID(hash_delete(&open_cache,(uchar*) list)); // Close table
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2069 2070 2071
    }
    else
    {
2072
      /* Step to next entry in open_tables list. */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2073 2074 2075
      prev= &list->next;
    }
  }
2076

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2077
  // Notify any 'refresh' threads
2078
  broadcast_refresh();
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2079 2080 2081 2082 2083
  DBUG_VOID_RETURN;
}


/**
2084
    Auxiliary routine which closes and drops open table.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2085 2086 2087 2088 2089 2090 2091 2092

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

    @note This routine assumes that table to be closed is open only
          by calling thread so we needn't wait until other threads
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2093 2094 2095 2096 2097
          will close the table. Also unless called under implicit or
          explicit LOCK TABLES mode it assumes that table to be
          dropped is already unlocked. In the former case it will
          also remove lock on the table. But one should not rely on
          this behaviour as it may change in future.
2098 2099
          Currently, however, this function is never called for a
          table that was locked with LOCK TABLES.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2100 2101 2102 2103 2104 2105 2106 2107 2108
*/

void drop_open_table(THD *thd, TABLE *table, const char *db_name,
                     const char *table_name)
{
  if (table->s->tmp_table)
    close_temporary_table(thd, table, 1, 1);
  else
  {
kostja@vajra.(none)'s avatar
kostja@vajra.(none) committed
2109
    handlerton *table_type= table->s->db_type();
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2110 2111 2112 2113 2114 2115 2116 2117 2118
    VOID(pthread_mutex_lock(&LOCK_open));
    /*
      unlink_open_table() also tells threads waiting for refresh or close
      that something has happened.
    */
    unlink_open_table(thd, table, FALSE);
    quick_rm_table(table_type, db_name, table_name, 0);
    VOID(pthread_mutex_unlock(&LOCK_open));
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2119 2120 2121
}


2122
/*
2123 2124 2125 2126 2127 2128 2129 2130
   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
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2131 2132
*/

2133
void wait_for_condition(THD *thd, pthread_mutex_t *mutex, pthread_cond_t *cond)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2134 2135 2136
{
  /* Wait until the current table is up to date */
  const char *proc_info;
2137 2138
  thd->mysys_var->current_mutex= mutex;
  thd->mysys_var->current_cond= cond;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2139
  proc_info=thd->proc_info;
2140
  thd_proc_info(thd, "Waiting for table");
2141
  DBUG_ENTER("wait_for_condition");
2142
  if (!thd->killed)
2143
    (void) pthread_cond_wait(cond, mutex);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2144

2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156
  /*
    We must unlock mutex first to avoid deadlock becasue conditions are
    sent to this thread by doing locks in the following order:
    lock(mysys_var->mutex)
    lock(mysys_var->current_mutex)

    One by effect of this that one can only use wait_for_condition with
    condition variables that are guranteed to not disapper (freed) even if this
    mutex is unlocked
  */
    
  pthread_mutex_unlock(mutex);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2157 2158 2159
  pthread_mutex_lock(&thd->mysys_var->mutex);
  thd->mysys_var->current_mutex= 0;
  thd->mysys_var->current_cond= 0;
2160
  thd_proc_info(thd, proc_info);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2161
  pthread_mutex_unlock(&thd->mysys_var->mutex);
monty@mysql.com's avatar
monty@mysql.com committed
2162
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2163 2164
}

2165

2166 2167 2168 2169 2170
/**
  Exclusively name-lock a table that is already write-locked by the
  current thread.

  @param thd current thread context
2171
  @param tables table list containing one table to open.
2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200

  @return FALSE on success, TRUE otherwise.
*/

bool name_lock_locked_table(THD *thd, TABLE_LIST *tables)
{
  DBUG_ENTER("name_lock_locked_table");

  /* Under LOCK TABLES we must only accept write locked tables. */
  tables->table= find_locked_table(thd, tables->db, tables->table_name);

  if (!tables->table)
    my_error(ER_TABLE_NOT_LOCKED, MYF(0), tables->alias);
  else if (tables->table->reginfo.lock_type < TL_WRITE_LOW_PRIORITY)
    my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0), tables->alias);
  else
  {
    /*
      Ensures that table is opened only by this thread and that no
      other statement will open this table.
    */
    wait_while_table_is_used(thd, tables->table, HA_EXTRA_FORCE_REOPEN);
    DBUG_RETURN(FALSE);
  }

  DBUG_RETURN(TRUE);
}


2201 2202 2203 2204 2205 2206 2207 2208 2209
/*
  Open table which is already name-locked by this thread.

  SYNOPSIS
    reopen_name_locked_table()
      thd         Thread handle
      table_list  TABLE_LIST object for table to be open, TABLE_LIST::table
                  member should point to TABLE object which was used for
                  name-locking.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2210 2211 2212 2213 2214
      link_in     TRUE  - if TABLE object for table to be opened should be
                          linked into THD::open_tables list.
                  FALSE - placeholder used for name-locking is already in
                          this list so we only need to preserve TABLE::next
                          pointer.
2215 2216 2217 2218 2219 2220 2221 2222 2223

  NOTE
    This function assumes that its caller already acquired LOCK_open mutex.

  RETURN VALUE
    FALSE - Success
    TRUE  - Error
*/

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2224
bool reopen_name_locked_table(THD* thd, TABLE_LIST* table_list, bool link_in)
2225
{
2226
  TABLE *table= table_list->table;
2227
  TABLE_SHARE *share;
2228 2229 2230
  char *table_name= table_list->table_name;
  TABLE orig_table;
  DBUG_ENTER("reopen_name_locked_table");
2231

2232 2233 2234 2235 2236 2237
  safe_mutex_assert_owner(&LOCK_open);

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

  orig_table= *table;
2238

2239 2240
  if (open_unireg_entry(thd, table, table_list, table_name,
                        table->s->table_cache_key.str,
2241
                        table->s->table_cache_key.length, thd->mem_root, 0))
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2242
  {
2243 2244 2245 2246 2247 2248 2249 2250 2251
    intern_close_table(table);
    /*
      If there was an error during opening of table (for example if it
      does not exist) '*table' object can be wiped out. To be able
      properly release name-lock in this case we should restore this
      object to its original state.
    */
    *table= orig_table;
    DBUG_RETURN(TRUE);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2252
  }
2253

2254
  share= table->s;
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2255 2256 2257 2258 2259 2260 2261 2262
  /*
    We want to prevent other connections from opening this table until end
    of statement as it is likely that modifications of table's metadata are
    not yet finished (for example CREATE TRIGGER have to change .TRG file,
    or we might want to drop table if CREATE TABLE ... SELECT fails).
    This also allows us to assume that no other connection will sneak in
    before we will get table-level lock on this table.
  */
2263
  share->version=0;
2264 2265
  table->in_use = thd;
  check_unused();
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280

  if (link_in)
  {
    table->next= thd->open_tables;
    thd->open_tables= table;
  }
  else
  {
    /*
      TABLE object should be already in THD::open_tables list so we just
      need to set TABLE::next correctly.
    */
    table->next= orig_table.next;
  }

2281 2282 2283
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
2284
  table->null_row= table->maybe_null= table->force_index= 0;
2285
  table->status=STATUS_NO_RECORD;
2286
  DBUG_RETURN(FALSE);
2287 2288
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2289

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2290
/**
2291 2292 2293
    Create and insert into table cache placeholder for table
    which will prevent its opening (or creation) (a.k.a lock
    table name).
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330

    @param thd         Thread context
    @param key         Table cache key for name to be locked
    @param key_length  Table cache key length

    @return Pointer to TABLE object used for name locking or 0 in
            case of failure.
*/

TABLE *table_cache_insert_placeholder(THD *thd, const char *key,
                                      uint key_length)
{
  TABLE *table;
  TABLE_SHARE *share;
  char *key_buff;
  DBUG_ENTER("table_cache_insert_placeholder");

  safe_mutex_assert_owner(&LOCK_open);

  /*
    Create a table entry with the right key and with an old refresh version
    Note that we must use my_multi_malloc() here as this is freed by the
    table cache
  */
  if (!my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),
                       &table, sizeof(*table),
                       &share, sizeof(*share),
                       &key_buff, key_length,
                       NULL))
    DBUG_RETURN(NULL);

  table->s= share;
  share->set_table_cache_key(key_buff, key, key_length);
  share->tmp_table= INTERNAL_TMP_TABLE;  // for intern_close_table
  table->in_use= thd;
  table->locked_by_name=1;

2331
  if (my_hash_insert(&open_cache, (uchar*)table))
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2332
  {
jani@linux-th5m.site's avatar
jani@linux-th5m.site committed
2333
    my_free((uchar*) table, MYF(0));
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2334 2335 2336 2337 2338 2339 2340 2341
    DBUG_RETURN(NULL);
  }

  DBUG_RETURN(table);
}


/**
2342 2343
    Obtain an exclusive name lock on the table if it is not cached
    in the table cache.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372

    @param      thd         Thread context
    @param      db          Name of database
    @param      table_name  Name of table
    @param[out] table       Out parameter which is either:
                            - set to NULL if table cache contains record for
                              the table or
                            - set to point to the TABLE instance used for
                              name-locking.

    @note This function takes into account all records for table in table
          cache, even placeholders used for name-locking. This means that
          'table' parameter can be set to NULL for some situations when
          table does not really exist.

    @retval  TRUE   Error occured (OOM)
    @retval  FALSE  Success. 'table' parameter set according to above rules.
*/

bool lock_table_name_if_not_cached(THD *thd, const char *db,
                                   const char *table_name, TABLE **table)
{
  char key[MAX_DBKEY_LENGTH];
  uint key_length;
  DBUG_ENTER("lock_table_name_if_not_cached");

  key_length= (uint)(strmov(strmov(key, db) + 1, table_name) - key) + 1;
  VOID(pthread_mutex_lock(&LOCK_open));

2373
  if (hash_search(&open_cache, (uchar *)key, key_length))
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393
  {
    VOID(pthread_mutex_unlock(&LOCK_open));
    DBUG_PRINT("info", ("Table is cached, name-lock is not obtained"));
    *table= 0;
    DBUG_RETURN(FALSE);
  }
  if (!(*table= table_cache_insert_placeholder(thd, key, key_length)))
  {
    VOID(pthread_mutex_unlock(&LOCK_open));
    DBUG_RETURN(TRUE);
  }
  (*table)->open_placeholder= 1;
  (*table)->next= thd->open_tables;
  thd->open_tables= *table;
  VOID(pthread_mutex_unlock(&LOCK_open));
  DBUG_RETURN(FALSE);
}


/**
2394 2395
    Check that table exists in table definition cache, on disk
    or in some storage engine.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2396

kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
2397 2398 2399
    @param       thd     Thread context
    @param       table   Table list element
    @param[out]  exists  Out parameter which is set to TRUE if table
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456
                         exists and to FALSE otherwise.

    @note This function assumes that caller owns LOCK_open mutex.
          It also assumes that the fact that there are no name-locks
          on the table was checked beforehand.

    @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)
{
  char path[FN_REFLEN];
  int rc;
  DBUG_ENTER("check_if_table_exists");

  safe_mutex_assert_owner(&LOCK_open);

  *exists= TRUE;

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

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

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

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

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

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


2457 2458 2459 2460 2461
/*
  Open a table.

  SYNOPSIS
    open_table()
2462 2463 2464 2465 2466 2467 2468 2469 2470 2471
    thd                 Thread context.
    table_list          Open first table in list.
    refresh      INOUT  Pointer to memory that will be set to 1 if
                        we need to close all tables and reopen them.
                        If this is a NULL pointer, then the table is not
                        put in the thread-open-list.
    flags               Bitmap of flags to modify how open works:
                          MYSQL_LOCK_IGNORE_FLUSH - Open table even if
                          someone has done a flush or namelock on it.
                          No version number checking is done.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2472 2473
                          MYSQL_OPEN_TEMPORARY_ONLY - Open only temporary
                          table not the base table or view.
2474 2475 2476 2477

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

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2478 2479 2480 2481 2482
    If table list element for the table to be opened has "create" flag
    set and table does not exist, this function will automatically insert
    a placeholder for exclusive name lock into the open tables cache and
    will return the TABLE instance that corresponds to this placeholder.

2483 2484
  RETURN
    NULL  Open failed.  If refresh is set then one should close
2485
          all other tables and retry the open.
2486 2487
    #     Success. Pointer to TABLE object for open table.
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2488 2489


bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2490
TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
2491
		  bool *refresh, uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2492 2493 2494 2495
{
  reg1	TABLE *table;
  char	key[MAX_DBKEY_LENGTH];
  uint	key_length;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2496
  char	*alias= table_list->alias;
2497
  HASH_SEARCH_STATE state;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2498 2499
  DBUG_ENTER("open_table");

2500 2501 2502
  /* Parsing of partitioning information from .frm needs thd->lex set up. */
  DBUG_ASSERT(thd->lex->is_lex_started);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2503 2504 2505
  /* find a unused table in the open table cache */
  if (refresh)
    *refresh=0;
2506 2507

  /* an open table operation needs a lot of the stack space */
2508
  if (check_stack_overrun(thd, STACK_MIN_SIZE_FOR_OPEN, (uchar *)&alias))
monty@mysql.com's avatar
monty@mysql.com committed
2509
    DBUG_RETURN(0);
2510

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2511 2512
  if (thd->killed)
    DBUG_RETURN(0);
2513 2514 2515

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

2517 2518 2519 2520 2521 2522 2523
  /*
    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.
  */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2524
  if (!table_list->skip_temporary)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2525
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2526
    for (table= thd->temporary_tables; table ; table=table->next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2527
    {
2528 2529 2530
      if (table->s->table_cache_key.length == key_length +
          TMP_TABLE_KEY_EXTRA &&
	  !memcmp(table->s->table_cache_key.str, key,
monty@mysql.com's avatar
monty@mysql.com committed
2531
		  key_length + TMP_TABLE_KEY_EXTRA))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2532
      {
2533 2534 2535 2536 2537 2538
        /*
          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.
        */
2539
	if (table->query_id)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2540
	{
2541 2542 2543 2544
          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));
2545
	  my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2546 2547 2548
	  DBUG_RETURN(0);
	}
	table->query_id= thd->query_id;
2549
	thd->thread_specific_used= TRUE;
monty@mysql.com's avatar
monty@mysql.com committed
2550 2551
        DBUG_PRINT("info",("Using temporary table"));
        goto reset;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2552 2553 2554 2555
      }
    }
  }

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2556 2557 2558 2559 2560 2561
  if (flags & MYSQL_OPEN_TEMPORARY_ONLY)
  {
    my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->db, table_list->table_name);
    DBUG_RETURN(0);
  }

2562 2563 2564 2565 2566 2567 2568
  /*
    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.
  */
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2569
  if (thd->locked_tables || thd->prelocked_mode)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2570
  {						// Using table locks
2571
    TABLE *best_table= 0;
2572
    int best_distance= INT_MIN;
2573 2574 2575
    bool check_if_used= thd->prelocked_mode &&
                        ((int) table_list->lock_type >=
                         (int) TL_WRITE_ALLOW_WRITE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2576 2577
    for (table=thd->open_tables; table ; table=table->next)
    {
2578 2579
      if (table->s->table_cache_key.length == key_length &&
	  !memcmp(table->s->table_cache_key.str, key, key_length))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2580
      {
2581 2582
        if (check_if_used && table->query_id &&
            table->query_id != thd->query_id)
2583
        {
2584 2585 2586 2587 2588 2589 2590
          /*
            If we are in stored function or trigger we should ensure that
            we won't change table that is already used by calling statement.
            So if we are opening table for writing, we should check that it
            is not already open by some calling stamement.
          */
          my_error(ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG, MYF(0),
2591
                   table->s->table_name.str);
2592 2593
          DBUG_RETURN(0);
        }
2594 2595 2596 2597
        /*
          When looking for a usable TABLE, ignore MERGE children, as they
          belong to their parent and cannot be used explicitly.
        */
2598 2599
        if (!my_strcasecmp(system_charset_info, table->alias, alias) &&
            table->query_id != thd->query_id && /* skip tables already used */
2600 2601
            !(thd->prelocked_mode && table->query_id) &&
            !table->parent)
2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632
        {
          int distance= ((int) table->reginfo.lock_type -
                         (int) table_list->lock_type);
          /*
            Find a table that either has the exact lock type requested,
            or has the best suitable lock. In case there is no locked
            table that has an equal or higher lock than requested,
            we us the closest matching lock to be able to produce an error
            message about wrong lock mode on the table. The best_table
            is changed if bd < 0 <= d or bd < d < 0 or 0 <= d < bd.

            distance <  0 - No suitable lock found
            distance >  0 - we have lock mode higher then we require
            distance == 0 - we have lock mode exactly which we need
          */
          if (best_distance < 0 && distance > best_distance ||
              distance >= 0 && distance < best_distance)
          {
            best_distance= distance;
            best_table= table;
            if (best_distance == 0 && !check_if_used)
            {
              /*
                If we have found perfect match and we don't need to check that
                table is not used by one of calling statements (assuming that
                we are inside of function or trigger) we can finish iterating
                through open tables list.
              */
              break;
            }
          }
2633
        }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2634
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2635
    }
2636 2637 2638 2639 2640 2641 2642
    if (best_table)
    {
      table= best_table;
      table->query_id= thd->query_id;
      DBUG_PRINT("info",("Using locked table"));
      goto reset;
    }
2643
    /*
2644
      Is this table a view and not a base table?
2645 2646 2647 2648 2649
      (it is work around to allow to open view with locked tables,
      real fix will be made after definition cache will be made)
    */
    {
      char path[FN_REFLEN];
2650
      enum legacy_db_type not_used;
2651
      build_table_filename(path, sizeof(path) - 1,
2652
                           table_list->db, table_list->table_name, reg_ext, 0);
2653
      if (mysql_frm_type(thd, path, &not_used) == FRMTYPE_VIEW)
2654
      {
2655 2656 2657 2658 2659
        /*
          Will not be used (because it's VIEW) but has to be passed.
          Also we will not free it (because it is a stack variable).
        */
        TABLE tab;
2660
        table= &tab;
2661
        VOID(pthread_mutex_lock(&LOCK_open));
2662
        if (!open_unireg_entry(thd, table, table_list, alias,
2663
                              key, key_length, mem_root, 0))
2664
        {
2665
          DBUG_ASSERT(table_list->view != 0);
2666 2667 2668 2669 2670 2671
          VOID(pthread_mutex_unlock(&LOCK_open));
          DBUG_RETURN(0); // VIEW
        }
        VOID(pthread_mutex_unlock(&LOCK_open));
      }
    }
2672 2673 2674 2675 2676 2677 2678 2679
    /*
      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.
    */
    if (thd->prelocked_mode == PRELOCKED)
2680
      my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->db, table_list->alias);
2681 2682
    else
      my_error(ER_TABLE_NOT_LOCKED, MYF(0), alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2683 2684
    DBUG_RETURN(0);
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2685

2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701
  /*
    Non pre-locked/LOCK TABLES mode, and the table is not temporary:
    this is the normal use case.
    Now we should:
    - try to find the table in the table cache.
    - if one of the discovered TABLE instances is name-locked
      (table->s->version == 0) or some thread has started FLUSH TABLES
      (refresh_version > table->s->version), back off -- we have to wait
      until no one holds a name lock on the table.
    - if there is no such TABLE in the name cache, read the table definition
    and insert it into the cache.
    We perform all of the above under LOCK_open which currently protects
    the open cache (also known as table cache) and table definitions stored
    on disk.
  */

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2702 2703
  VOID(pthread_mutex_lock(&LOCK_open));

2704 2705 2706 2707 2708 2709 2710 2711
  /*
    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.
  */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2712 2713
  if (!thd->open_tables)
    thd->version=refresh_version;
2714
  else if ((thd->version != refresh_version) &&
2715
           ! (flags & MYSQL_LOCK_IGNORE_FLUSH))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2716 2717
  {
    /* Someone did a refresh while thread was opening tables */
2718 2719
    if (refresh)
      *refresh=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2720 2721 2722 2723
    VOID(pthread_mutex_unlock(&LOCK_open));
    DBUG_RETURN(0);
  }

2724 2725 2726 2727 2728 2729 2730
  /*
    In order for the back off and re-start process to work properly,
    handler tables having old versions (due to FLUSH TABLES or pending
    name-lock) MUST be closed. This is specially important if a name-lock
    is pending for any table of the handler_tables list, otherwise a
    deadlock may occur.
  */
monty@mysql.com's avatar
monty@mysql.com committed
2731
  if (thd->handler_tables)
2732
    mysql_ha_flush(thd);
2733

2734 2735 2736 2737 2738 2739 2740 2741 2742 2743
  /*
    Actually try to find the table in the open_cache.
    The cache may contain several "TABLE" instances for the same
    physical table. The instances that are currently "in use" by
    some thread have their "in_use" member != NULL.
    There is no good reason for having more than one entry in the
    hash for the same physical table, except that we use this as
    an implicit "pending locks queue" - see
    wait_for_locked_table_names for details.
  */
2744
  for (table= (TABLE*) hash_first(&open_cache, (uchar*) key, key_length,
2745
                                  &state);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2746
       table && table->in_use ;
2747
       table= (TABLE*) hash_next(&open_cache, (uchar*) key, key_length,
2748
                                 &state))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2749
  {
2750 2751
    DBUG_PRINT("tcache", ("in_use table: '%s'.'%s' 0x%lx", table->s->db.str,
                          table->s->table_name.str, (long) table));
2752
    /*
2753
      Here we flush tables marked for flush.
2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768
      Normally, table->s->version contains the value of
      refresh_version from the moment when this table was
      (re-)opened and added to the cache.
      If since then we did (or just started) FLUSH TABLES
      statement, refresh_version has been increased.
      For "name-locked" TABLE instances, table->s->version is set
      to 0 (see lock_table_name for details).
      In case there is a pending FLUSH TABLES or a name lock, we
      need to back off and re-start opening tables.
      If we do not back off now, we may dead lock in case of lock
      order mismatch with some other thread:
      c1: name lock t1; -- sort of exclusive lock 
      c2: open t2;      -- sort of shared lock
      c1: name lock t2; -- blocks
      c2: open t1; -- blocks
2769
    */
2770
    if (table->needs_reopen_or_name_lock())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2771
    {
monty@mysql.com's avatar
monty@mysql.com committed
2772 2773 2774
      DBUG_PRINT("note",
                 ("Found table '%s.%s' with different refresh version",
                  table_list->db, table_list->table_name));
2775

2776
      if (flags & MYSQL_LOCK_IGNORE_FLUSH)
2777 2778 2779 2780 2781 2782
      {
        /* Force close at once after usage */
        thd->version= table->s->version;
        continue;
      }

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2783 2784 2785 2786 2787 2788 2789 2790
      /* Avoid self-deadlocks by detecting self-dependencies. */
      if (table->open_placeholder && table->in_use == thd)
      {
	VOID(pthread_mutex_unlock(&LOCK_open));
        my_error(ER_UPDATE_TABLE_USED, MYF(0), table->s->table_name.str);
        DBUG_RETURN(0);
      }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2791
      /*
2792 2793 2794 2795 2796 2797 2798
        Back off, part 1: mark the table as "unused" for the
        purpose of name-locking by setting table->db_stat to 0. Do
        that only for the tables in this thread that have an old
        table->s->version (this is an optimization (?)).
        table->db_stat == 0 signals wait_for_locked_table_names
        that the tables in question are not used any more. See
        table_is_used call for details.
2799 2800 2801 2802

        Notice that HANDLER tables were already taken care of by
        the earlier call to mysql_ha_flush() in this same critical
        section.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2803
      */
2804
      close_old_data_files(thd,thd->open_tables,0,0);
2805 2806 2807 2808 2809 2810
      /*
        Back-off part 2: try to avoid "busy waiting" on the table:
        if the table is in use by some other thread, we suspend
        and wait till the operation is complete: when any
        operation that juggles with table->s->version completes,
        it broadcasts COND_refresh condition variable.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2811 2812 2813 2814 2815 2816 2817 2818
        If 'old' table we met is in use by current thread we return
        without waiting since in this situation it's this thread
        which is responsible for broadcasting on COND_refresh
        (and this was done already in close_old_data_files()).
        Good example of such situation is when we have statement
        that needs two instances of table and FLUSH TABLES comes
        after we open first instance but before we open second
        instance.
2819
      */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2820
      if (table->in_use != thd)
2821
      {
2822
        /* wait_for_conditionwill unlock LOCK_open for us */
2823
        wait_for_condition(thd, &LOCK_open, &COND_refresh);
2824
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2825
      else
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2826
      {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2827
	VOID(pthread_mutex_unlock(&LOCK_open));
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2828
      }
2829 2830 2831 2832
      /*
        There is a refresh in progress for this table.
        Signal the caller that it has to try again.
      */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2833 2834 2835 2836 2837 2838 2839
      if (refresh)
	*refresh=1;
      DBUG_RETURN(0);
    }
  }
  if (table)
  {
2840 2841
    DBUG_PRINT("tcache", ("unused table: '%s'.'%s' 0x%lx", table->s->db.str,
                          table->s->table_name.str, (long) table));
2842
    /* Unlink the table from "unused_tables" list. */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2843 2844 2845 2846 2847 2848 2849 2850
    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;
2851
    table->in_use= thd;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2852 2853 2854
  }
  else
  {
2855
    /* Insert a new TABLE instance into the open cache */
2856
    int error;
2857
    DBUG_PRINT("tcache", ("opening new table"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2858
    /* Free cache if too big */
2859
    while (open_cache.records > table_cache_size && unused_tables)
2860
      VOID(hash_delete(&open_cache,(uchar*) unused_tables)); /* purecov: tested */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2861

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894
    if (table_list->create)
    {
      bool exists;

      if (check_if_table_exists(thd, table_list, &exists))
      {
        VOID(pthread_mutex_unlock(&LOCK_open));
        DBUG_RETURN(NULL);
      }

      if (!exists)
      {
        /*
          Table to be created, so we need to create placeholder in table-cache.
        */
        if (!(table= table_cache_insert_placeholder(thd, key, key_length)))
        {
          VOID(pthread_mutex_unlock(&LOCK_open));
          DBUG_RETURN(NULL);
        }
        /*
          Link placeholder to the open tables list so it will be automatically
          removed once tables are closed. Also mark it so it won't be ignored
          by other trying to take name-lock.
        */
        table->open_placeholder= 1;
        table->next= thd->open_tables;
        thd->open_tables= table;
        VOID(pthread_mutex_unlock(&LOCK_open));
        DBUG_RETURN(table);
      }
      /* Table exists. Let us try to open it. */
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2895 2896 2897

    /* make a new table */
    if (!(table=(TABLE*) my_malloc(sizeof(*table),MYF(MY_WME))))
2898 2899
    {
      VOID(pthread_mutex_unlock(&LOCK_open));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2900
      DBUG_RETURN(NULL);
2901
    }
2902

2903 2904 2905
    error= open_unireg_entry(thd, table, table_list, alias, key, key_length,
                             mem_root, (flags & OPEN_VIEW_NO_PARSE));
    if (error > 0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2906
    {
2907
      my_free((uchar*)table, MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2908 2909 2910
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(NULL);
    }
2911
    if (table_list->view || error < 0)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2912
    {
2913 2914 2915 2916 2917 2918 2919
      /*
        VIEW not really opened, only frm were read.
        Set 1 as a flag here
      */
      if (error < 0)
        table_list->view= (st_lex*)1;

2920
      my_free((uchar*)table, MYF(0));
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2921 2922 2923
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(0); // VIEW
    }
2924 2925 2926
    DBUG_PRINT("info", ("inserting table '%s'.'%s' 0x%lx into the cache",
                        table->s->db.str, table->s->table_name.str,
                        (long) table));
2927
    VOID(my_hash_insert(&open_cache,(uchar*) table));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2928 2929
  }

2930
  check_unused();				// Debugging call
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2931

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2932 2933 2934 2935 2936 2937 2938 2939 2940
  VOID(pthread_mutex_unlock(&LOCK_open));
  if (refresh)
  {
    table->next=thd->open_tables;		/* Link into simple list */
    thd->open_tables=table;
  }
  table->reginfo.lock_type=TL_READ;		/* Assume read */

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

2943 2944
  if (thd->lex->need_correct_ident())
    table->alias_name_used= my_strcasecmp(table_alias_charset,
2945
                                          table->s->table_name.str, alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2946
  /* Fix alias if table name changes */
2947
  if (strcmp(table->alias, alias))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2948
  {
2949
    uint length=(uint) strlen(alias)+1;
2950 2951 2952
    table->alias= (char*) my_realloc((char*) table->alias, length,
                                     MYF(MY_WME));
    memcpy((char*) table->alias, alias, length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2953 2954 2955 2956 2957
  }
  /* These variables are also set in reopen_table() */
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
2958
  table->null_row= table->maybe_null= table->force_index= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2959
  table->status=STATUS_NO_RECORD;
2960
  table->insert_values= 0;
2961 2962
  table->fulltext_searched= 0;
  table->file->ft_handler= 0;
2963 2964 2965
  /* 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;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2966
  if (table->timestamp_field)
2967
    table->timestamp_field_type= table->timestamp_field->get_auto_set_type();
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2968
  table->pos_in_table_list= table_list;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2969
  table_list->updatable= 1; // It is not derived table nor non-updatable VIEW
2970
  table->clear_column_bitmaps();
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
2971
  DBUG_ASSERT(table->key_read == 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982
  DBUG_RETURN(table);
}


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

  for (TABLE *table=thd->open_tables; table ; table=table->next)
  {
2983 2984
    if (table->s->table_cache_key.length == key_length &&
	!memcmp(table->s->table_cache_key.str, key, key_length))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2985 2986 2987 2988 2989 2990
      return table;
  }
  return(0);
}


2991 2992
/*
  Reopen an table because the definition has changed.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2993

2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006
  SYNOPSIS
    reopen_table()
    table	Table object

  NOTES
   The data file for the table is already closed and the share is released
   The table has a 'dummy' share that mainly contains database and table name.

 RETURN
   0  ok
   1  error. The old table object is not changed.
*/

3007
bool reopen_table(TABLE *table)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3008 3009
{
  TABLE tmp;
3010
  bool error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3011 3012
  Field **field;
  uint key,part;
3013 3014
  TABLE_LIST table_list;
  THD *thd= table->in_use;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3015
  DBUG_ENTER("reopen_table");
3016 3017
  DBUG_PRINT("tcache", ("table: '%s'.'%s' 0x%lx", table->s->db.str,
                        table->s->table_name.str, (long) table));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3018

3019 3020
  DBUG_ASSERT(table->s->ref_count == 0);
  DBUG_ASSERT(!table->sort.io_cache);
3021
  DBUG_ASSERT(!table->children_attached);
3022

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3023 3024 3025
#ifdef EXTRA_DEBUG
  if (table->db_stat)
    sql_print_error("Table %s had a open data handler in reopen_table",
3026
		    table->alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3027
#endif
3028
  bzero((char*) &table_list, sizeof(TABLE_LIST));
3029 3030 3031
  table_list.db=         table->s->db.str;
  table_list.table_name= table->s->table_name.str;
  table_list.table=      table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3032

3033 3034 3035 3036 3037 3038 3039
  if (wait_for_locked_table_names(thd, &table_list))
    DBUG_RETURN(1);                             // Thread was killed

  if (open_unireg_entry(thd, &tmp, &table_list,
			table->alias,
                        table->s->table_cache_key.str,
                        table->s->table_cache_key.length,
3040
                        thd->mem_root, 0))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3041 3042
    goto end;

3043
  /* This list copies variables set by open_table */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3044 3045 3046 3047
  tmp.tablenr=		table->tablenr;
  tmp.used_fields=	table->used_fields;
  tmp.const_table=	table->const_table;
  tmp.null_row=		table->null_row;
3048
  tmp.maybe_null=	table->maybe_null;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3049
  tmp.status=		table->status;
3050

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

3053
  /* Get state */
3054
  tmp.in_use=    	thd;
3055
  tmp.reginfo.lock_type=table->reginfo.lock_type;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3056 3057
  tmp.grant=		table->grant;

3058
  /* Replace table in open list */
3059 3060
  tmp.next=		table->next;
  tmp.prev=		table->prev;
3061

3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072
  /* Preserve MERGE parent. */
  tmp.parent=           table->parent;
  /* Fix MERGE child list and check for unchanged union. */
  if ((table->child_l || tmp.child_l) &&
      fix_merge_after_open(table->child_l, table->child_last_l,
                           tmp.child_l, tmp.child_last_l))
  {
    VOID(closefrm(&tmp, 1)); // close file, free everything
    goto end;
  }

3073
  delete table->triggers;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3074
  if (table->file)
3075
    VOID(closefrm(table, 1));		// close file, free everything
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3076

3077
  *table= tmp;
3078
  table->default_column_bitmaps();
3079
  table->file->change_table_ptr(table, table->s);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3080

3081
  DBUG_ASSERT(table->alias != 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3082 3083
  for (field=table->field ; *field ; field++)
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3084
    (*field)->table= (*field)->orig_table= table;
3085
    (*field)->table_name= &table->alias;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3086
  }
3087
  for (key=0 ; key < table->s->keys ; key++)
3088
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3089
    for (part=0 ; part < table->key_info[key].usable_key_parts ; part++)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3090
      table->key_info[key].key_part[part].field->table= table;
3091
  }
3092 3093
  if (table->triggers)
    table->triggers->set_table(table);
3094 3095 3096 3097 3098
  /*
    Do not attach MERGE children here. The children might be reopened
    after the parent. Attach children after reopening all tables that
    require reopen. See for example reopen_tables().
  */
3099

3100
  broadcast_refresh();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3101 3102 3103 3104 3105 3106 3107
  error=0;

 end:
  DBUG_RETURN(error);
}


3108
/**
3109 3110
    Close all instances of a table open by this thread and replace
    them with exclusive name-locks.
3111 3112 3113 3114 3115 3116 3117 3118 3119

    @param thd        Thread context
    @param db         Database name for the table to be closed
    @param table_name Name of the table to be closed

    @note This function assumes that if we are not under LOCK TABLES,
          then there is only one table open and locked. This means that
          the function probably has to be adjusted before it can be used
          anywhere outside ALTER TABLE.
3120 3121 3122

    @note Must not use TABLE_SHARE::table_name/db of the table being closed,
          the strings are used in a loop even after the share may be freed.
3123
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3124

3125 3126
void close_data_files_and_morph_locks(THD *thd, const char *db,
                                      const char *table_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3127 3128
{
  TABLE *table;
3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141
  DBUG_ENTER("close_data_files_and_morph_locks");

  safe_mutex_assert_owner(&LOCK_open);

  if (thd->lock)
  {
    /*
      If we are not under LOCK TABLES we should have only one table
      open and locked so it makes sense to remove the lock at once.
    */
    mysql_unlock_tables(thd, thd->lock);
    thd->lock= 0;
  }
3142

3143 3144 3145 3146 3147
  /*
    Note that open table list may contain a name-lock placeholder
    for target table name if we process ALTER TABLE ... RENAME.
    So loop below makes sense even if we are not under LOCK TABLES.
  */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3148 3149
  for (table=thd->open_tables; table ; table=table->next)
  {
3150 3151
    if (!strcmp(table->s->table_name.str, table_name) &&
	!strcmp(table->s->db.str, db))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3152
    {
3153
      if (thd->locked_tables)
3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169
      {
        if (table->parent)
        {
          /*
            If MERGE child, need to reopen parent too. This means that
            the first child to be closed will detach all children from
            the parent and close it. OTOH in most cases a MERGE table
            won't have multiple children with the same db.table_name.
          */
          mysql_lock_remove(thd, thd->locked_tables, table->parent, TRUE);
          table->parent->open_placeholder= 1;
          close_handle_and_leave_table_as_lock(table->parent);
        }
        else
          mysql_lock_remove(thd, thd->locked_tables, table, TRUE);
      }
3170
      table->open_placeholder= 1;
3171
      close_handle_and_leave_table_as_lock(table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3172 3173
    }
  }
3174
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3175 3176 3177
}


dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3178
/**
3179
  Reattach MERGE children after reopen.
3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233

  @param[in]     thd            thread context
  @param[in,out] err_tables_p   pointer to pointer of tables in error

  @return       status
    @retval     FALSE           OK, err_tables_p unchanged
    @retval     TRUE            Error, err_tables_p contains table(s)
*/

static bool reattach_merge(THD *thd, TABLE **err_tables_p)
{
  TABLE *table;
  TABLE *next;
  TABLE **prv_p= &thd->open_tables;
  bool error= FALSE;
  DBUG_ENTER("reattach_merge");

  for (table= thd->open_tables; table; table= next)
  {
    next= table->next;
    DBUG_PRINT("tcache", ("check table: '%s'.'%s' 0x%lx  next: 0x%lx",
                          table->s->db.str, table->s->table_name.str,
                          (long) table, (long) next));
    /* Reattach children for MERGE tables with "closed data files" only. */
    if (table->child_l && !table->children_attached)
    {
      DBUG_PRINT("tcache", ("MERGE parent, attach children"));
      if(table->file->extra(HA_EXTRA_ATTACH_CHILDREN))
      {
        my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
        error= TRUE;
        /* Remove table from open_tables. */
        *prv_p= next;
        if (next)
          prv_p= &next->next;
        /* Stack table on error list. */
        table->next= *err_tables_p;
        *err_tables_p= table;
        continue;
      }
      else
      {
        table->children_attached= TRUE;
        DBUG_PRINT("myrg", ("attached parent: '%s'.'%s' 0x%lx",
                            table->s->db.str,
                            table->s->table_name.str, (long) table));
      }
    }
    prv_p= &table->next;
  }
  DBUG_RETURN(error);
}


dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3234
/**
3235
    Reopen all tables with closed data files.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3236 3237 3238

    @param thd         Thread context
    @param get_locks   Should we get locks after reopening tables ?
3239 3240
    @param mark_share_as_old  Mark share as old to protect from a impending
                              global read lock.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251

    @note Since this function can't properly handle prelocking and
          create placeholders it should be used in very special
          situations like FLUSH TABLES or ALTER TABLE. In general
          case one should just repeat open_tables()/lock_tables()
          combination when one needs tables to be reopened (for
          example see open_and_lock_tables()).

    @note One should have lock on LOCK_open when calling this.

    @return FALSE in case of success, TRUE - otherwise.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3252 3253
*/

3254
bool reopen_tables(THD *thd, bool get_locks, bool mark_share_as_old)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3255
{
3256 3257
  TABLE *table,*next,**prev;
  TABLE **tables,**tables_ptr;			// For locks
3258
  TABLE *err_tables= NULL;
3259
  bool error=0, not_used;
3260
  bool merge_table_found= FALSE;
3261 3262 3263 3264
  const uint flags= MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN |
                    MYSQL_LOCK_IGNORE_GLOBAL_READ_LOCK |
                    MYSQL_LOCK_IGNORE_FLUSH;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3265
  DBUG_ENTER("reopen_tables");
3266

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3267 3268 3269
  if (!thd->open_tables)
    DBUG_RETURN(0);

3270
  safe_mutex_assert_owner(&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3271 3272
  if (get_locks)
  {
3273 3274 3275 3276
    /*
      The ptr is checked later
      Do not handle locks of MERGE children.
    */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3277
    uint opens=0;
3278
    for (table= thd->open_tables; table ; table=table->next)
3279 3280 3281
      if (!table->parent)
        opens++;
    DBUG_PRINT("tcache", ("open tables to lock: %u", opens));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292
    tables= (TABLE**) my_alloca(sizeof(TABLE*)*opens);
  }
  else
    tables= &thd->open_tables;
  tables_ptr =tables;

  prev= &thd->open_tables;
  for (table=thd->open_tables; table ; table=next)
  {
    uint db_stat=table->db_stat;
    next=table->next;
3293 3294 3295 3296 3297 3298
    DBUG_PRINT("tcache", ("open table: '%s'.'%s' 0x%lx  "
                          "parent: 0x%lx  db_stat: %u",
                          table->s->db.str, table->s->table_name.str,
                          (long) table, (long) table->parent, db_stat));
    if (table->child_l && !db_stat)
      merge_table_found= TRUE;
3299
    if (!tables || (!db_stat && reopen_table(table)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3300
    {
3301
      my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312
      /*
        If we could not allocate 'tables', we may close open tables
        here. If a MERGE table is affected, detach the children first.
        It is not necessary to clear the child or parent table reference
        of this table because the TABLE is freed. But we need to clear
        the child or parent references of the other belonging tables so
        that they cannot be moved into the unused_tables chain with
        these pointers set.
      */
      if (table->child_l || table->parent)
        detach_merge_children(table, TRUE);
3313
      VOID(hash_delete(&open_cache,(uchar*) table));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3314 3315 3316 3317
      error=1;
    }
    else
    {
3318 3319
      DBUG_PRINT("tcache", ("opened. need lock: %d",
                            get_locks && !db_stat && !table->parent));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3320 3321
      *prev= table;
      prev= &table->next;
3322 3323
      /* Do not handle locks of MERGE children. */
      if (get_locks && !db_stat && !table->parent)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3324
	*tables_ptr++= table;			// need new lock on this
3325
      if (mark_share_as_old)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3326
      {
3327
	table->s->version=0;
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3328
	table->open_placeholder= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3329 3330 3331
      }
    }
  }
3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347
  *prev=0;
  /*
    When all tables are open again, we can re-attach MERGE children to
    their parents. All TABLE objects are still present.
  */
  DBUG_PRINT("tcache", ("re-attaching MERGE tables: %d", merge_table_found));
  if (!error && merge_table_found && reattach_merge(thd, &err_tables))
  {
    while (err_tables)
    {
      VOID(hash_delete(&open_cache, (uchar*) err_tables));
      err_tables= err_tables->next;
    }
  }
  DBUG_PRINT("tcache", ("open tables to lock: %u",
                        (uint) (tables_ptr - tables)));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3348 3349 3350
  if (tables != tables_ptr)			// Should we get back old locks
  {
    MYSQL_LOCK *lock;
3351 3352 3353 3354 3355
    /*
      We should always get these locks. Anyway, we must not go into
      wait_for_tables() as it tries to acquire LOCK_open, which is
      already locked.
    */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3356
    thd->some_tables_deleted=0;
3357
    if ((lock= mysql_lock_tables(thd, tables, (uint) (tables_ptr - tables),
3358
                                 flags, &not_used)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3359 3360 3361 3362
    {
      thd->locked_tables=mysql_lock_merge(thd->locked_tables,lock);
    }
    else
3363 3364 3365 3366 3367 3368 3369
    {
      /*
        This case should only happen if there is a bug in the reopen logic.
        Need to issue error message to have a reply for the application.
        Not exactly what happened though, but close enough.
      */
      my_error(ER_LOCK_DEADLOCK, MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3370
      error=1;
3371
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3372 3373 3374
  }
  if (get_locks && tables)
  {
3375
    my_afree((uchar*) tables);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3376
  }
3377
  broadcast_refresh();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3378 3379 3380
  DBUG_RETURN(error);
}

3381

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3382
/**
3383 3384
    Close handlers for tables in list, but leave the TABLE structure
    intact so that we can re-open these quickly.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3385 3386 3387 3388 3389 3390 3391 3392 3393

    @param thd           Thread context
    @param table         Head of the list of TABLE objects
    @param morph_locks   TRUE  - remove locks which we have on tables being closed
                                 but ensure that no DML or DDL will sneak in before
                                 we will re-open the table (i.e. temporarily morph
                                 our table-level locks into name-locks).
                         FALSE - otherwise
    @param send_refresh  Should we awake waiters even if we didn't close any tables?
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3394 3395
*/

3396 3397
static void close_old_data_files(THD *thd, TABLE *table, bool morph_locks,
                                 bool send_refresh)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3398
{
3399
  bool found= send_refresh;
3400
  DBUG_ENTER("close_old_data_files");
3401

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3402 3403
  for (; table ; table=table->next)
  {
3404 3405 3406 3407 3408
    DBUG_PRINT("tcache", ("checking table: '%s'.'%s' 0x%lx",
                          table->s->db.str, table->s->table_name.str,
                          (long) table));
    DBUG_PRINT("tcache", ("needs refresh: %d  is open: %u",
                          table->needs_reopen_or_name_lock(), table->db_stat));
3409
    /*
3410
      Reopen marked for flush.
3411
    */
3412
    if (table->needs_reopen_or_name_lock())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3413 3414 3415 3416
    {
      found=1;
      if (table->db_stat)
      {
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3417
	if (morph_locks)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3418
	{
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3419
          /*
3420 3421
            Forward lock handling to MERGE parent. But unlock parent
            once only.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3422
          */
3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446
          TABLE *ulcktbl= table->parent ? table->parent : table;
          if (ulcktbl->lock_count)
          {
            /*
              Wake up threads waiting for table-level lock on this table
              so they won't sneak in when we will temporarily remove our
              lock on it. This will also give them a chance to close their
              instances of this table.
            */
            mysql_lock_abort(thd, ulcktbl, TRUE);
            mysql_lock_remove(thd, thd->locked_tables, ulcktbl, TRUE);
            ulcktbl->lock_count= 0;
          }
          if ((ulcktbl != table) && ulcktbl->db_stat)
          {
            /*
              Close the parent too. Note that parent can come later in
              the list of tables. It will then be noticed as closed and
              as a placeholder. When this happens, do not clear the
              placeholder flag. See the branch below ("***").
            */
            ulcktbl->open_placeholder= 1;
            close_handle_and_leave_table_as_lock(ulcktbl);
          }
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3447 3448 3449 3450 3451
          /*
            We want to protect the table from concurrent DDL operations
            (like RENAME TABLE) until we will re-open and re-lock it.
          */
	  table->open_placeholder= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3452
	}
3453
        close_handle_and_leave_table_as_lock(table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3454
      }
3455
      else if (table->open_placeholder && !morph_locks)
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3456 3457 3458 3459 3460 3461 3462
      {
        /*
          We come here only in close-for-back-off scenario. So we have to
          "close" create placeholder here to avoid deadlocks (for example,
          in case of concurrent execution of CREATE TABLE t1 SELECT * FROM t2
          and RENAME TABLE t2 TO t1). In close-for-re-open scenario we will
          probably want to let it stay.
3463 3464 3465 3466

          Note "***": We must not enter this branch if the placeholder
          flag has been set because of a former close through a child.
          See above the comment that refers to this note.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3467 3468 3469
        */
        table->open_placeholder= 0;
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3470 3471 3472
    }
  }
  if (found)
3473
    broadcast_refresh();
3474
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3475 3476 3477 3478 3479 3480 3481 3482 3483
}


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

3484
bool table_is_used(TABLE *table, bool wait_for_name_lock)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3485
{
3486
  DBUG_ENTER("table_is_used");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3487 3488
  do
  {
3489 3490 3491 3492
    char *key= table->s->table_cache_key.str;
    uint key_length= table->s->table_cache_key.length;

    DBUG_PRINT("loop", ("table_name: %s", table->alias));
konstantin@mysql.com's avatar
konstantin@mysql.com committed
3493
    HASH_SEARCH_STATE state;
3494
    for (TABLE *search= (TABLE*) hash_first(&open_cache, (uchar*) key,
3495
                                             key_length, &state);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3496
	 search ;
3497
         search= (TABLE*) hash_next(&open_cache, (uchar*) key,
3498
                                    key_length, &state))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3499
    {
3500
      DBUG_PRINT("info", ("share: 0x%lx  "
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3501
                          "open_placeholder: %d  locked_by_name: %d "
3502
                          "db_stat: %u  version: %lu",
3503
                          (ulong) search->s,
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3504
                          search->open_placeholder, search->locked_by_name,
3505 3506 3507 3508 3509 3510 3511 3512 3513
                          search->db_stat,
                          search->s->version));
      if (search->in_use == table->in_use)
        continue;                               // Name locked by this thread
      /*
        We can't use the table under any of the following conditions:
        - There is an name lock on it (Table is to be deleted or altered)
        - If we are in flush table and we didn't execute the flush
        - If the table engine is open and it's an old version
3514
        (We must wait until all engines are shut down to use the table)
3515
      */
3516 3517
      if ( (search->locked_by_name && wait_for_name_lock) ||
           (search->is_name_opened() && search->needs_reopen_or_name_lock()))
3518
        DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3519 3520
    }
  } while ((table=table->next));
3521
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3522 3523 3524 3525 3526 3527 3528 3529 3530 3531
}


/* Wait until all used tables are refreshed */

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

3532
  thd_proc_info(thd, "Waiting for tables");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3533
  pthread_mutex_lock(&LOCK_open);
3534
  while (!thd->killed)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3535
  {
3536 3537
    thd->some_tables_deleted=0;
    close_old_data_files(thd,thd->open_tables,0,dropping_tables != 0);
3538
    mysql_ha_flush(thd);
3539 3540
    if (!table_is_used(thd->open_tables,1))
      break;
3541
    (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3542 3543 3544 3545 3546 3547
  }
  if (thd->killed)
    result= 1;					// aborted
  else
  {
    /* Now we can open all tables without any interference */
3548
    thd_proc_info(thd, "Reopen tables");
antony@ltantony.mysql.com's avatar
antony@ltantony.mysql.com committed
3549
    thd->version= refresh_version;
3550
    result=reopen_tables(thd,0,0);
3551
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3552
  pthread_mutex_unlock(&LOCK_open);
3553
  thd_proc_info(thd, 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3554 3555 3556 3557
  DBUG_RETURN(result);
}


3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574
/*
  drop tables from locked list

  SYNOPSIS
    drop_locked_tables()
    thd			Thread thandler
    db			Database
    table_name		Table name

  INFORMATION
    This is only called on drop tables

    The TABLE object for the dropped table is unlocked but still kept around
    as a name lock, which means that the table will be available for other
    thread as soon as we call unlock_table_names().
    If there is multiple copies of the table locked, all copies except
    the first, which acts as a name lock, is removed.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3575

3576 3577 3578 3579 3580
  RETURN
    #    If table existed, return table
    0	 Table was not locked
*/

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3581

3582
TABLE *drop_locked_tables(THD *thd,const char *db, const char *table_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3583
{
3584
  TABLE *table,*next,**prev, *found= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3585
  prev= &thd->open_tables;
3586 3587
  DBUG_ENTER("drop_locked_tables");

3588 3589 3590 3591 3592 3593 3594
  /*
    Note that we need to hold LOCK_open while changing the
    open_tables list. Another thread may work on it.
    (See: remove_table_from_cache(), mysql_wait_completed_table())
    Closing a MERGE child before the parent would be fatal if the
    other thread tries to abort the MERGE lock in between.
  */
3595
  for (table= thd->open_tables; table ; table=next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3596 3597
  {
    next=table->next;
3598 3599
    if (!strcmp(table->s->table_name.str, table_name) &&
	!strcmp(table->s->db.str, db))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3600
    {
3601 3602 3603 3604 3605 3606 3607 3608 3609 3610
      /* If MERGE child, forward lock handling to parent. */
      mysql_lock_remove(thd, thd->locked_tables,
                        table->parent ? table->parent : table, TRUE);
      /*
        When closing a MERGE parent or child table, detach the children first.
        Clear child table references in case this object is opened again.
      */
      if (table->child_l || table->parent)
        detach_merge_children(table, TRUE);

3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623
      if (!found)
      {
        found= table;
        /* Close engine table, but keep object around as a name lock */
        if (table->db_stat)
        {
          table->db_stat= 0;
          table->file->close();
        }
      }
      else
      {
        /* We already have a name lock, remove copy */
3624
        VOID(hash_delete(&open_cache,(uchar*) table));
3625
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3626 3627 3628 3629 3630 3631 3632 3633 3634
    }
    else
    {
      *prev=table;
      prev= &table->next;
    }
  }
  *prev=0;
  if (found)
3635
    broadcast_refresh();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3636 3637
  if (thd->locked_tables && thd->locked_tables->table_count == 0)
  {
3638
    my_free((uchar*) thd->locked_tables,MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3639 3640
    thd->locked_tables=0;
  }
3641
  DBUG_RETURN(found);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3642 3643 3644
}


3645 3646 3647 3648 3649
/*
  If we have the table open, which only happens when a LOCK TABLE has been
  done on the table, change the lock type to a lock that will abort all
  other threads trying to get the lock.
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3650 3651 3652 3653

void abort_locked_tables(THD *thd,const char *db, const char *table_name)
{
  TABLE *table;
3654
  for (table= thd->open_tables; table ; table= table->next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3655
  {
3656 3657
    if (!strcmp(table->s->table_name.str, table_name) &&
	!strcmp(table->s->db.str, db))
3658
    {
3659 3660
      /* If MERGE child, forward lock handling to parent. */
      mysql_lock_abort(thd, table->parent ? table->parent : table, TRUE);
3661 3662
      break;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3663 3664 3665
  }
}

3666

3667
/*
3668
  Function to assign a new table map id to a table share.
3669 3670 3671

  PARAMETERS

3672
    share - Pointer to table share structure
3673

mats@mysql.com's avatar
mats@mysql.com committed
3674 3675 3676 3677 3678 3679 3680
  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).

3681 3682
  PRE-CONDITION(S)

3683
    share is non-NULL
3684 3685 3686 3687
    The LOCK_open mutex is locked

  POST-CONDITION(S)

3688 3689 3690
    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
3691 3692
    share opens have been executed while one table was open all the
    time).
3693

3694
    share->table_map_id is not ~0UL.
3695
 */
3696 3697
static ulong last_table_id= ~0UL;

3698
void assign_new_table_id(TABLE_SHARE *share)
3699 3700
{

3701
  DBUG_ENTER("assign_new_table_id");
3702 3703

  /* Preconditions */
3704
  DBUG_ASSERT(share != NULL);
3705 3706 3707
  safe_mutex_assert_owner(&LOCK_open);

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

  /* Post conditions */
3718
  DBUG_ASSERT(share->table_map_id != ~0UL);
3719 3720 3721 3722

  DBUG_VOID_RETURN;
}

3723 3724 3725 3726
/**
  Compare metadata versions of an element obtained from the table
  definition cache and its corresponding node in the parse tree.

3727
  @details If the new and the old values mismatch, invoke
3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741
  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
3742 3743
  @sa TABLE_LIST::is_table_ref_id_equal()
  @sa TABLE_SHARE::get_table_ref_id()
3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758

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

bool
check_and_update_table_version(THD *thd,
                               TABLE_LIST *tables, TABLE_SHARE *table_share)
{
3759
  if (! tables->is_table_ref_id_equal(table_share))
3760
  {
3761 3762
    if (thd->m_reprepare_observer &&
        thd->m_reprepare_observer->report_error(thd))
3763 3764 3765 3766 3767 3768
    {
      /*
        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.
      */
3769
      DBUG_ASSERT(thd->is_error());
3770 3771
      return TRUE;
    }
3772
    /* Always maintain the latest version and type */
3773
    tables->set_table_ref_id(table_share);
3774
  }
3775

3776 3777
#ifndef DBUG_OFF
  /* Spuriously reprepare each statement. */
3778
  if (_db_strict_keyword_("reprepare_each_statement") &&
3779
      thd->m_reprepare_observer && thd->stmt_arena->is_reprepared == FALSE)
3780
  {
3781
    thd->m_reprepare_observer->report_error(thd);
3782 3783 3784
    return TRUE;
  }
#endif
3785

3786 3787 3788
  return FALSE;
}

3789 3790 3791 3792 3793 3794 3795
/*
  Load a table definition from file and open unireg table

  SYNOPSIS
    open_unireg_entry()
    thd			Thread handle
    entry		Store open table definition here
3796
    table_list		TABLE_LIST with db, table_name & belong_to_view
3797
    alias		Alias name
3798 3799
    cache_key		Key for share_cache
    cache_key_length	length of cache_key
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3800
    mem_root		temporary mem_root for parsing
3801 3802
    flags               the OPEN_VIEW_NO_PARSE flag to be passed to
                        openfrm()/open_new_frm()
3803 3804 3805

  NOTES
   Extra argument for open is taken from thd->open_options
3806
   One must have a lock on LOCK_open when calling this function
3807 3808 3809 3810

  RETURN
    0	ok
    #	Error
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3811
*/
3812 3813 3814

static int open_unireg_entry(THD *thd, TABLE *entry, TABLE_LIST *table_list,
                             const char *alias,
3815
                             char *cache_key, uint cache_key_length,
3816
                             MEM_ROOT *mem_root, uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3817
{
3818
  int error;
3819
  TABLE_SHARE *share;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3820
  uint discover_retry_count= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3821 3822
  DBUG_ENTER("open_unireg_entry");

3823 3824 3825 3826
  safe_mutex_assert_owner(&LOCK_open);
retry:
  if (!(share= get_table_share_with_create(thd, table_list, cache_key,
                                           cache_key_length, 
3827 3828 3829
                                           OPEN_VIEW |
                                           table_list->i_s_requested_object,
                                           &error)))
3830 3831 3832 3833
    DBUG_RETURN(1);

  if (share->is_view)
  {
3834 3835 3836 3837
    /*
      This table is a view. Validate its metadata version: in particular,
      that it was a view when the statement was prepared.
    */
3838 3839
    if (check_and_update_table_version(thd, table_list, share))
      goto err;
3840 3841 3842
    if (table_list->i_s_requested_object &  OPEN_TABLE_ONLY)
      goto err;

3843 3844 3845 3846
    /* Open view */
    error= (int) open_new_frm(thd, share, alias,
                              (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
                                      HA_GET_INDEX | HA_TRY_READ_ONLY),
3847 3848
                              READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD |
                              (flags & OPEN_VIEW_NO_PARSE),
3849
                              thd->open_options, entry, table_list,
3850
                              mem_root);
3851 3852 3853 3854
    if (error)
      goto err;
    /* TODO: Don't free this */
    release_table_share(share, RELEASE_NORMAL);
3855
    DBUG_RETURN((flags & OPEN_VIEW_NO_PARSE)? -1 : 0);
3856
  }
3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870
  else if (table_list->view)
  {
    /*
      We're trying to open a table for what was a view.
      This can only happen during (re-)execution.
      At prepared statement prepare the view has been opened and
      merged into the statement parse tree. After that, someone
      performed a DDL and replaced the view with a base table.
      Don't try to open the table inside a prepared statement,
      invalidate it instead.

      Note, the assert below is known to fail inside stored
      procedures (Bug#27011).
    */
3871
    DBUG_ASSERT(thd->m_reprepare_observer);
3872 3873 3874 3875 3876
    check_and_update_table_version(thd, table_list, share);
    /* Always an error. */
    DBUG_ASSERT(thd->is_error());
    goto err;
  }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3877

3878 3879 3880
  if (table_list->i_s_requested_object &  OPEN_VIEW_ONLY)
    goto err;

3881 3882 3883 3884 3885 3886 3887
  while ((error= open_table_from_share(thd, share, alias,
                                       (uint) (HA_OPEN_KEYFILE |
                                               HA_OPEN_RNDFILE |
                                               HA_GET_INDEX |
                                               HA_TRY_READ_ONLY),
                                       (READ_KEYINFO | COMPUTE_TYPES |
                                        EXTRA_RECORD),
3888
                                       thd->open_options, entry, FALSE)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3889
  {
3890
    if (error == 7)                             // Table def changed
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3891
    {
3892 3893 3894 3895
      share->version= 0;                        // Mark share as old
      if (discover_retry_count++)               // Retry once
        goto err;

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3896
      /*
3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907
        TODO:
        Here we should wait until all threads has released the table.
        For now we do one retry. This may cause a deadlock if there
        is other threads waiting for other tables used by this thread.
        
        Proper fix would be to if the second retry failed:
        - Mark that table def changed
        - Return from open table
        - Close all tables used by this thread
        - Start waiting that the share is released
        - Retry by opening all tables again
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3908
      */
3909 3910
      if (ha_create_table_from_engine(thd, table_list->db,
                                      table_list->table_name))
monty@mysql.com's avatar
monty@mysql.com committed
3911
        goto err;
3912 3913 3914 3915 3916 3917
      /*
        TO BE FIXED
        To avoid deadlock, only wait for release if no one else is
        using the share.
      */
      if (share->ref_count != 1)
monty@mysql.com's avatar
monty@mysql.com committed
3918
        goto err;
3919 3920 3921
      /* Free share and wait until it's released by all threads */
      release_table_share(share, RELEASE_WAIT_FOR_DROP);
      if (!thd->killed)
3922
      {
3923 3924 3925
        mysql_reset_errors(thd, 1);         // Clear warnings
        thd->clear_error();                 // Clear error message
        goto retry;
3926
      }
3927
      DBUG_RETURN(1);
3928
    }
3929
    if (!entry->s || !entry->s->crashed)
3930
      goto err;
3931
     // Code below is for repairing a crashed file
3932
     if ((error= lock_table_name(thd, table_list, TRUE)))
3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950
     {
       if (error < 0)
 	goto err;
       if (wait_for_locked_table_names(thd, table_list))
       {
 	unlock_table_name(thd, table_list);
 	goto err;
       }
     }
     pthread_mutex_unlock(&LOCK_open);
     thd->clear_error();				// Clear error message
     error= 0;
     if (open_table_from_share(thd, share, alias,
                               (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
                                       HA_GET_INDEX |
                                       HA_TRY_READ_ONLY),
                               READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
                               ha_open_options | HA_OPEN_FOR_REPAIR,
3951
                               entry, FALSE) || ! entry->file ||
3952
        (entry->file->is_crashed() && entry->file->ha_check_and_repair(thd)))
3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971
     {
       /* Give right error message */
       thd->clear_error();
       my_error(ER_NOT_KEYFILE, MYF(0), share->table_name.str, my_errno);
       sql_print_error("Couldn't repair table: %s.%s", share->db.str,
                       share->table_name.str);
       if (entry->file)
 	closefrm(entry, 0);
       error=1;
     }
     else
       thd->clear_error();			// Clear error message
     pthread_mutex_lock(&LOCK_open);
     unlock_table_name(thd, table_list);
 
     if (error)
       goto err;
     break;
   }
3972

3973 3974 3975 3976
  if (Table_triggers_list::check_n_load(thd, share->db.str,
                                        share->table_name.str, entry, 0))
  {
    closefrm(entry, 0);
3977
    goto err;
3978
  }
3979

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3980 3981 3982 3983 3984 3985 3986 3987 3988 3989
  /*
    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;
3990 3991
      uint query_buf_size= 20 + share->db.length + share->table_name.length +1;
      if ((query= (char*) my_malloc(query_buf_size,MYF(MY_WME))))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3992
      {
3993
        /* this DELETE FROM is needed even with row-based binlogging */
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3994
        end = strxmov(strmov(query, "DELETE FROM `"),
3995
                      share->db.str,"`.`",share->table_name.str,"`", NullS);
3996 3997
        thd->binlog_query(THD::STMT_QUERY_TYPE,
                          query, (ulong)(end-query), FALSE, FALSE);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3998 3999 4000 4001 4002 4003 4004 4005 4006
        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).
        */
4007 4008 4009
        sql_print_error("When opening HEAP table, could not allocate memory "
                        "to write 'DELETE FROM `%s`.`%s`' to the binary log",
                        table_list->db, table_list->table_name);
4010
        delete entry->triggers;
4011
        closefrm(entry, 0);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4012 4013 4014
        goto err;
      }
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4015 4016
  }
  DBUG_RETURN(0);
4017

4018
err:
4019
  release_table_share(share, RELEASE_NORMAL);
4020
  DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4021 4022
}

4023

4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 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 4089 4090 4091 4092 4093 4094 4095 4096 4097 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 4208 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 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357
/**
  @brief Add list of MERGE children to a TABLE_LIST list.

  @param[in]    tlist           the parent TABLE_LIST object just opened

  @return status
    @retval     0               OK
    @retval     != 0            Error

  @detail
    When a MERGE parent table has just been opened, insert the
    TABLE_LIST chain from the MERGE handle into the table list used for
    opening tables for this statement. This lets the children be opened
    too.
*/

static int add_merge_table_list(TABLE_LIST *tlist)
{
  TABLE       *parent= tlist->table;
  TABLE_LIST  *child_l;
  DBUG_ENTER("add_merge_table_list");
  DBUG_PRINT("myrg", ("table: '%s'.'%s' 0x%lx", parent->s->db.str,
                      parent->s->table_name.str, (long) parent));

  /* Must not call this with attached children. */
  DBUG_ASSERT(!parent->children_attached);
  /* Must not call this with children list in place. */
  DBUG_ASSERT(tlist->next_global != parent->child_l);
  /* Prevent inclusion of another MERGE table. Could make infinite recursion. */
  if (tlist->parent_l)
  {
    my_error(ER_ADMIN_WRONG_MRG_TABLE, MYF(0), tlist->alias);
    DBUG_RETURN(1);
  }

  /* Fix children.*/
  for (child_l= parent->child_l; ; child_l= child_l->next_global)
  {
    /*
      Note: child_l->table may still be set if this parent was taken
      from the unused_tables chain. Ignore this fact here. The
      reference will be replaced by the handler in
      ::extra(HA_EXTRA_ATTACH_CHILDREN).
    */

    /* Set lock type. */
    child_l->lock_type= tlist->lock_type;

    /* Set parent reference. */
    child_l->parent_l= tlist;

    /* Break when this was the last child. */
    if (&child_l->next_global == parent->child_last_l)
      break;
  }

  /* Insert children into the table list. */
  *parent->child_last_l= tlist->next_global;
  tlist->next_global= parent->child_l;

  /*
    Do not fix the prev_global pointers. We will remove the
    chain soon anyway.
  */

  DBUG_RETURN(0);
}


/**
  @brief Attach MERGE children to the parent.

  @param[in]    tlist           the child TABLE_LIST object just opened

  @return status
    @retval     0               OK
    @retval     != 0            Error

  @note
    This is called when the last MERGE child has just been opened, let
    the handler attach the MyISAM tables to the MERGE table. Remove
    MERGE TABLE_LIST chain from the statement list so that it cannot be
    changed or freed.
*/

static int attach_merge_children(TABLE_LIST *tlist)
{
  TABLE *parent= tlist->parent_l->table;
  int error;
  DBUG_ENTER("attach_merge_children");
  DBUG_PRINT("myrg", ("table: '%s'.'%s' 0x%lx", parent->s->db.str,
                      parent->s->table_name.str, (long) parent));

  /* Must not call this with attached children. */
  DBUG_ASSERT(!parent->children_attached);
  /* Must call this with children list in place. */
  DBUG_ASSERT(tlist->parent_l->next_global == parent->child_l);

  /* Attach MyISAM tables to MERGE table. */
  error= parent->file->extra(HA_EXTRA_ATTACH_CHILDREN);

  /*
    Remove children from the table list. Even in case of an error.
    This should prevent tampering with them.
  */
  tlist->parent_l->next_global= *parent->child_last_l;

  /*
    Do not fix the last childs next_global pointer. It is needed for
    stepping to the next table in the enclosing loop in open_tables().
    Do not fix prev_global pointers. We did not set them.
  */

  if (error)
  {
    DBUG_PRINT("error", ("attaching MERGE children failed: %d", my_errno));
    parent->file->print_error(error, MYF(0));
    DBUG_RETURN(1);
  }

  parent->children_attached= TRUE;
  DBUG_PRINT("myrg", ("attached parent: '%s'.'%s' 0x%lx", parent->s->db.str,
                      parent->s->table_name.str, (long) parent));

  /*
    Note that we have the cildren in the thd->open_tables list at this
    point.
  */

  DBUG_RETURN(0);
}


/**
  @brief Detach MERGE children from the parent.

  @note
    Call this before the first table of a MERGE table (parent or child)
    is closed.

    When closing thread tables at end of statement, both parent and
    children are in thd->open_tables and will be closed. In most cases
    the children will be closed before the parent. They are opened after
    the parent and thus stacked into thd->open_tables before it.

    To avoid that we touch a closed children in any way, we must detach
    the children from the parent when the first belonging table is
    closed (parent or child).

    All references to the children should be removed on handler level
    and optionally on table level.

  @note
    Assure that you call it for a MERGE parent or child only.
    Either table->child_l or table->parent must be set.

  @param[in]    table           the TABLE object of the parent
  @param[in]    clear_refs      if to clear TABLE references
                                this must be true when called from
                                close_thread_tables() to enable fresh
                                open in open_tables()
                                it must be false when called in preparation
                                for reopen_tables()
*/

void detach_merge_children(TABLE *table, bool clear_refs)
{
  TABLE_LIST *child_l;
  TABLE *parent= table->child_l ? table : table->parent;
  bool first_detach;
  DBUG_ENTER("detach_merge_children");
  /*
    Either table->child_l or table->parent must be set. Parent must have
    child_l set.
  */
  DBUG_ASSERT(parent && parent->child_l);
  DBUG_PRINT("myrg", ("table: '%s'.'%s' 0x%lx  clear_refs: %d",
                      table->s->db.str, table->s->table_name.str,
                      (long) table, clear_refs));
  DBUG_PRINT("myrg", ("parent: '%s'.'%s' 0x%lx", parent->s->db.str,
                      parent->s->table_name.str, (long) parent));

  /*
    In a open_tables() loop it can happen that not all tables have their
    children attached yet. Also this is called for every child and the
    parent from close_thread_tables().
  */
  if ((first_detach= parent->children_attached))
  {
    VOID(parent->file->extra(HA_EXTRA_DETACH_CHILDREN));
    parent->children_attached= FALSE;
    DBUG_PRINT("myrg", ("detached parent: '%s'.'%s' 0x%lx", parent->s->db.str,
                        parent->s->table_name.str, (long) parent));
  }
  else
    DBUG_PRINT("myrg", ("parent is already detached"));

  if (clear_refs)
  {
    /* In any case clear the own parent reference. (***) */
    table->parent= NULL;

    /*
      On the first detach, clear all references. If this table is the
      parent, we still may need to clear the child references. The first
      detach might not have done this.
    */
    if (first_detach || (table == parent))
    {
      /* Clear TABLE references to force new assignment at next open. */
      for (child_l= parent->child_l; ; child_l= child_l->next_global)
      {
        /*
          Do not DBUG_ASSERT(child_l->table); open_tables might be
          incomplete.

          Clear the parent reference of the children only on the first
          detach. The children might already be closed. They will clear
          it themseves when this function is called for them with
          'clear_refs' true. See above "(***)".
        */
        if (first_detach && child_l->table)
          child_l->table->parent= NULL;

        /* Clear the table reference to force new assignment at next open. */
        child_l->table= NULL;

        /* Break when this was the last child. */
        if (&child_l->next_global == parent->child_last_l)
          break;
      }
    }
  }

  DBUG_VOID_RETURN;
}


/**
  @brief Fix MERGE children after open.

  @param[in]    old_child_list  first list member from original table
  @param[in]    old_last        pointer to &next_global of last list member
  @param[in]    new_child_list  first list member from freshly opened table
  @param[in]    new_last        pointer to &next_global of last list member

  @return       mismatch
    @retval     FALSE           OK, no mismatch
    @retval     TRUE            Error, lists mismatch

  @detail
    Main action is to copy TABLE reference for each member of original
    child list to new child list. After a fresh open these references
    are NULL. Assign the old children to the new table. Some of them
    might also be reopened or will be reopened soon.

    Other action is to verify that the table definition with respect to
    the UNION list did not change.

  @note
    This function terminates the child list if the respective '*_last'
    pointer is non-NULL. Do not call it from a place where the list is
    embedded in another list and this would break it.

    Terminating the list is required for example in the first
    reopen_table() after open_tables(). open_tables() requires the end
    of the list not to be terminated because other tables could follow
    behind the child list.

    If a '*_last' pointer is NULL, the respective list is assumed to be
    NULL terminated.
*/

bool fix_merge_after_open(TABLE_LIST *old_child_list, TABLE_LIST **old_last,
                          TABLE_LIST *new_child_list, TABLE_LIST **new_last)
{
  bool mismatch= FALSE;
  DBUG_ENTER("fix_merge_after_open");
  DBUG_PRINT("myrg", ("old last addr: 0x%lx  new last addr: 0x%lx",
                      (long) old_last, (long) new_last));

  /* Terminate the lists for easier check of list end. */
  if (old_last)
    *old_last= NULL;
  if (new_last)
    *new_last= NULL;

  for (;;)
  {
    DBUG_PRINT("myrg", ("old list item: 0x%lx  new list item: 0x%lx",
                        (long) old_child_list, (long) new_child_list));
    /* Break if one of the list is at its end. */
    if (!old_child_list || !new_child_list)
      break;
    /* Old table has references to child TABLEs. */
    DBUG_ASSERT(old_child_list->table);
    /* New table does not yet have references to child TABLEs. */
    DBUG_ASSERT(!new_child_list->table);
    DBUG_PRINT("myrg", ("old table: '%s'.'%s'  new table: '%s'.'%s'",
                        old_child_list->db, old_child_list->table_name,
                        new_child_list->db, new_child_list->table_name));
    /* Child db.table names must match. */
    if (strcmp(old_child_list->table_name, new_child_list->table_name) ||
        strcmp(old_child_list->db,         new_child_list->db))
      break;
    /*
      Copy TABLE reference. Child TABLE objects are still in place
      though not necessarily open yet.
    */
    DBUG_PRINT("myrg", ("old table ref: 0x%lx  replaces new table ref: 0x%lx",
                        (long) old_child_list->table,
                        (long) new_child_list->table));
    new_child_list->table= old_child_list->table;
    /* Step both lists. */
    old_child_list= old_child_list->next_global;
    new_child_list= new_child_list->next_global;
  }
  DBUG_PRINT("myrg", ("end of list, mismatch: %d", mismatch));
  /*
    If the list pointers are not both NULL after the loop, then the
    lists differ. If the are both identical, but not NULL, then they
    have at least one table in common and hence the rest of the list
    would be identical too. But in this case the loop woul run until the
    list end, where both pointers would become NULL.
  */
  if (old_child_list != new_child_list)
    mismatch= TRUE;
  if (mismatch)
    my_error(ER_TABLE_DEF_CHANGED, MYF(0));

  DBUG_RETURN(mismatch);
}


igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4358 4359 4360 4361 4362 4363
/*
  Open all tables in list

  SYNOPSIS
    open_tables()
    thd - thread handler
4364
    start - list of tables in/out
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4365
    counter - number of opened tables will be return using this parameter
4366 4367 4368
    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.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4369

4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380
  NOTE
    Unless we are already in prelocked mode, 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. If resulting
    tables list will be non empty it will mark query as requiring precaching.
    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.

4381 4382 4383 4384 4385
    If any table has a trigger and start->trg_event_map is non-zero
    the final lock will end up in thd->locked_tables, otherwise, the
    lock will be placed in thd->lock. See also comments in
    st_lex::set_trg_event_type_for_tables().

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4386 4387 4388 4389 4390
  RETURN
    0  - OK
    -1 - error
*/

4391
int open_tables(THD *thd, TABLE_LIST **start, uint *counter, uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4392
{
4393
  TABLE_LIST *tables= NULL;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4394 4395
  bool refresh;
  int result=0;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4396
  MEM_ROOT new_frm_mem;
4397 4398
  /* Also used for indicating that prelocking is need */
  TABLE_LIST **query_tables_last_own;
4399 4400
  bool safe_to_ignore_table;

4401
  DBUG_ENTER("open_tables");
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4402 4403 4404 4405
  /*
    temporary mem_root for new .frm parsing.
    TODO: variables for size
  */
4406
  init_sql_alloc(&new_frm_mem, 8024, 8024);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4407

4408
  thd->current_tablenr= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4409
 restart:
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4410
  *counter= 0;
4411
  query_tables_last_own= 0;
4412
  thd_proc_info(thd, "Opening tables");
4413 4414 4415 4416 4417 4418 4419

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

  */
4420 4421

  if (!thd->prelocked_mode && !thd->lex->requires_prelocking() &&
4422
      thd->lex->uses_stored_routines())
4423
  {
4424
    bool first_no_prelocking, need_prelocking;
4425
    TABLE_LIST **save_query_tables_last= thd->lex->query_tables_last;
4426 4427

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

4430
    if (sp_cache_routines_and_add_tables(thd, thd->lex, first_no_prelocking))
4431
    {
4432 4433 4434 4435 4436 4437
      /*
        Serious error during reading stored routines from mysql.proc table.
        Something's wrong with the table or its contents, and an error has
        been emitted; we must abort.
      */
      result= -1;
4438 4439
      goto err;
    }
4440
    else if (need_prelocking)
4441 4442 4443 4444 4445 4446
    {
      query_tables_last_own= save_query_tables_last;
      *start= thd->lex->query_tables;
    }
  }

4447 4448 4449 4450
  /*
    For every table in the list of tables to open, try to find or open
    a table.
  */
4451
  for (tables= *start; tables ;tables= tables->next_global)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4452
  {
4453 4454 4455
    DBUG_PRINT("tcache", ("opening table: '%s'.'%s'  item: 0x%lx",
                          tables->db, tables->table_name, (long) tables));

4456
    safe_to_ignore_table= FALSE;
4457

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4458 4459 4460
    /*
      Ignore placeholders for derived tables. After derived tables
      processing, link to created temporary table will be put here.
4461 4462
      If this is derived table for view then we still want to process
      routines used by this view.
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4463 4464
     */
    if (tables->derived)
4465 4466 4467
    {
      if (tables->view)
        goto process_view_routines;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4468
      continue;
4469
    }
4470 4471 4472 4473 4474 4475
    /*
      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.
    */
4476 4477
    if (tables->schema_table)
    {
4478 4479 4480 4481 4482 4483 4484 4485 4486 4487
      /*
        If this information_schema table is merged into a mergeable
        view, ignore it for now -- it will be filled when its respective
        TABLE_LIST is processed. This code works only during re-execution.
      */
      if (tables->view)
        goto process_view_routines;
      if (!mysql_schema_table(thd, thd->lex, tables) &&
          !check_and_update_table_version(thd, tables, tables->table->s))
      {
4488
        continue;
4489
      }
4490 4491
      DBUG_RETURN(-1);
    }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4492
    (*counter)++;
4493 4494 4495 4496 4497

    /*
      Not a placeholder: must be a base table or a view, and the table is
      not opened yet. Try to open the table.
    */
4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516
    if (!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);
        tables->table= open_table(thd, tables, &new_frm_mem, &refresh, flags);
        thd->pop_internal_handler();
        safe_to_ignore_table= prelock_handler.safely_trapped_errors();
      }
      else
        tables->table= open_table(thd, tables, &new_frm_mem, &refresh, flags);
    }
4517 4518 4519 4520
    else
      DBUG_PRINT("tcache", ("referenced table: '%s'.'%s' 0x%lx",
                            tables->db, tables->table_name,
                            (long) tables->table));
4521 4522

    if (!tables->table)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4523
    {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4524
      free_root(&new_frm_mem, MYF(MY_KEEP_PREALLOC));
4525

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4526 4527
      if (tables->view)
      {
4528
        /* VIEW placeholder */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4529
	(*counter)--;
4530

4531
        /*
4532 4533 4534 4535 4536
          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
4537 4538 4539
          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.
4540
        */
4541
        if (query_tables_last_own == &(tables->next_global) &&
4542 4543
            tables->view->query_tables)
          query_tables_last_own= tables->view->query_tables_last;
4544
        /*
4545 4546
          Let us free memory used by 'sroutines' hash here since we never
          call destructor for this LEX.
4547
        */
4548
        hash_free(&tables->view->sroutines);
4549
	goto process_view_routines;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4550 4551
      }

4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564
      /*
        If in a MERGE table open, we need to remove the children list
        from statement table list before restarting. Otherwise the list
        will be inserted another time.
      */
      if (tables->parent_l)
      {
        TABLE_LIST *parent_l= tables->parent_l;
        /* The parent table should be correctly open at this point. */
        DBUG_ASSERT(parent_l->table);
        parent_l->next_global= *parent_l->table->child_last_l;
      }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4565 4566
      if (refresh)				// Refresh in progress
      {
4567
        /*
4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579
          We have met name-locked or old version of table. Now we have
          to close all tables which are not up to date. We also have to
          throw away set of prelocked tables (and thus close tables from
          this set that were open by now) since it possible that one of
          tables which determined its content was changed.

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

          In order to prepare for recalculation of set of prelocked tables
          we pretend that we have finished calculation which we were doing
          currently.
4580 4581 4582
        */
        if (query_tables_last_own)
          thd->lex->mark_as_requiring_prelocking(query_tables_last_own);
4583
        close_tables_for_reopen(thd, start);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4584 4585
	goto restart;
      }
4586 4587 4588 4589 4590 4591 4592 4593

      if (safe_to_ignore_table)
      {
        DBUG_PRINT("info", ("open_table: ignoring table '%s'.'%s'",
                            tables->db, tables->alias));
        continue;
      }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4594 4595 4596
      result= -1;				// Fatal error
      break;
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4597
    else
4598 4599 4600 4601 4602 4603 4604 4605 4606 4607
    {
      /*
        If we are not already in prelocked mode and extended table list is not
        yet built and we have trigger for table being opened then we should
        cache all routines used by its triggers and add their tables to
        prelocking list.
        If we lock table for reading we won't update it so there is no need to
        process its triggers since they never will be activated.
      */
      if (!thd->prelocked_mode && !thd->lex->requires_prelocking() &&
4608
          tables->trg_event_map && tables->table->triggers &&
4609 4610 4611
          tables->lock_type >= TL_WRITE_ALLOW_WRITE)
      {
        if (!query_tables_last_own)
4612 4613
          query_tables_last_own= thd->lex->query_tables_last;
        if (sp_cache_routines_and_add_tables_for_triggers(thd, thd->lex,
4614
                                                          tables))
4615
        {
4616 4617 4618 4619 4620 4621
          /*
            Serious error during reading stored routines from mysql.proc table.
            Something's wrong with the table or its contents, and an error has
            been emitted; we must abort.
          */
          result= -1;
4622 4623
          goto err;
        }
4624
      }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4625
      free_root(&new_frm_mem, MYF(MY_KEEP_PREALLOC));
4626
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4627

4628
    if (tables->lock_type != TL_UNLOCK && ! thd->locked_tables)
4629 4630 4631 4632 4633 4634
    {
      if (tables->lock_type == TL_WRITE_DEFAULT)
        tables->table->reginfo.lock_type= thd->update_lock_default;
      else if (tables->table->s->tmp_table == NO_TMP_TABLE)
        tables->table->reginfo.lock_type= tables->lock_type;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4635
    tables->table->grant= tables->grant;
4636

4637
    /* Check and update metadata version of a base table. */
4638 4639 4640 4641 4642 4643
    if (check_and_update_table_version(thd, tables, tables->table->s))
    {
      result= -1;
      goto err;
    }

4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661
    /* Attach MERGE children if not locked already. */
    DBUG_PRINT("tcache", ("is parent: %d  is child: %d",
                          test(tables->table->child_l),
                          test(tables->parent_l)));
    DBUG_PRINT("tcache", ("in lock tables: %d  in prelock mode: %d",
                          test(thd->locked_tables), test(thd->prelocked_mode)));
    if (((!thd->locked_tables && !thd->prelocked_mode) ||
         tables->table->s->tmp_table) &&
        ((tables->table->child_l &&
          add_merge_table_list(tables)) ||
         (tables->parent_l &&
          (&tables->next_global == tables->parent_l->table->child_last_l) &&
          attach_merge_children(tables))))
    {
      result= -1;
      goto err;
    }

4662 4663 4664 4665 4666 4667 4668
process_view_routines:
    /*
      Again we may need cache all routines used by this view and add
      tables used by them to table list.
    */
    if (tables->view && !thd->prelocked_mode &&
        !thd->lex->requires_prelocking() &&
4669
        tables->view->uses_stored_routines())
4670 4671 4672 4673
    {
      /* We have at least one table in TL here. */
      if (!query_tables_last_own)
        query_tables_last_own= thd->lex->query_tables_last;
4674
      if (sp_cache_routines_and_add_tables_for_view(thd, thd->lex, tables))
4675
      {
4676 4677
        /*
          Serious error during reading stored routines from mysql.proc table.
4678
          Something is wrong with the table or its contents, and an error has
4679 4680 4681
          been emitted; we must abort.
        */
        result= -1;
4682 4683
        goto err;
      }
4684
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4685
  }
4686 4687

 err:
4688
  thd_proc_info(thd, 0);
4689
  free_root(&new_frm_mem, MYF(0));              // Free pre-alloced block
4690 4691 4692 4693

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

4694 4695 4696 4697 4698 4699 4700 4701
  if (result && tables)
  {
    /*
      Some functions determine success as (tables->table != NULL).
      tables->table is in thd->open_tables. It won't go lost. If the
      error happens on a MERGE child, clear the parents TABLE reference.
    */
    if (tables->parent_l)
4702 4703 4704
    {
      if (tables->parent_l->next_global == tables->parent_l->table->child_l)
        tables->parent_l->next_global= *tables->parent_l->table->child_last_l;
4705
      tables->parent_l->table= NULL;
4706
    }
4707 4708 4709
    tables->table= NULL;
  }
  DBUG_PRINT("tcache", ("returning: %d", result));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4710 4711 4712 4713
  DBUG_RETURN(result);
}


4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736
/*
  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)
  {
4737
    my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),table->alias);
4738 4739
    DBUG_RETURN(1);
  }
serg@serg.mylan's avatar
serg@serg.mylan committed
4740
  if ((error=table->file->start_stmt(thd, lock_type)))
4741 4742 4743 4744 4745 4746 4747 4748
  {
    table->file->print_error(error,MYF(0));
    DBUG_RETURN(1);
  }
  DBUG_RETURN(0);
}


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

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

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

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

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

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

TABLE *open_n_lock_single_table(THD *thd, TABLE_LIST *table_l,
                                thr_lock_type lock_type)
{
  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. */
  if (simple_open_n_lock_tables(thd, table_l))
    table_l->table= NULL; /* Just to be sure. */

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

  DBUG_RETURN(table_l->table);
}


4806 4807 4808 4809 4810 4811 4812 4813
/*
  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
4814
    lock_flags          Flags passed to mysql_lock_table
4815

4816 4817 4818 4819 4820
  NOTE
    This function don't do anything like SP/SF/views/triggers analysis done
    in open_tables(). It is intended for opening of only one concrete table.
    And used only in special contexts.

4821 4822 4823 4824 4825 4826 4827 4828 4829
  RETURN VALUES
    table		Opened table
    0			Error
  
    If ok, the following are also set:
      table_list->lock_type 	lock_type
      table_list->table		table
*/

4830 4831
TABLE *open_ltable(THD *thd, TABLE_LIST *table_list, thr_lock_type lock_type,
                   uint lock_flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4832 4833 4834 4835 4836
{
  TABLE *table;
  bool refresh;
  DBUG_ENTER("open_ltable");

4837
  thd_proc_info(thd, "Opening table");
4838
  thd->current_tablenr= 0;
4839 4840
  /* open_ltable can be used only for BASIC TABLEs */
  table_list->required_type= FRMTYPE_TABLE;
4841
  while (!(table= open_table(thd, table_list, thd->mem_root, &refresh, 0)) &&
4842
         refresh)
4843
    ;
4844

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4845 4846
  if (table)
  {
4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857
    if (table->child_l)
    {
      /* 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 */
    }

4858 4859
    table_list->lock_type= lock_type;
    table_list->table=	   table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4860 4861 4862
    table->grant= table_list->grant;
    if (thd->locked_tables)
    {
4863 4864 4865 4866 4867
      if (check_lock_and_start_stmt(thd, table, lock_type))
	table= 0;
    }
    else
    {
4868
      DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
4869
      if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)
4870 4871
	if (! (thd->lock= mysql_lock_tables(thd, &table_list->table, 1,
                                            lock_flags, &refresh)))
4872
	  table= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4873 4874
    }
  }
4875 4876

 end:
4877
  thd_proc_info(thd, 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4878 4879 4880
  DBUG_RETURN(table);
}

4881

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4882
/*
4883
  Open all tables in list, locks them and optionally process derived tables.
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4884 4885

  SYNOPSIS
4886
    open_and_lock_tables_derived()
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4887 4888
    thd		- thread handler
    tables	- list of tables for open&locking
4889
    derived     - if to handle derived tables
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4890 4891

  RETURN
4892 4893
    FALSE - ok
    TRUE  - error
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4894 4895

  NOTE
4896
    The lock will automaticaly be freed by close_thread_tables()
4897 4898 4899 4900 4901 4902 4903

  NOTE
    There are two convenience functions:
    - 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.
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4904 4905
*/

4906
int open_and_lock_tables_derived(THD *thd, TABLE_LIST *tables, bool derived)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4907 4908
{
  uint counter;
4909
  bool need_reopen;
4910 4911
  DBUG_ENTER("open_and_lock_tables_derived");
  DBUG_PRINT("enter", ("derived handling: %d", derived));
4912 4913 4914 4915 4916

  for ( ; ; ) 
  {
    if (open_tables(thd, &tables, &counter, 0))
      DBUG_RETURN(-1);
4917 4918 4919 4920 4921 4922 4923

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

4924 4925 4926 4927
    if (!lock_tables(thd, tables, counter, &need_reopen))
      break;
    if (!need_reopen)
      DBUG_RETURN(-1);
4928
    close_tables_for_reopen(thd, &tables);
4929
  }
4930 4931 4932 4933
  if (derived &&
      (mysql_handle_derived(thd->lex, &mysql_derived_prepare) ||
       (thd->fill_derived_tables() &&
        mysql_handle_derived(thd->lex, &mysql_derived_filling))))
4934
    DBUG_RETURN(TRUE); /* purecov: inspected */
monty@mysql.com's avatar
monty@mysql.com committed
4935
  DBUG_RETURN(0);
monty@mysql.com's avatar
monty@mysql.com committed
4936 4937 4938
}


4939 4940 4941 4942 4943 4944
/*
  Open all tables in list and process derived tables

  SYNOPSIS
    open_normal_and_derived_tables
    thd		- thread handler
4945
    tables	- list of tables for open
4946 4947 4948
    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.
4949 4950 4951 4952 4953 4954 4955 4956 4957 4958

  RETURN
    FALSE - ok
    TRUE  - error

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

4959
bool open_normal_and_derived_tables(THD *thd, TABLE_LIST *tables, uint flags)
4960 4961 4962
{
  uint counter;
  DBUG_ENTER("open_normal_and_derived_tables");
monty@mysql.com's avatar
monty@mysql.com committed
4963
  DBUG_ASSERT(!thd->fill_derived_tables());
4964
  if (open_tables(thd, &tables, &counter, flags) ||
monty@mysql.com's avatar
monty@mysql.com committed
4965 4966 4967
      mysql_handle_derived(thd->lex, &mysql_derived_prepare))
    DBUG_RETURN(TRUE); /* purecov: inspected */
  DBUG_RETURN(0);
4968 4969 4970
}


4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986
/*
  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)
4987
    if (!table->placeholder())
4988 4989 4990 4991
      table->table->query_id= 0;
}


4992 4993
/**
   Decide on logging format to use for the statement.
4994

4995 4996 4997 4998
   Compute the capabilities vector for the involved storage engines
   and mask out the flags for the binary log. Right now, the binlog
   flags only include the capabilities of the storage engines, so this
   is safe.
4999

5000 5001
   We now have three alternatives that prevent the statement from
   being loggable:
5002

5003 5004 5005
   1. If there are no capabilities left (all flags are clear) it is
      not possible to log the statement at all, so we roll back the
      statement and report an error.
5006

5007 5008
   2. Statement mode is set, but the capabilities indicate that
      statement format is not possible.
5009

5010 5011
   3. Row mode is set, but the capabilities indicate that row
      format is not possible.
5012

5013 5014 5015 5016 5017 5018
   4. Statement is unsafe, but the capabilities indicate that row
      format is not possible.

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

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

5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031
   2. If statement-based logging is not possible, row-based logging is
      used.

   3. Otherwise, statement-based logging is used.

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

int decide_logging_format(THD *thd, TABLE_LIST *tables)
{
  if (mysql_bin_log.is_open() && (thd->options & OPTION_BIN_LOG))
5032
  {
5033 5034 5035 5036
    handler::Table_flags flags_some_set= handler::Table_flags();
    handler::Table_flags flags_all_set= ~handler::Table_flags();
    my_bool multi_engine= FALSE;
    void* prev_ht= NULL;
5037
    for (TABLE_LIST *table= tables; table; table= table->next_global)
5038
    {
5039 5040
      if (!table->placeholder() && table->lock_type >= TL_WRITE_ALLOW_WRITE)
      {
5041
        ulonglong const flags= table->table->file->ha_table_flags();
5042
        DBUG_PRINT("info", ("table: %s; ha_table_flags: %s%s",
5043
                            table->table_name,
5044 5045
                            FLAGSTR(flags, HA_BINLOG_STMT_CAPABLE),
                            FLAGSTR(flags, HA_BINLOG_ROW_CAPABLE)));
5046 5047 5048 5049 5050
        if (prev_ht && prev_ht != table->table->file->ht)
          multi_engine= TRUE;
        prev_ht= table->table->file->ht;
        flags_all_set &= flags;
        flags_some_set |= flags;
5051
      }
5052 5053 5054 5055 5056 5057 5058 5059
    }

    DBUG_PRINT("info", ("flags_all_set: %s%s",
                        FLAGSTR(flags_all_set, HA_BINLOG_STMT_CAPABLE),
                        FLAGSTR(flags_all_set, HA_BINLOG_ROW_CAPABLE)));
    DBUG_PRINT("info", ("flags_some_set: %s%s",
                        FLAGSTR(flags_some_set, HA_BINLOG_STMT_CAPABLE),
                        FLAGSTR(flags_some_set, HA_BINLOG_ROW_CAPABLE)));
5060 5061
    DBUG_PRINT("info", ("thd->variables.binlog_format: %ld",
                        thd->variables.binlog_format));
5062 5063
    DBUG_PRINT("info", ("multi_engine: %s",
                        multi_engine ? "TRUE" : "FALSE"));
5064 5065

    int error= 0;
5066
    if (flags_all_set == 0)
5067
    {
5068 5069 5070
      my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
               "Statement cannot be logged to the binary log in"
               " row-based nor statement-based format");
5071 5072
    }
    else if (thd->variables.binlog_format == BINLOG_FORMAT_STMT &&
5073
             (flags_all_set & HA_BINLOG_STMT_CAPABLE) == 0)
5074
    {
5075 5076 5077
      my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
                "Statement-based format required for this statement,"
                " but not allowed by this combination of engines");
5078 5079 5080
    }
    else if ((thd->variables.binlog_format == BINLOG_FORMAT_ROW ||
              thd->lex->is_stmt_unsafe()) &&
5081
             (flags_all_set & HA_BINLOG_ROW_CAPABLE) == 0)
5082
    {
5083 5084 5085
      my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
                "Row-based format required for this statement,"
                " but not allowed by this combination of engines");
5086 5087
    }

5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103
    /*
      If more than one engine is involved in the statement and at
      least one is doing it's own logging (is *self-logging*), the
      statement cannot be logged atomically, so we generate an error
      rather than allowing the binlog to become corrupt.
     */
    if (multi_engine &&
        (flags_some_set & HA_HAS_OWN_BINLOGGING))
    {
      error= ER_BINLOG_LOGGING_IMPOSSIBLE;
      my_error(error, MYF(0),
               "Statement cannot be written atomically since more"
               " than one engine involved and at least one engine"
               " is self-logging");
    }

5104 5105 5106
    DBUG_PRINT("info", ("error: %d", error));

    if (error)
5107
      return -1;
5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119

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

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

      Observe that point to cannot be decided before the tables
      involved in a statement has been checked, i.e., we cannot put
      this code in reset_current_stmt_binlog_row_based(), it has to be
      here.
5120
    */
5121
    if (thd->lex->is_stmt_unsafe() ||
5122
        (flags_all_set & HA_BINLOG_STMT_CAPABLE) == 0)
5123 5124 5125 5126
    {
      thd->set_current_stmt_binlog_row_based_if_mixed();
    }
  }
5127

5128 5129 5130
  return 0;
}

5131 5132 5133 5134 5135 5136 5137
/*
  Lock all tables in list

  SYNOPSIS
    lock_tables()
    thd			Thread handler
    tables		Tables to lock
5138 5139 5140 5141 5142 5143
    count		Number of opened tables
    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).
5144

5145 5146 5147 5148 5149
  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.

5150 5151 5152 5153
    If query for which we are calling this function marked as requring
    prelocking, this function will do implicit LOCK TABLES and change
    thd::prelocked_mode accordingly.

5154 5155 5156 5157 5158
  RETURN VALUES
   0	ok
   -1	Error
*/

5159
int lock_tables(THD *thd, TABLE_LIST *tables, uint count, bool *need_reopen)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5160
{
5161
  TABLE_LIST *table;
5162 5163 5164 5165 5166 5167 5168

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

5171
  if (!tables && !thd->lex->requires_prelocking())
5172
    DBUG_RETURN(decide_logging_format(thd, tables));
5173

5174 5175 5176 5177 5178 5179 5180 5181 5182 5183
  /*
    We need this extra check for thd->prelocked_mode because we want to avoid
    attempts to lock tables in substatements. Checking for thd->locked_tables
    is not enough in some situations. For example for SP containing
    "drop table t3; create temporary t3 ..; insert into t3 ...;"
    thd->locked_tables may be 0 after drop tables, and without this extra
    check insert will try to lock temporary table t3, that will lead
    to memory leak...
  */
  if (!thd->locked_tables && !thd->prelocked_mode)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5184
  {
5185
    DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5186
    TABLE **start,**ptr;
5187
    uint lock_flag= MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN;
5188

5189
    if (!(ptr=start=(TABLE**) thd->alloc(sizeof(TABLE*)*count)))
5190
      DBUG_RETURN(-1);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5191
    for (table= tables; table; table= table->next_global)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5192
    {
5193
      if (!table->placeholder())
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5194 5195
	*(ptr++)= table->table;
    }
5196 5197 5198 5199 5200 5201

    /* We have to emulate LOCK TABLES if we are statement needs prelocking. */
    if (thd->lex->requires_prelocking())
    {
      thd->in_lock_tables=1;
      thd->options|= OPTION_TABLE_LOCK;
5202 5203 5204 5205 5206 5207 5208 5209
      /*
        If we have >= 2 different tables to update with auto_inc columns,
        statement-based binlogging won't work. We can solve this problem in
        mixed mode by switching to row-based binlogging:
      */
      if (thd->variables.binlog_format == BINLOG_FORMAT_MIXED &&
          has_two_write_locked_tables_with_auto_increment(tables))
      {
5210
        thd->lex->set_stmt_unsafe();
5211 5212
        thd->set_current_stmt_binlog_row_based_if_mixed();
      }
5213 5214
    }

5215
    if (! (thd->lock= mysql_lock_tables(thd, start, (uint) (ptr - start),
5216
                                        lock_flag, need_reopen)))
5217 5218 5219
    {
      if (thd->lex->requires_prelocking())
      {
5220
        thd->options&= ~(OPTION_TABLE_LOCK);
5221 5222 5223 5224
        thd->in_lock_tables=0;
      }
      DBUG_RETURN(-1);
    }
5225

5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243
    if (thd->lex->requires_prelocking() &&
        thd->lex->sql_command != SQLCOM_LOCK_TABLES)
    {
      TABLE_LIST *first_not_own= thd->lex->first_not_own_table();
      /*
        We just have done implicit LOCK TABLES, and now we have
        to emulate first open_and_lock_tables() after it.

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

5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254
      /*
        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)
5255
      {
5256
        if (!table->placeholder())
5257 5258 5259 5260 5261 5262
        {
          table->table->query_id= thd->query_id;
          if (check_lock_and_start_stmt(thd, table->table, table->lock_type))
          {
            mysql_unlock_tables(thd, thd->locked_tables);
            thd->locked_tables= 0;
5263
            thd->options&= ~(OPTION_TABLE_LOCK);
5264 5265 5266 5267 5268 5269 5270 5271 5272
            DBUG_RETURN(-1);
          }
        }
      }
      /*
        Let us mark all tables which don't belong to the statement itself,
        and was marked as occupied during open_tables() as free for reuse.
      */
      mark_real_tables_as_free_for_reuse(first_not_own);
5273
      DBUG_PRINT("info",("prelocked_mode= PRELOCKED"));
5274 5275
      thd->prelocked_mode= PRELOCKED;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5276
  }
5277 5278
  else
  {
5279
    TABLE_LIST *first_not_own= thd->lex->first_not_own_table();
5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290
    /*
      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)
5291
    {
5292
      if (!table->placeholder() &&
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5293
	  check_lock_and_start_stmt(thd, table->table, table->lock_type))
5294
      {
5295
	DBUG_RETURN(-1);
5296 5297
      }
    }
5298 5299 5300 5301 5302 5303 5304 5305
    /*
      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);
5306
      DBUG_PRINT("info", ("thd->prelocked_mode= PRELOCKED_UNDER_LOCK_TABLES"));
5307 5308
      thd->prelocked_mode= PRELOCKED_UNDER_LOCK_TABLES;
    }
5309
  }
5310 5311

  DBUG_RETURN(decide_logging_format(thd, tables));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5312 5313
}

5314

5315 5316 5317 5318 5319 5320
/*
  Prepare statement for reopening of tables and recalculation of set of
  prelocked tables.

  SYNOPSIS
    close_tables_for_reopen()
5321 5322
      thd    in     Thread context
      tables in/out List of tables which we were trying to open and lock
5323 5324 5325

*/

5326
void close_tables_for_reopen(THD *thd, TABLE_LIST **tables)
5327
{
5328 5329 5330 5331 5332 5333
  /*
    If table list consists only from tables from prelocking set, table list
    for new attempt should be empty, so we have to update list's root pointer.
  */
  if (thd->lex->first_not_own_table() == *tables)
    *tables= 0;
5334 5335
  thd->lex->chop_off_not_own_tables();
  sp_remove_not_own_routines(thd->lex);
5336 5337
  for (TABLE_LIST *tmp= *tables; tmp; tmp= tmp->next_global)
    tmp->table= 0;
5338 5339 5340 5341
  close_thread_tables(thd);
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
5342
/*
5343
  Open a single table without table caching and don't set it in open_list
5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359

  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
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5360 5361 5362 5363 5364 5365
*/

TABLE *open_temporary_table(THD *thd, const char *path, const char *db,
			    const char *table_name, bool link_in_list)
{
  TABLE *tmp_table;
5366
  TABLE_SHARE *share;
5367 5368 5369
  char cache_key[MAX_DBKEY_LENGTH], *saved_cache_key, *tmp_path;
  uint key_length;
  TABLE_LIST table_list;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5370
  DBUG_ENTER("open_temporary_table");
5371 5372 5373 5374 5375
  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));
5376

5377 5378 5379 5380 5381 5382 5383 5384
  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))))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5385 5386
    DBUG_RETURN(0);				/* purecov: inspected */

5387 5388 5389 5390 5391
  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);

5392
  init_tmp_table_share(thd, share, saved_cache_key, key_length,
5393 5394 5395 5396 5397 5398 5399 5400
                       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,
5401
                            tmp_table, FALSE))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5402
  {
5403 5404
    /* No need to lock share->mutex as this is not needed for tmp tables */
    free_table_share(share);
5405
    my_free((char*) tmp_table,MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5406 5407 5408
    DBUG_RETURN(0);
  }

5409
  tmp_table->reginfo.lock_type= TL_WRITE;	 // Simulate locked
5410
  share->tmp_table= (tmp_table->file->has_transactions() ? 
5411
                     TRANSACTIONAL_TMP_TABLE : NON_TRANSACTIONAL_TMP_TABLE);
5412

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5413 5414
  if (link_in_list)
  {
5415 5416 5417 5418
    /* growing temp list at the head */
    tmp_table->next= thd->temporary_tables;
    if (tmp_table->next)
      tmp_table->next->prev= tmp_table;
5419
    thd->temporary_tables= tmp_table;
5420
    thd->temporary_tables->prev= 0;
5421 5422
    if (thd->slave_thread)
      slave_open_temp_tables++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5423
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5424
  tmp_table->pos_in_table_list= 0;
5425 5426
  DBUG_PRINT("tmptable", ("opened table: '%s'.'%s' 0x%lx", tmp_table->s->db.str,
                          tmp_table->s->table_name.str, (long) tmp_table));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5427 5428 5429 5430
  DBUG_RETURN(tmp_table);
}


5431
bool rm_temporary_table(handlerton *base, char *path)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5432 5433
{
  bool error=0;
5434 5435
  handler *file;
  char *ext;
5436 5437
  DBUG_ENTER("rm_temporary_table");

5438
  strmov(ext= strend(path), reg_ext);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5439 5440
  if (my_delete(path,MYF(0)))
    error=1; /* purecov: inspected */
5441 5442
  *ext= 0;				// remove extension
  file= get_new_handler((TABLE_SHARE*) 0, current_thd->mem_root, base);
5443
  if (file && file->ha_delete_table(path))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5444
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5445
    error=1;
5446
    sql_print_warning("Could not remove temporary table: '%s', error: %d",
serg@serg.mylan's avatar
serg@serg.mylan committed
5447
                      path, my_errno);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5448
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5449
  delete file;
5450
  DBUG_RETURN(error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5451 5452 5453 5454
}


/*****************************************************************************
5455 5456 5457 5458 5459 5460
* 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.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5461 5462
******************************************************************************/

5463
/* Special Field pointers as return values of find_field_in_XXX functions. */
5464 5465
Field *not_found_field= (Field*) 0x1;
Field *view_ref_found= (Field*) 0x2; 
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5466

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5467 5468
#define WRONG_GRANT (Field*) -1

5469 5470
static void update_field_dependencies(THD *thd, Field *field, TABLE *table)
{
5471 5472
  DBUG_ENTER("update_field_dependencies");
  if (thd->mark_used_columns != MARK_COLUMNS_NONE)
5473
  {
5474 5475 5476 5477 5478 5479 5480
    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).
    */
      
5481
    table->covering_keys.intersect(field->part_of_key);
5482 5483 5484
    table->merge_keys.merge(field->part_of_key);

    if (thd->mark_used_columns == MARK_COLUMNS_READ)
5485
    {
5486 5487
      current_bitmap= table->read_set;
      other_bitmap=   table->write_set;
5488 5489
    }
    else
5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512
    {
      current_bitmap= table->write_set;
      other_bitmap=   table->read_set;
    }

    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)
5513
    field->flags|= GET_FIXED_FIELDS_FLAG;
5514
  DBUG_VOID_RETURN;
5515 5516
}

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5517 5518

/*
5519
  Find a field by name in a view that uses merge algorithm.
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5520 5521

  SYNOPSIS
5522
    find_field_in_view()
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5523
    thd				thread handler
5524
    table_list			view to search for 'name'
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5525 5526
    name			name of field
    length			length of name
5527
    item_name                   name of item if it will be created (VIEW)
5528 5529
    ref				expression substituted in VIEW should be passed
                                using this reference (return view_ref_found)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5530
    register_tree_change        TRUE if ref is not stack variable and we
5531
                                need register changes in item tree
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5532 5533 5534 5535

  RETURN
    0			field is not found
    view_ref_found	found value in VIEW (real result is in *ref)
5536
    #			pointer to field - only for schema table fields
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5537 5538
*/

5539 5540
static Field *
find_field_in_view(THD *thd, TABLE_LIST *table_list,
5541 5542
                   const char *name, uint length,
                   const char *item_name, Item **ref,
5543
                   bool register_tree_change)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5544
{
5545 5546 5547 5548 5549 5550
  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);
gshchepa/uchum@gleb.loc's avatar
gshchepa/uchum@gleb.loc committed
5551
  Query_arena *arena= 0, backup;  
5552
  
5553 5554 5555
  DBUG_ASSERT(table_list->schema_table_reformed ||
              (ref != 0 && table_list->view != 0));
  for (; !field_it.end_of_fields(); field_it.next())
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5556
  {
5557
    if (!my_strcasecmp(system_charset_info, field_it.name(), name))
5558
    {
5559
      // in PS use own arena or data will be freed after prepare
gshchepa/uchum@gleb.loc's avatar
gshchepa/uchum@gleb.loc committed
5560
      if (register_tree_change && thd->stmt_arena->is_stmt_prepare_or_first_sp_execute())
5561
        arena= thd->activate_stmt_arena_if_needed(&backup);
5562 5563 5564 5565
      /*
        create_item() may, or may not create a new Item, depending on
        the column reference. See create_view_field() for details.
      */
5566
      Item *item= field_it.create_item(thd);
gshchepa/uchum@gleb.loc's avatar
gshchepa/uchum@gleb.loc committed
5567
      if (arena)
5568 5569
        thd->restore_active_arena(arena, &backup);
      
5570 5571 5572 5573 5574 5575
      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.
5576
       We need to set alias on both ref itself and on ref real item.
5577 5578
      */
      if (*ref && !(*ref)->is_autogenerated_name)
5579
      {
5580 5581
        item->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
5582 5583 5584
        item->real_item()->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
      }
5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612
      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

5613 5614 5615 5616 5617 5618
  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.

5619
  RETURN
5620 5621 5622
    NULL        if the field was not found
    WRONG_GRANT if no access rights to the found field
    #           Pointer to the found Field
5623 5624 5625 5626
*/

static Field *
find_field_in_natural_join(THD *thd, TABLE_LIST *table_ref, const char *name,
5627
                           uint length, Item **ref, bool register_tree_change,
5628
                           TABLE_LIST **actual_table)
5629
{
5630 5631
  List_iterator_fast<Natural_join_column>
    field_it(*(table_ref->join_columns));
5632
  Natural_join_column *nj_col, *curr_nj_col;
5633
  Field *found_field;
5634
  Query_arena *arena, backup;
5635
  DBUG_ENTER("find_field_in_natural_join");
5636
  DBUG_PRINT("enter", ("field name: '%s', ref 0x%lx",
5637 5638
		       name, (ulong) ref));
  DBUG_ASSERT(table_ref->is_natural_join && table_ref->join_columns);
5639
  DBUG_ASSERT(*actual_table == NULL);
5640

5641
  LINT_INIT(arena);
5642
  LINT_INIT(found_field);
5643

5644 5645
  for (nj_col= NULL, curr_nj_col= field_it++; curr_nj_col; 
       curr_nj_col= field_it++)
5646
  {
5647 5648 5649 5650 5651 5652 5653 5654 5655
    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;
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5656
  }
5657 5658
  if (!nj_col)
    DBUG_RETURN(NULL);
5659 5660 5661

  if (nj_col->view_field)
  {
monty@mysql.com's avatar
monty@mysql.com committed
5662
    Item *item;
5663
    LINT_INIT(arena);
5664 5665
    if (register_tree_change)
      arena= thd->activate_stmt_arena_if_needed(&backup);
5666 5667 5668 5669
    /*
      create_item() may, or may not create a new Item, depending on the
      column reference. See create_view_field() for details.
    */
monty@mysql.com's avatar
monty@mysql.com committed
5670
    item= nj_col->create_item(thd);
5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683
    /*
     *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);
    }
5684 5685 5686
    if (register_tree_change && arena)
      thd->restore_active_arena(arena, &backup);

5687 5688 5689 5690
    if (!item)
      DBUG_RETURN(NULL);
    DBUG_ASSERT(nj_col->table_field == NULL);
    if (nj_col->table_ref->schema_table_reformed)
5691
    {
5692 5693 5694 5695 5696 5697
      /*
        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);
5698
    }
5699 5700 5701 5702 5703 5704 5705 5706 5707 5708
    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);
5709
    DBUG_ASSERT(nj_col->table_ref->table == nj_col->table_field->table);
5710 5711 5712 5713 5714 5715 5716
    found_field= nj_col->table_field;
    update_field_dependencies(thd, found_field, nj_col->table_ref->table);
  }

  *actual_table= nj_col->table_ref;
  
  DBUG_RETURN(found_field);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5717 5718
}

5719

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5720
/*
5721
  Find field by name in a base table or a view with temp table algorithm.
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5722 5723

  SYNOPSIS
5724
    find_field_in_table()
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5725
    thd				thread handler
5726
    table			table where to search for the field
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5727 5728 5729
    name			name of field
    length			length of name
    allow_rowid			do allow finding of "_rowid" field?
5730 5731
    cached_field_index_ptr	cached position in field list (used to speedup
                                lookup for fields in prepared tables)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5732 5733

  RETURN
5734 5735
    0	field is not found
    #	pointer to field
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5736 5737
*/

5738 5739
Field *
find_field_in_table(THD *thd, TABLE *table, const char *name, uint length,
5740
                    bool allow_rowid, uint *cached_field_index_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5741
{
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5742 5743
  Field **field_ptr, *field;
  uint cached_field_index= *cached_field_index_ptr;
5744 5745
  DBUG_ENTER("find_field_in_table");
  DBUG_PRINT("enter", ("table: '%s', field name: '%s'", table->alias, name));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5746 5747

  /* We assume here that table->field < NO_CACHED_FIELD_INDEX = UINT_MAX */
5748
  if (cached_field_index < table->s->fields &&
5749
      !my_strcasecmp(system_charset_info,
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5750 5751
                     table->field[cached_field_index]->field_name, name))
    field_ptr= table->field + cached_field_index;
5752
  else if (table->s->name_hash.records)
5753
  {
5754
    field_ptr= (Field**) hash_search(&table->s->name_hash, (uchar*) name,
5755
                                     length);
5756 5757 5758 5759 5760 5761 5762 5763 5764
    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));
    }
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5765 5766 5767
  else
  {
    if (!(field_ptr= table->field))
5768
      DBUG_RETURN((Field *)0);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5769 5770 5771 5772 5773 5774
    for (; *field_ptr; ++field_ptr)
      if (!my_strcasecmp(system_charset_info, (*field_ptr)->field_name, name))
        break;
  }

  if (field_ptr && *field_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5775
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5776 5777
    *cached_field_index_ptr= field_ptr - table->field;
    field= *field_ptr;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5778 5779 5780
  }
  else
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5781 5782
    if (!allow_rowid ||
        my_strcasecmp(system_charset_info, name, "_rowid") ||
5783
        table->s->rowid_field_offset == 0)
5784
      DBUG_RETURN((Field*) 0);
5785
    field= table->field[table->s->rowid_field_offset-1];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5786 5787
  }

5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801
  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
5802
    length		   [in]  field length of name
5803 5804
    item_name              [in]  name of item if it will be created (VIEW)
    db_name                [in]  optional database name that qualifies the
5805
    table_name             [in]  optional table name that qualifies the field
5806 5807
    ref		       [in/out] if 'name' is resolved to a view field, ref
                                 is set to point to the found view field
5808
    check_privileges       [in]  check privileges
5809 5810 5811 5812 5813 5814 5815 5816 5817
    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.

timour@mysql.com's avatar
timour@mysql.com committed
5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829
  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.

5830 5831 5832 5833 5834 5835 5836 5837
  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,
5838 5839 5840
                        const char *name, uint length,
                        const char *item_name, const char *db_name,
                        const char *table_name, Item **ref,
5841 5842
                        bool check_privileges, bool allow_rowid,
                        uint *cached_field_index_ptr,
5843 5844 5845 5846
                        bool register_tree_change, TABLE_LIST **actual_table)
{
  Field *fld;
  DBUG_ENTER("find_field_in_table_ref");
5847 5848 5849
  DBUG_ASSERT(table_list->alias);
  DBUG_ASSERT(name);
  DBUG_ASSERT(item_name);
5850 5851 5852 5853 5854 5855
  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
timour@mysql.com's avatar
timour@mysql.com committed
5856 5857
    are the same as the table reference we are going to search for the field.

5858 5859 5860 5861
    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.
timour@mysql.com's avatar
timour@mysql.com committed
5862 5863 5864 5865 5866 5867

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

5868 5869
    TODO: Ensure that table_name, db_name and tables->db always points to
          something !
5870
  */
5871 5872
  if (/* Exclude nested joins. */
      (!table_list->nested_join ||
timour@mysql.com's avatar
timour@mysql.com committed
5873 5874 5875 5876 5877 5878
       /* Include merge views and information schema tables. */
       table_list->field_translation) &&
      /*
        Test if the field qualifiers match the table reference we plan
        to search.
      */
5879 5880
      table_name && table_name[0] &&
      (my_strcasecmp(table_alias_charset, table_list->alias, table_name) ||
5881 5882 5883 5884
       (db_name && db_name[0] && table_list->db && table_list->db[0] &&
        strcmp(db_name, table_list->db))))
    DBUG_RETURN(0);

5885
  *actual_table= NULL;
timour@mysql.com's avatar
timour@mysql.com committed
5886

5887 5888
  if (table_list->field_translation)
  {
timour@mysql.com's avatar
timour@mysql.com committed
5889
    /* 'table_list' is a view or an information schema table. */
5890
    if ((fld= find_field_in_view(thd, table_list, name, length, item_name, ref,
5891
                                 register_tree_change)))
5892 5893
      *actual_table= table_list;
  }
5894
  else if (!table_list->nested_join)
5895
  {
5896 5897
    /* 'table_list' is a stored table. */
    DBUG_ASSERT(table_list->table);
timour@mysql.com's avatar
timour@mysql.com committed
5898
    if ((fld= find_field_in_table(thd, table_list->table, name, length,
5899 5900
                                  allow_rowid,
                                  cached_field_index_ptr)))
timour@mysql.com's avatar
timour@mysql.com committed
5901 5902 5903
      *actual_table= table_list;
  }
  else
5904
  {
timour@mysql.com's avatar
timour@mysql.com committed
5905
    /*
timour@mysql.com's avatar
timour@mysql.com committed
5906 5907 5908 5909 5910
      '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.
timour@mysql.com's avatar
timour@mysql.com committed
5911
    */
5912 5913 5914 5915 5916 5917
    if (table_name && table_name[0])
    {
      List_iterator<TABLE_LIST> it(table_list->nested_join->join_list);
      TABLE_LIST *table;
      while ((table= it++))
      {
5918 5919
        if ((fld= find_field_in_table_ref(thd, table, name, length, item_name,
                                          db_name, table_name, ref,
5920 5921
                                          check_privileges, allow_rowid,
                                          cached_field_index_ptr,
5922 5923 5924 5925 5926 5927 5928
                                          register_tree_change, actual_table)))
          DBUG_RETURN(fld);
      }
      DBUG_RETURN(0);
    }
    /*
      Non-qualified field, search directly in the result columns of the
timour@mysql.com's avatar
timour@mysql.com committed
5929 5930 5931
      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.
5932 5933
    */
    fld= find_field_in_natural_join(thd, table_list, name, length, ref,
5934
                                    register_tree_change, actual_table);
5935
  }
5936

5937 5938
  if (fld)
  {
5939
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5940 5941 5942 5943 5944
    /* 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
5945
#endif
5946
      if (thd->mark_used_columns != MARK_COLUMNS_NONE)
5947
      {
5948
        /*
5949 5950 5951
          Get rw_set correct for this field so that the handler
          knows that this field is involved in the query and gets
          retrieved/updated
5952
         */
5953 5954 5955 5956 5957 5958
        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;
5959 5960 5961
          else
          {
            if (thd->mark_used_columns == MARK_COLUMNS_READ)
5962
              it->walk(&Item::register_field_in_read_map, 1, (uchar *) 0);
5963
          }
5964 5965 5966 5967
        }
        else
          field_to_set= fld;
        if (field_to_set)
5968 5969 5970 5971 5972 5973 5974
        {
          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);
        }
5975 5976
      }
  }
5977
  DBUG_RETURN(fld);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5978 5979
}

5980

5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999
/*
  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)
6000
  {
6001
    field_ptr= (Field**)hash_search(&table->s->name_hash,(uchar*) name,
6002
                                    strlen(name));
6003 6004 6005 6006 6007 6008 6009 6010 6011
    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));
    }
  }
6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026
  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;
}


6027 6028 6029 6030 6031
/*
  Find field in table list.

  SYNOPSIS
    find_field_in_tables()
6032 6033 6034 6035 6036 6037
    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
6038
                          point to the found view field
6039
    report_error	  Degree of error reporting:
6040 6041
                          - IGNORE_ERRORS then do not report any error
                          - IGNORE_EXCEPT_NON_UNIQUE report only non-unique
6042
                            fields, suppress all other errors
6043 6044 6045 6046
                          - REPORT_EXCEPT_NON_UNIQUE report all other errors
                            except when non-unique fields were found
                          - REPORT_ALL_ERRORS
    check_privileges      need to check privileges
6047 6048
    register_tree_change  TRUE if ref is not a stack variable and we
                          to need register changes in item tree
6049 6050

  RETURN VALUES
6051 6052 6053
    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.
6054 6055 6056 6057 6058
    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
6059
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6060 6061

Field *
6062 6063
find_field_in_tables(THD *thd, Item_ident *item,
                     TABLE_LIST *first_table, TABLE_LIST *last_table,
6064
		     Item **ref, find_item_error_report_type report_error,
6065
                     bool check_privileges, bool register_tree_change)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6066 6067
{
  Field *found=0;
6068 6069 6070
  const char *db= item->db_name;
  const char *table_name= item->table_name;
  const char *name= item->field_name;
6071
  uint length=(uint) strlen(name);
6072
  char name_buff[NAME_LEN+1];
6073 6074
  TABLE_LIST *cur_table= first_table;
  TABLE_LIST *actual_table;
6075 6076 6077 6078 6079 6080 6081 6082 6083
  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);
monty@mysql.com's avatar
monty@mysql.com committed
6084

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6085 6086 6087
  if (item->cached_table)
  {
    /*
6088 6089
      This shortcut is used by prepared statements. We assume that
      TABLE_LIST *first_table is not changed during query execution (which
6090
      is true for all queries except RENAME but luckily RENAME doesn't
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6091
      use fields...) so we can rely on reusing pointer to its member.
timour@mysql.com's avatar
timour@mysql.com committed
6092
      With this optimization we also miss case when addition of one more
6093
      field makes some prepared query ambiguous and so erroneous, but we
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6094 6095
      accept this trade off.
    */
6096 6097 6098 6099 6100 6101 6102 6103
    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,
6104
                                 TRUE, &(item->cached_field_index));
6105
    else
6106
      found= find_field_in_table_ref(thd, table_ref, name, length, item->name,
6107 6108
                                     NULL, NULL, ref, check_privileges,
                                     TRUE, &(item->cached_field_index),
6109 6110
                                     register_tree_change,
                                     &actual_table);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6111 6112 6113
    if (found)
    {
      if (found == WRONG_GRANT)
6114
	return (Field*) 0;
6115 6116 6117 6118 6119 6120

      /*
        Only views fields should be marked as dependent, not an underlying
        fields.
      */
      if (!table_ref->belong_to_view)
6121 6122
      {
        SELECT_LEX *current_sel= thd->lex->current_select;
6123
        SELECT_LEX *last_select= table_ref->select_lex;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6124 6125
        /*
          If the field was an outer referencee, mark all selects using this
6126
          sub query as dependent on the outer query
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6127
        */
6128
        if (current_sel != last_select)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6129
          mark_select_range_as_dependent(thd, last_select, current_sel,
6130 6131
                                         found, *ref, item);
      }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6132 6133 6134 6135
      return found;
    }
  }

6136 6137 6138
  if (db && lower_case_table_names)
  {
    /*
timour@mysql.com's avatar
timour@mysql.com committed
6139
      convert database to lower case for comparison.
6140 6141 6142 6143
      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);
monty@mysql.com's avatar
monty@mysql.com committed
6144
    my_casedn_str(files_charset_info, name_buff);
6145 6146
    db= name_buff;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6147

6148 6149 6150 6151 6152
  if (last_table)
    last_table= last_table->next_name_resolution_table;

  for (; cur_table != last_table ;
       cur_table= cur_table->next_name_resolution_table)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6153
  {
6154 6155
    Field *cur_field= find_field_in_table_ref(thd, cur_table, name, length,
                                              item->name, db, table_name, ref,
6156 6157 6158
                                              (thd->lex->sql_command ==
                                               SQLCOM_SHOW_FIELDS)
                                              ? false : check_privileges,
6159
                                              allow_rowid,
6160 6161 6162 6163
                                              &(item->cached_field_index),
                                              register_tree_change,
                                              &actual_table);
    if (cur_field)
6164
    {
6165
      if (cur_field == WRONG_GRANT)
6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182
      {
        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);
6183
          nf->init(cur_table->table);
6184 6185 6186
          cur_field= nf;
        }
      }
6187 6188 6189 6190 6191 6192 6193 6194

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

6195 6196 6197 6198 6199
      DBUG_ASSERT(thd->where);
      /*
        If we found a fully qualified field we return it directly as it can't
        have duplicates.
       */
6200
      if (db)
6201 6202
        return cur_field;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
6203 6204
      if (found)
      {
6205 6206
        if (report_error == REPORT_ALL_ERRORS ||
            report_error == IGNORE_EXCEPT_NON_UNIQUE)
6207
          my_error(ER_NON_UNIQ_ERROR, MYF(0),
6208
                   table_name ? item->full_name() : name, thd->where);
6209
        return (Field*) 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6210
      }
6211
      found= cur_field;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6212 6213
    }
  }
6214

bk@work.mysql.com's avatar
bk@work.mysql.com committed
6215 6216
  if (found)
    return found;
6217 6218 6219 6220 6221 6222 6223 6224

  /*
    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.
  */
6225
  if (table_name && (cur_table == first_table) &&
6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236
      (report_error == REPORT_ALL_ERRORS ||
       report_error == REPORT_EXCEPT_NON_UNIQUE))
  {
    char buff[NAME_LEN*2+1];
    if (db && db[0])
    {
      strxnmov(buff,sizeof(buff)-1,db,".",table_name,NullS);
      table_name=buff;
    }
    my_error(ER_UNKNOWN_TABLE, MYF(0), table_name, thd->where);
  }
6237
  else
6238
  {
6239 6240 6241 6242 6243
    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;
6244
  }
6245
  return found;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6246 6247
}

6248 6249 6250

/*
  Find Item in list of items (find_field_in_tables analog)
6251 6252 6253 6254

  TODO
    is it better return only counter?

6255 6256
  SYNOPSIS
    find_item_in_list()
6257 6258 6259
    find			Item to find
    items			List of items
    counter			To return number of found item
6260
    report_error
6261 6262 6263 6264 6265
      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
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6266 6267 6268 6269 6270 6271 6272
    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)
                                
6273
  RETURN VALUES
6274 6275 6276 6277 6278
    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
6279
                        found field
6280 6281
*/

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


bk@work.mysql.com's avatar
bk@work.mysql.com committed
6286
Item **
6287
find_item_in_list(Item *find, List<Item> &items, uint *counter,
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6288 6289
                  find_item_error_report_type report_error,
                  enum_resolution_type *resolution)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6290 6291
{
  List_iterator<Item> li(items);
6292
  Item **found=0, **found_unaliased= 0, *item;
6293
  const char *db_name=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6294 6295
  const char *field_name=0;
  const char *table_name=0;
6296
  bool found_unaliased_non_uniq= 0;
6297 6298 6299 6300 6301
  /*
    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;
6302
  uint unaliased_counter;
6303 6304
  LINT_INIT(unaliased_counter);                 // Dependent on found_unaliased

igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6305
  *resolution= NOT_RESOLVED;
6306

6307 6308 6309
  is_ref_by_name= (find->type() == Item::FIELD_ITEM  || 
                   find->type() == Item::REF_ITEM);
  if (is_ref_by_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6310 6311 6312
  {
    field_name= ((Item_ident*) find)->field_name;
    table_name= ((Item_ident*) find)->table_name;
6313
    db_name=    ((Item_ident*) find)->db_name;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6314 6315
  }

6316
  for (uint i= 0; (item=li++); i++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6317
  {
6318
    if (field_name && item->real_item()->type() == Item::FIELD_ITEM)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6319
    {
6320
      Item_ident *item_field= (Item_ident*) item;
6321

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6322 6323 6324 6325 6326 6327
      /*
	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
      */ 
6328 6329 6330 6331
      if (!item_field->name)
        continue;

      if (table_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6332
      {
6333 6334 6335
        /*
          If table name is specified we should find field 'field_name' in
          table 'table_name'. According to SQL-standard we should ignore
6336 6337 6338 6339 6340
          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.
6341

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

	  item_field->field_name and item_field->table_name can be 0x0 if
6347
	  item is not fix_field()'ed yet.
6348
        */
6349 6350
        if (item_field->field_name && item_field->table_name &&
	    !my_strcasecmp(system_charset_info, item_field->field_name,
6351
                           field_name) &&
6352 6353
            !my_strcasecmp(table_alias_charset, item_field->table_name, 
                           table_name) &&
6354 6355 6356
            (!db_name || (item_field->db_name &&
                          !strcmp(item_field->db_name, db_name))))
        {
6357
          if (found_unaliased)
6358
          {
6359 6360 6361 6362 6363 6364 6365
            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.
            */
6366
            if (report_error != IGNORE_ERRORS)
6367 6368
              my_error(ER_NON_UNIQ_ERROR, MYF(0),
                       find->full_name(), current_thd->where);
6369 6370
            return (Item**) 0;
          }
6371 6372
          found_unaliased= li.ref();
          unaliased_counter= i;
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6373
          *resolution= RESOLVED_IGNORING_ALIAS;
6374 6375
          if (db_name)
            break;                              // Perfect match
6376 6377
        }
      }
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6378
      else
6379
      {
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6380 6381 6382 6383 6384
        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))
6385
        {
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6386 6387 6388 6389 6390 6391 6392 6393 6394 6395 6396 6397 6398 6399 6400 6401 6402 6403 6404 6405
          /*
            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;
6406
        }
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6407
        else if (!fname_cmp)
6408
        {
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6409 6410 6411 6412 6413 6414 6415 6416 6417 6418 6419 6420
          /*
            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;
          }
6421 6422 6423
          found_unaliased= li.ref();
          unaliased_counter= i;
        }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6424 6425
      }
    }
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6426 6427 6428 6429 6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442
    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;
      }
6443 6444 6445 6446 6447 6448 6449 6450 6451 6452 6453 6454 6455 6456 6457 6458 6459 6460 6461 6462 6463 6464 6465 6466 6467 6468 6469 6470 6471 6472
    }
    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;
      }
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6473
  }
6474 6475 6476 6477 6478
  if (!found)
  {
    if (found_unaliased_non_uniq)
    {
      if (report_error != IGNORE_ERRORS)
6479 6480
        my_error(ER_NON_UNIQ_ERROR, MYF(0),
                 find->full_name(), current_thd->where);
6481 6482 6483 6484 6485 6486
      return (Item **) 0;
    }
    if (found_unaliased)
    {
      found= found_unaliased;
      *counter= unaliased_counter;
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6487
      *resolution= RESOLVED_BEHIND_ALIAS;
6488 6489
    }
  }
6490 6491
  if (found)
    return found;
6492
  if (report_error != REPORT_EXCEPT_NOT_FOUND)
6493 6494
  {
    if (report_error == REPORT_ALL_ERRORS)
6495 6496
      my_error(ER_BAD_FIELD_ERROR, MYF(0),
               find->full_name(), current_thd->where);
6497 6498 6499 6500
    return (Item **) 0;
  }
  else
    return (Item **) not_found_item;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6501 6502
}

6503 6504 6505 6506 6507 6508 6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520 6521 6522 6523 6524 6525 6526 6527 6528 6529 6530

/*
  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;
6531
    if (!my_strcasecmp(system_charset_info, find, curr_str->ptr()))
6532 6533 6534 6535 6536 6537 6538 6539 6540 6541 6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 6552
      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
6553 6554
    FALSE  if all OK
    TRUE   otherwise
6555 6556 6557 6558 6559 6560
*/

static bool
set_new_item_local_context(THD *thd, Item_ident *item, TABLE_LIST *table_ref)
{
  Name_resolution_context *context;
6561
  if (!(context= new (thd->mem_root) Name_resolution_context))
6562 6563
    return TRUE;
  context->init();
6564 6565
  context->first_name_resolution_table=
    context->last_name_resolution_table= table_ref;
6566 6567 6568 6569 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
  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
6598 6599
    TRUE   error when some common column is non-unique, or out of memory
    FALSE  OK
6600 6601 6602 6603 6604 6605 6606 6607 6608 6609
*/

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;
timour@mysql.com's avatar
timour@mysql.com committed
6610 6611 6612 6613 6614 6615 6616 6617 6618 6619 6620
  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;
6621 6622

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

6626
  *found_using_fields= 0;
konstantin@mysql.com's avatar
konstantin@mysql.com committed
6627
  arena= thd->activate_stmt_arena_if_needed(&backup);
6628 6629 6630

  for (it_1.set(table_ref_1); !it_1.end_of_fields(); it_1.next())
  {
6631
    bool found= FALSE;
konstantin@mysql.com's avatar
konstantin@mysql.com committed
6632
    const char *field_name_1;
6633 6634
    /* true if field_name_1 is a member of using_fields */
    bool is_using_column_1;
timour@mysql.com's avatar
timour@mysql.com committed
6635
    if (!(nj_col_1= it_1.get_or_create_column_ref(leaf_1)))
6636 6637
      goto err;
    field_name_1= nj_col_1->name();
6638 6639 6640 6641 6642
    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));
6643

6644 6645 6646 6647 6648 6649 6650
    /*
      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.
    */
6651 6652 6653 6654
    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;
6655
      const char *cur_field_name_2;
timour@mysql.com's avatar
timour@mysql.com committed
6656
      if (!(cur_nj_col_2= it_2.get_or_create_column_ref(leaf_2)))
6657
        goto err;
6658
      cur_field_name_2= cur_nj_col_2->name();
6659 6660 6661 6662
      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));
6663

timour@mysql.com's avatar
timour@mysql.com committed
6664 6665 6666 6667 6668 6669
      /*
        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).
6670 6671 6672 6673
        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).
timour@mysql.com's avatar
timour@mysql.com committed
6674
      */
6675 6676
      if (!my_strcasecmp(system_charset_info, field_name_1, cur_field_name_2))
      {
6677 6678 6679
        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)))
6680 6681 6682 6683 6684 6685 6686 6687
        {
          my_error(ER_NON_UNIQ_ERROR, MYF(0), field_name_1, thd->where);
          goto err;
        }
        nj_col_2= cur_nj_col_2;
        found= TRUE;
      }
    }
timour@mysql.com's avatar
timour@mysql.com committed
6688 6689 6690 6691 6692 6693 6694 6695 6696
    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;
    }
6697
    if (!found)
6698
      continue;                                 // No matching field
6699 6700 6701 6702 6703 6704

    /*
      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.
    */
6705
    if (nj_col_2 && (!using_fields ||is_using_column_1))
6706 6707 6708 6709 6710 6711
    {
      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;
6712 6713 6714 6715 6716
      Item_func_eq *eq_cond;

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

6717
      /*
6718
        The following assert checks that the two created items are of
6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731 6732 6733 6734 6735 6736 6737 6738 6739 6740 6741 6742
        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.
      */
6743 6744
      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))
6745 6746
        goto err;

6747 6748
      if (!(eq_cond= new Item_func_eq(item_ident_1, item_ident_2)))
        goto err;                               /* Out of memory. */
6749 6750 6751 6752 6753 6754

      /*
        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.
       */
6755 6756 6757
      add_join_on((table_ref_1->outer_join & JOIN_TYPE_RIGHT ?
                   table_ref_1 : table_ref_2),
                  eq_cond);
6758 6759

      nj_col_1->is_common= nj_col_2->is_common= TRUE;
6760 6761 6762 6763 6764 6765 6766
      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()));
6767 6768 6769

      if (field_1)
      {
6770
        TABLE *table_1= nj_col_1->table_ref->table;
6771
        /* Mark field_1 used for table cache. */
6772
        bitmap_set_bit(table_1->read_set, field_1->field_index);
6773
        table_1->covering_keys.intersect(field_1->part_of_key);
6774
        table_1->merge_keys.merge(field_1->part_of_key);
6775 6776 6777
      }
      if (field_2)
      {
6778
        TABLE *table_2= nj_col_2->table_ref->table;
6779
        /* Mark field_2 used for table cache. */
6780
        bitmap_set_bit(table_2->read_set, field_2->field_index);
6781
        table_2->covering_keys.intersect(field_2->part_of_key);
6782
        table_2->merge_keys.merge(field_2->part_of_key);
6783 6784 6785 6786 6787 6788
      }

      if (using_fields != NULL)
        ++(*found_using_fields);
    }
  }
timour@mysql.com's avatar
timour@mysql.com committed
6789 6790
  if (leaf_1)
    leaf_1->is_join_columns_complete= TRUE;
6791 6792 6793 6794 6795 6796 6797 6798 6799 6800 6801 6802

  /*
    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)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
6803
    thd->restore_active_arena(arena, &backup);
6804 6805 6806 6807 6808 6809 6810 6811 6812 6813 6814 6815 6816 6817 6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828 6829 6830 6831 6832 6833 6834 6835 6836 6837 6838 6839
  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
6840 6841
    TRUE    error: Some common column is ambiguous
    FALSE   OK
6842 6843 6844 6845 6846 6847 6848 6849 6850 6851 6852 6853 6854
*/

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;
6855
  List<Natural_join_column> *non_join_columns;
6856 6857
  DBUG_ENTER("store_natural_using_join_columns");

6858 6859
  DBUG_ASSERT(!natural_using_join->join_columns);

konstantin@mysql.com's avatar
konstantin@mysql.com committed
6860
  arena= thd->activate_stmt_arena_if_needed(&backup);
6861

6862 6863
  if (!(non_join_columns= new List<Natural_join_column>) ||
      !(natural_using_join->join_columns= new List<Natural_join_column>))
6864 6865 6866 6867 6868
    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())
  {
6869
    nj_col_1= it_1.get_natural_column_ref();
6870 6871 6872 6873 6874 6875 6876 6877 6878 6879 6880 6881 6882 6883 6884 6885 6886 6887 6888 6889 6890
    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++))
    {
6891
      const char *using_field_name_ptr= using_field_name->c_ptr();
6892 6893 6894
      List_iterator_fast<Natural_join_column>
        it(*(natural_using_join->join_columns));
      Natural_join_column *common_field;
6895 6896

      for (;;)
6897
      {
6898 6899 6900 6901 6902 6903 6904
        /* 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;
        }
6905 6906
        if (!my_strcasecmp(system_charset_info,
                           common_field->name(), using_field_name_ptr))
6907
          break;                                // Found match
6908 6909 6910 6911 6912 6913 6914
      }
    }
  }

  /* 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())
  {
6915
    nj_col_2= it_2.get_natural_column_ref();
6916 6917 6918
    if (!nj_col_2->is_common)
      non_join_columns->push_back(nj_col_2);
    else
6919
    {
6920 6921
      /* Reset the common columns for the next call to mark_common_columns. */
      nj_col_2->is_common= FALSE;
6922
    }
6923 6924 6925 6926 6927 6928 6929 6930 6931 6932
  }

  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)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
6933
    thd->restore_active_arena(arena, &backup);
6934 6935 6936
  DBUG_RETURN(result);
}

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
/*
  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
6964 6965
    TRUE   Error
    FALSE  OK
6966 6967 6968 6969 6970 6971 6972
*/

static bool
store_top_level_join_columns(THD *thd, TABLE_LIST *table_ref,
                             TABLE_LIST *left_neighbor,
                             TABLE_LIST *right_neighbor)
{
timour@mysql.com's avatar
timour@mysql.com committed
6973 6974 6975
  Query_arena *arena, backup;
  bool result= TRUE;

6976
  DBUG_ENTER("store_top_level_join_columns");
6977

konstantin@mysql.com's avatar
konstantin@mysql.com committed
6978
  arena= thd->activate_stmt_arena_if_needed(&backup);
timour@mysql.com's avatar
timour@mysql.com committed
6979

6980 6981 6982 6983
  /* 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);
timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
6984 6985 6986 6987
    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;
6988

timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
6989
    while (same_level_left_neighbor)
6990
    {
timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
6991 6992
      TABLE_LIST *cur_table_ref= same_level_left_neighbor;
      same_level_left_neighbor= nested_it++;
6993 6994 6995 6996
      /*
        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
timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
6997 6998 6999 7000 7001
        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
7002 7003
        swapped in the first loop.
      */
timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
7004
      if (same_level_left_neighbor &&
7005 7006 7007 7008
          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);
timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
7009
        swap_variables(TABLE_LIST*, same_level_left_neighbor, cur_table_ref);
7010 7011
      }

timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
7012 7013 7014 7015 7016 7017 7018 7019 7020
      /*
        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;

7021 7022
      if (cur_table_ref->nested_join &&
          store_top_level_join_columns(thd, cur_table_ref,
timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
7023
                                       real_left_neighbor, real_right_neighbor))
timour@mysql.com's avatar
timour@mysql.com committed
7024
        goto err;
timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
7025
      same_level_right_neighbor= cur_table_ref;
7026 7027 7028 7029 7030 7031 7032 7033 7034 7035 7036 7037 7038 7039 7040 7041 7042 7043 7044 7045 7046 7047 7048 7049 7050 7051 7052 7053 7054 7055
    }
  }

  /*
    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))
timour@mysql.com's avatar
timour@mysql.com committed
7056
      goto err;
7057 7058 7059 7060 7061 7062 7063 7064 7065 7066 7067

    /*
      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))
timour@mysql.com's avatar
timour@mysql.com committed
7068
      goto err;
7069 7070 7071 7072 7073 7074 7075 7076 7077

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

timour@mysql.com's avatar
timour@mysql.com committed
7078 7079 7080 7081 7082
    /* 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. */

7083 7084 7085
    /* Change this table reference to become a leaf for name resolution. */
    if (left_neighbor)
    {
7086
      TABLE_LIST *last_leaf_on_the_left;
7087 7088 7089 7090 7091
      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)
    {
7092
      TABLE_LIST *first_leaf_on_the_right;
7093 7094 7095 7096 7097 7098
      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;
  }
timour@mysql.com's avatar
timour@mysql.com committed
7099 7100 7101 7102
  result= FALSE; /* All is OK. */

err:
  if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7103
    thd->restore_active_arena(arena, &backup);
timour@mysql.com's avatar
timour@mysql.com committed
7104
  DBUG_RETURN(result);
7105 7106 7107 7108 7109 7110 7111 7112 7113 7114 7115 7116 7117 7118 7119 7120 7121 7122 7123 7124 7125 7126 7127 7128
}


/*
  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
7129 7130
    TRUE   Error
    FALSE  OK
7131
*/
7132 7133
static bool setup_natural_join_row_types(THD *thd,
                                         List<TABLE_LIST> *from_clause,
7134 7135 7136 7137 7138 7139 7140 7141 7142
                                         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. */
7143
  TABLE_LIST *left_neighbor;
7144 7145 7146
  /* Table reference to the right of the current. */
  TABLE_LIST *right_neighbor= NULL;

7147 7148
  /* Note that tables in the list are in reversed order */
  for (left_neighbor= table_ref_it++; left_neighbor ; )
7149 7150 7151
  {
    table_ref= left_neighbor;
    left_neighbor= table_ref_it++;
7152 7153
    /* For stored procedures do not redo work if already done. */
    if (context->select_lex->first_execution)
7154
    {
7155 7156 7157 7158 7159 7160 7161 7162 7163
      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;
      }
7164 7165 7166 7167 7168 7169 7170
    }
    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
7171
    right_neighbor points to the left-most top-level table reference in the
7172 7173 7174 7175 7176 7177 7178 7179 7180 7181
    FROM clause.
  */
  DBUG_ASSERT(right_neighbor);
  context->first_name_resolution_table=
    right_neighbor->first_leaf_for_name_resolution();

  return FALSE;
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
7182
/****************************************************************************
7183
** Expand all '*' in given fields
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7184 7185
****************************************************************************/

7186 7187 7188
int setup_wild(THD *thd, TABLE_LIST *tables, List<Item> &fields,
	       List<Item> *sum_func_list,
	       uint wild_num)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7189
{
7190
  if (!wild_num)
7191
    return(0);
7192

7193
  Item *item;
7194
  List_iterator<Item> it(fields);
serg@serg.mylan's avatar
serg@serg.mylan committed
7195
  Query_arena *arena, backup;
7196
  DBUG_ENTER("setup_wild");
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7197 7198

  /*
7199 7200
    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
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7201
  */
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7202
  arena= thd->activate_stmt_arena_if_needed(&backup);
7203

7204
  thd->lex->current_select->cur_pos_in_select_list= 0;
monty@mysql.com's avatar
monty@mysql.com committed
7205
  while (wild_num && (item= it++))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7206
  {
7207 7208
    if (item->type() == Item::FIELD_ITEM &&
        ((Item_field*) item)->field_name &&
7209 7210
	((Item_field*) item)->field_name[0] == '*' &&
	!((Item_field*) item)->field)
7211
    {
7212
      uint elem= fields.elements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7213
      bool any_privileges= ((Item_field *) item)->any_privileges;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7214 7215 7216 7217 7218 7219 7220 7221 7222
      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.
        */
7223 7224
        it.replace(new Item_int("Not_used", (longlong) 1,
                                MY_INT64_NUM_DECIMAL_DIGITS));
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7225
      }
7226 7227
      else if (insert_fields(thd, ((Item_field*) item)->context,
                             ((Item_field*) item)->db_name,
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7228
                             ((Item_field*) item)->table_name, &it,
7229
                             any_privileges))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7230 7231
      {
	if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7232
	  thd->restore_active_arena(arena, &backup);
7233
	DBUG_RETURN(-1);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7234
      }
7235
      if (sum_func_list)
7236 7237 7238 7239 7240 7241 7242 7243
      {
	/*
	  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;
      }
7244
      wild_num--;
7245
    }
7246 7247
    else
      thd->lex->current_select->cur_pos_in_select_list++;
7248
  }
7249
  thd->lex->current_select->cur_pos_in_select_list= UNDEF_POS;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7250 7251 7252 7253 7254 7255 7256
  if (arena)
  {
    /* make * substituting permanent */
    SELECT_LEX *select_lex= thd->lex->current_select;
    select_lex->with_wild= 0;
    select_lex->item_list= fields;

konstantin@mysql.com's avatar
konstantin@mysql.com committed
7257
    thd->restore_active_arena(arena, &backup);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7258
  }
7259
  DBUG_RETURN(0);
7260 7261
}

7262 7263 7264 7265
/****************************************************************************
** Check that all given fields exists and fill struct with current data
****************************************************************************/

7266
bool setup_fields(THD *thd, Item **ref_pointer_array,
7267
                  List<Item> &fields, enum_mark_columns mark_used_columns,
7268
                  List<Item> *sum_func_list, bool allow_sum_func)
7269 7270
{
  reg2 Item *item;
7271
  enum_mark_columns save_mark_used_columns= thd->mark_used_columns;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7272
  nesting_map save_allow_sum_func= thd->lex->allow_sum_func;
7273
  List_iterator<Item> it(fields);
7274
  bool save_is_item_list_lookup;
7275 7276
  DBUG_ENTER("setup_fields");

7277 7278
  thd->mark_used_columns= mark_used_columns;
  DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7279 7280
  if (allow_sum_func)
    thd->lex->allow_sum_func|= 1 << thd->lex->current_select->nest_level;
7281
  thd->where= THD::DEFAULT_WHERE;
7282 7283
  save_is_item_list_lookup= thd->lex->current_select->is_item_list_lookup;
  thd->lex->current_select->is_item_list_lookup= 0;
7284

7285 7286 7287 7288 7289 7290 7291 7292 7293 7294 7295 7296 7297 7298
  /*
    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);

7299
  Item **ref= ref_pointer_array;
7300
  thd->lex->current_select->cur_pos_in_select_list= 0;
7301
  while ((item= it++))
7302
  {
7303
    if (!item->fixed && item->fix_fields(thd, it.ref()) ||
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7304
	(item= *(it.ref()))->check_cols(1))
7305
    {
7306
      thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7307
      thd->lex->allow_sum_func= save_allow_sum_func;
7308 7309
      thd->mark_used_columns= save_mark_used_columns;
      DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
7310
      DBUG_RETURN(TRUE); /* purecov: inspected */
7311
    }
7312 7313
    if (ref)
      *(ref++)= item;
7314 7315
    if (item->with_sum_func && item->type() != Item::SUM_FUNC_ITEM &&
	sum_func_list)
7316
      item->split_sum_func(thd, ref_pointer_array, *sum_func_list);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7317
    thd->used_tables|= item->used_tables();
7318
    thd->lex->current_select->cur_pos_in_select_list++;
7319
  }
7320
  thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
7321 7322
  thd->lex->current_select->cur_pos_in_select_list= UNDEF_POS;

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7323
  thd->lex->allow_sum_func= save_allow_sum_func;
7324 7325
  thd->mark_used_columns= save_mark_used_columns;
  DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
7326
  DBUG_RETURN(test(thd->is_error()));
7327
}
7328

7329

7330 7331 7332 7333 7334 7335 7336 7337 7338 7339 7340 7341 7342 7343 7344
/*
  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)
  {
7345 7346 7347 7348 7349 7350
    if (table->merge_underlying_list)
    {
      DBUG_ASSERT(table->view &&
                  table->effective_algorithm == VIEW_ALGORITHM_MERGE);
      list= make_leaves_list(list, table->merge_underlying_list);
    }
7351 7352 7353 7354 7355 7356 7357 7358 7359
    else
    {
      *list= table;
      list= &table->next_leaf;
    }
  }
  return list;
}

7360
/*
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7361 7362 7363 7364
  prepare tables

  SYNOPSIS
    setup_tables()
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7365
    thd		  Thread handler
7366
    context       name resolution contest to setup table list there
7367 7368 7369
    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)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7370 7371
    refresh       It is onle refresh for subquery
    select_insert It is SELECT ... INSERT command
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7372

monty@mysql.com's avatar
monty@mysql.com committed
7373 7374
  NOTE
    Check also that the 'used keys' and 'ignored keys' exists and set up the
7375 7376 7377 7378
    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.
7379

monty@mysql.com's avatar
monty@mysql.com committed
7380 7381
    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.
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7382

monty@mysql.com's avatar
monty@mysql.com committed
7383
  RETURN
7384
    FALSE ok;  In this case *map will includes the chosen index
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7385
    TRUE  error
7386 7387
*/

7388
bool setup_tables(THD *thd, Name_resolution_context *context,
7389
                  List<TABLE_LIST> *from_clause, TABLE_LIST *tables,
7390
                  TABLE_LIST **leaves, bool select_insert)
7391
{
monty@mysql.com's avatar
monty@mysql.com committed
7392
  uint tablenr= 0;
7393
  DBUG_ENTER("setup_tables");
7394

7395 7396
  DBUG_ASSERT ((select_insert && !tables->next_name_resolution_table) || !tables || 
               (context->table_list && context->first_name_resolution_table));
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7397 7398
  /*
    this is used for INSERT ... SELECT.
7399
    For select we setup tables except first (and its underlying tables)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7400 7401 7402 7403
  */
  TABLE_LIST *first_select_table= (select_insert ?
                                   tables->next_local:
                                   0);
7404 7405 7406
  if (!(*leaves))
    make_leaves_list(leaves, tables);

7407 7408
  TABLE_LIST *table_list;
  for (table_list= *leaves;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7409
       table_list;
7410
       table_list= table_list->next_leaf, tablenr++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7411
  {
7412
    TABLE *table= table_list->table;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7413
    table->pos_in_table_list= table_list;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7414
    if (first_select_table &&
7415
        table_list->top_table() == first_select_table)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7416 7417 7418 7419 7420
    {
      /* new counting for SELECT of INSERT ... SELECT command */
      first_select_table= 0;
      tablenr= 0;
    }
7421
    setup_table_map(table, table_list, tablenr);
7422 7423
    if (table_list->process_index_hints(table))
      DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7424 7425 7426 7427
  }
  if (tablenr > MAX_TABLES)
  {
    my_error(ER_TOO_MANY_TABLES,MYF(0),MAX_TABLES);
7428
    DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7429
  }
7430
  for (table_list= tables;
7431 7432
       table_list;
       table_list= table_list->next_local)
7433
  {
7434
    if (table_list->merge_underlying_list)
7435
    {
7436 7437
      DBUG_ASSERT(table_list->view &&
                  table_list->effective_algorithm == VIEW_ALGORITHM_MERGE);
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7438
      Query_arena *arena= thd->stmt_arena, backup;
7439 7440 7441 7442
      bool res;
      if (arena->is_conventional())
        arena= 0;                                   // For easier test
      else
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7443
        thd->set_n_backup_active_arena(arena, &backup);
7444
      res= table_list->setup_underlying(thd);
7445
      if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7446
        thd->restore_active_arena(arena, &backup);
7447 7448 7449
      if (res)
        DBUG_RETURN(1);
    }
7450
  }
7451 7452 7453 7454 7455

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

7456
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7457
}
7458

bk@work.mysql.com's avatar
bk@work.mysql.com committed
7459

7460 7461 7462 7463 7464 7465 7466 7467 7468 7469 7470 7471 7472 7473 7474 7475 7476 7477 7478 7479 7480 7481 7482 7483 7484 7485 7486
/*
  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,
monty@mysql.com's avatar
monty@mysql.com committed
7487
                                   TABLE_LIST **leaves,
7488
                                   bool select_insert,
7489
                                   ulong want_access_first,
7490 7491
                                   ulong want_access)
{
monty@mysql.com's avatar
monty@mysql.com committed
7492
  TABLE_LIST *leaves_tmp= NULL;
7493
  bool first_table= true;
7494

monty@mysql.com's avatar
monty@mysql.com committed
7495 7496
  if (setup_tables(thd, context, from_clause, tables,
                   &leaves_tmp, select_insert))
7497 7498
    return TRUE;

7499 7500
  if (leaves)
    *leaves= leaves_tmp;
7501 7502

  for (; leaves_tmp; leaves_tmp= leaves_tmp->next_leaf)
monty@mysql.com's avatar
monty@mysql.com committed
7503
  {
7504
    if (leaves_tmp->belong_to_view && 
7505
        check_single_table_access(thd, first_table ? want_access_first :
7506
                                  want_access, leaves_tmp, FALSE))
7507 7508 7509 7510
    {
      tables->hide_view_error(thd);
      return TRUE;
    }
7511
    first_table= 0;
monty@mysql.com's avatar
monty@mysql.com committed
7512
  }
7513 7514 7515 7516
  return FALSE;
}


7517 7518 7519 7520 7521 7522 7523 7524 7525 7526 7527 7528 7529 7530 7531
/*
   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,
7532
                               List<String> *index_list)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7533
{
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
7534
  List_iterator_fast<String> it(*index_list);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7535 7536
  String *name;
  uint pos;
7537 7538

  map->clear_all();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7539 7540
  while ((name=it++))
  {
7541 7542 7543
    if (table->s->keynames.type_names == 0 ||
        (pos= find_type(&table->s->keynames, name->ptr(),
                        name->length(), 1)) <=
7544
        0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7545
    {
7546
      my_error(ER_KEY_DOES_NOT_EXITS, MYF(0), name->c_ptr(),
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7547
	       table->pos_in_table_list->alias);
7548
      map->set_all();
7549
      return 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7550
    }
7551
    map->set_bit(pos-1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7552
  }
7553
  return 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7554 7555
}

7556

7557 7558 7559 7560 7561 7562
/*
  Drops in all fields instead of current '*' field

  SYNOPSIS
    insert_fields()
    thd			Thread handler
7563
    context             Context for name resolution
7564 7565 7566 7567 7568 7569 7570
    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
7571
    0	ok     'it' is updated to point at last inserted
monty@mysql.com's avatar
monty@mysql.com committed
7572
    1	error.  Error message is generated but not sent to client
7573
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7574

sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
7575
bool
7576
insert_fields(THD *thd, Name_resolution_context *context, const char *db_name,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7577
	      const char *table_name, List_iterator<Item> *it,
7578
              bool any_privileges)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7579
{
7580 7581
  Field_iterator_table_ref field_iterator;
  bool found;
monty@mysql.com's avatar
monty@mysql.com committed
7582
  char name_buff[NAME_LEN+1];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7583
  DBUG_ENTER("insert_fields");
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7584
  DBUG_PRINT("arena", ("stmt arena: 0x%lx", (ulong)thd->stmt_arena));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7585

7586 7587
  if (db_name && lower_case_table_names)
  {
monty@mysql.com's avatar
monty@mysql.com committed
7588 7589 7590 7591 7592
    /*
      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
    */
serg@serg.mylan's avatar
serg@serg.mylan committed
7593
    strmake(name_buff, db_name, sizeof(name_buff)-1);
monty@mysql.com's avatar
monty@mysql.com committed
7594
    my_casedn_str(files_charset_info, name_buff);
monty@mysql.com's avatar
monty@mysql.com committed
7595
    db_name= name_buff;
7596 7597
  }

7598
  found= FALSE;
7599 7600 7601 7602 7603 7604 7605 7606

  /*
    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);
7607
       tables;
7608 7609 7610
       tables= (table_name ? tables->next_local :
                tables->next_name_resolution_table)
       )
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7611
  {
7612 7613 7614
    Field *field;
    TABLE *table= tables->table;

7615 7616
    DBUG_ASSERT(tables->is_leaf_for_name_resolution());

7617 7618 7619 7620
    if (table_name && my_strcasecmp(table_alias_charset, table_name,
                                    tables->alias) ||
        (db_name && strcmp(tables->db,db_name)))
      continue;
7621

hf@deer.(none)'s avatar
hf@deer.(none) committed
7622
#ifndef NO_EMBEDDED_ACCESS_CHECKS
7623 7624 7625 7626 7627 7628 7629 7630 7631 7632 7633 7634 7635 7636 7637 7638 7639 7640 7641 7642 7643 7644 7645 7646 7647 7648 7649 7650
    /* 
       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.
    */
    if (!(table && !tables->view && (table->grant.privilege & SELECT_ACL) ||
          tables->view && (tables->grant.privilege & SELECT_ACL)) &&
7651 7652 7653
        !any_privileges)
    {
      field_iterator.set(tables);
7654
      if (check_grant_all_columns(thd, SELECT_ACL, &field_iterator))
7655 7656
        DBUG_RETURN(TRUE);
    }
hf@deer.(none)'s avatar
hf@deer.(none) committed
7657
#endif
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7658

7659 7660 7661 7662 7663 7664 7665 7666 7667 7668 7669 7670 7671 7672 7673 7674 7675 7676 7677 7678 7679 7680 7681
    /*
      Update the tables used in the query based on the referenced fields. For
      views and natural joins this update is performed inside the loop below.
    */
    if (table)
      thd->used_tables|= table->map;

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

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

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

      if (!found)
7682
      {
7683
        found= TRUE;
7684
        it->replace(item); /* Replace '*' with the first found item. */
7685
      }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7686
      else
7687 7688 7689 7690 7691 7692 7693
        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,
7694 7695 7696
        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.
7697 7698
      */
      if (any_privileges)
7699
      {
7700 7701 7702 7703
        DBUG_ASSERT(tables->field_translation == NULL && table ||
                    tables->is_natural_join);
        DBUG_ASSERT(item->type() == Item::FIELD_ITEM);
        Item_field *fld= (Item_field*) item;
7704
        const char *field_table_name= field_iterator.get_table_name();
7705

7706 7707 7708
        if (!tables->schema_table && 
            !(fld->have_privileges=
              (get_column_grant(thd, field_iterator.grant(),
7709
                                field_iterator.get_db_name(),
7710
                                field_table_name, fld->field_name) &
7711 7712
               VIEW_ANY_ACL)))
        {
7713
          my_error(ER_TABLEACCESS_DENIED_ERROR, MYF(0), "ANY",
7714 7715
                   thd->security_ctx->priv_user,
                   thd->security_ctx->host_or_ip,
7716
                   field_table_name);
7717 7718
          DBUG_RETURN(TRUE);
        }
7719
      }
7720
#endif
7721

7722
      if ((field= field_iterator.field()))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7723
      {
7724 7725
        /* Mark fields as used to allow storage engine to optimze access */
        bitmap_set_bit(field->table->read_set, field->field_index);
7726
        if (table)
7727
        {
7728
          table->covering_keys.intersect(field->part_of_key);
7729 7730
          table->merge_keys.merge(field->part_of_key);
        }
7731
        if (tables->is_natural_join)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7732
        {
7733 7734
          TABLE *field_table;
          /*
7735
            In this case we are sure that the column ref will not be created
7736
            because it was already created and stored with the natural join.
7737
          */
7738
          Natural_join_column *nj_col;
timour@mysql.com's avatar
timour@mysql.com committed
7739
          if (!(nj_col= field_iterator.get_natural_column_ref()))
7740
            DBUG_RETURN(TRUE);
timour@mysql.com's avatar
timour@mysql.com committed
7741
          DBUG_ASSERT(nj_col->table_field);
7742 7743
          field_table= nj_col->table_ref->table;
          if (field_table)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7744
          {
7745
            thd->used_tables|= field_table->map;
7746
            field_table->covering_keys.intersect(field->part_of_key);
7747
            field_table->merge_keys.merge(field->part_of_key);
7748
            field_table->used_fields++;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7749
          }
7750
        }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7751
      }
7752 7753
      else
        thd->used_tables|= item->used_tables();
7754
      thd->lex->current_select->cur_pos_in_select_list++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7755
    }
7756 7757 7758 7759 7760 7761 7762 7763
    /*
      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;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7764
  }
7765
  if (found)
7766
    DBUG_RETURN(FALSE);
7767

7768
  /*
7769 7770 7771
    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.
7772
  */
7773
  if (!table_name)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7774
    my_message(ER_NO_TABLES_USED, ER(ER_NO_TABLES_USED), MYF(0));
7775 7776
  else
    my_error(ER_BAD_TABLE_ERROR, MYF(0), table_name);
7777 7778

  DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7779 7780 7781 7782
}


/*
7783
  Fix all conditions and outer join expressions.
7784 7785 7786 7787

  SYNOPSIS
    setup_conds()
    thd     thread handler
7788 7789 7790 7791 7792 7793 7794 7795 7796 7797
    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
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7798 7799
*/

7800 7801
int setup_conds(THD *thd, TABLE_LIST *tables, TABLE_LIST *leaves,
                COND **conds)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7802
{
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7803
  SELECT_LEX *select_lex= thd->lex->current_select;
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7804
  Query_arena *arena= thd->stmt_arena, backup;
pem@mysql.comhem.se's avatar
pem@mysql.comhem.se committed
7805
  TABLE_LIST *table= NULL;	// For HP compilers
7806 7807 7808 7809 7810 7811 7812 7813 7814 7815
  /*
    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();
7816 7817
  bool save_is_item_list_lookup= select_lex->is_item_list_lookup;
  select_lex->is_item_list_lookup= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7818
  DBUG_ENTER("setup_conds");
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7819

monty@mysql.com's avatar
monty@mysql.com committed
7820
  if (select_lex->conds_processed_with_permanent_arena ||
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7821
      arena->is_conventional())
monty@mysql.com's avatar
monty@mysql.com committed
7822 7823
    arena= 0;                                   // For easier test

7824 7825
  thd->mark_used_columns= MARK_COLUMNS_READ;
  DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7826
  select_lex->cond_count= 0;
7827
  select_lex->between_count= 0;
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
7828
  select_lex->max_equal_elems= 0;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7829

7830 7831 7832 7833 7834 7835
  for (table= tables; table; table= table->next_local)
  {
    if (table->prepare_where(thd, conds, FALSE))
      goto err_no_arena;
  }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
7836 7837 7838
  if (*conds)
  {
    thd->where="where clause";
7839
    if (!(*conds)->fixed && (*conds)->fix_fields(thd, conds) ||
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7840
	(*conds)->check_cols(1))
7841
      goto err_no_arena;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7842 7843
  }

7844 7845 7846 7847
  /*
    Apply fix_fields() to all ON clauses at all levels of nesting,
    including the ones inside view definitions.
  */
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
7848
  for (table= leaves; table; table= table->next_leaf)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7849
  {
7850 7851
    TABLE_LIST *embedded; /* The table at the current level of nesting. */
    TABLE_LIST *embedding= table; /* The parent nested table reference. */
7852
    do
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7853
    {
7854 7855
      embedded= embedding;
      if (embedded->on_expr)
7856
      {
7857 7858
        /* Make a join an a expression */
        thd->where="on clause";
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7859
        if (!embedded->on_expr->fixed &&
7860
            embedded->on_expr->fix_fields(thd, &embedded->on_expr) ||
7861
	    embedded->on_expr->check_cols(1))
7862
	  goto err_no_arena;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7863
        select_lex->cond_count++;
7864
      }
7865
      embedding= embedded->embedding;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7866
    }
7867 7868
    while (embedding &&
           embedding->nested_join->join_list.head() == embedded);
7869 7870 7871 7872

    /* process CHECK OPTION */
    if (it_is_update)
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7873
      TABLE_LIST *view= table->top_table();
7874 7875 7876 7877 7878 7879 7880
      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);
      }
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7881
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7882

konstantin@mysql.com's avatar
konstantin@mysql.com committed
7883
  if (!thd->stmt_arena->is_conventional())
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7884 7885 7886 7887 7888 7889 7890 7891 7892 7893
  {
    /*
      We are in prepared statement preparation code => we should store
      WHERE clause changing for next executions.

      We do this ON -> WHERE transformation only once per PS/SP statement.
    */
    select_lex->where= *conds;
    select_lex->conds_processed_with_permanent_arena= 1;
  }
7894
  thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
7895
  DBUG_RETURN(test(thd->is_error()));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7896

7897
err_no_arena:
7898
  select_lex->is_item_list_lookup= save_is_item_list_lookup;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7899
  DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7900 7901 7902 7903 7904 7905 7906 7907
}


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

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7908 7909 7910 7911 7912 7913 7914 7915 7916 7917 7918

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

7919 7920 7921 7922 7923
  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.

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7924 7925 7926 7927 7928
  RETURN
    FALSE   OK
    TRUE    error occured
*/

7929
static bool
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7930 7931
fill_record(THD * thd, List<Item> &fields, List<Item> &values,
            bool ignore_errors)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7932
{
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
7933
  List_iterator_fast<Item> f(fields),v(values);
7934
  Item *value, *fld;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7935
  Item_field *field;
7936
  TABLE *table= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7937 7938
  DBUG_ENTER("fill_record");

7939 7940 7941 7942 7943 7944 7945 7946 7947 7948 7949 7950 7951 7952 7953 7954 7955 7956 7957 7958
  /*
    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();
  }
7959
  while ((fld= f++))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7960
  {
7961 7962 7963
    if (!(field= fld->filed_for_view_update()))
    {
      my_error(ER_NONUPDATEABLE_COLUMN, MYF(0), fld->name);
7964
      goto err;
7965
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7966
    value=v++;
7967
    Field *rfield= field->field;
7968
    table= rfield->table;
7969
    if (rfield == table->next_number_field)
7970
      table->auto_increment_field_not_null= TRUE;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7971
    if ((value->save_in_field(rfield, 0) < 0) && !ignore_errors)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7972 7973
    {
      my_message(ER_UNKNOWN_ERROR, ER(ER_UNKNOWN_ERROR), MYF(0));
7974
      goto err;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7975
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7976
  }
7977
  DBUG_RETURN(thd->is_error());
7978 7979 7980 7981
err:
  if (table)
    table->auto_increment_field_not_null= FALSE;
  DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7982 7983 7984
}


7985 7986 7987 7988 7989 7990 7991 7992 7993 7994 7995 7996 7997 7998 7999 8000 8001 8002 8003 8004 8005 8006 8007 8008 8009 8010 8011 8012 8013 8014 8015 8016 8017 8018 8019
/*
  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) ||
          triggers && triggers->process_triggers(thd, event,
                                                 TRG_ACTION_BEFORE, TRUE));
}


bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
8020 8021 8022 8023 8024 8025 8026 8027 8028 8029
/*
  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

8030 8031 8032 8033 8034
  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.

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
8035 8036 8037 8038 8039 8040 8041
  RETURN
    FALSE   OK
    TRUE    error occured
*/

bool
fill_record(THD *thd, Field **ptr, List<Item> &values, bool ignore_errors)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8042
{
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
8043
  List_iterator_fast<Item> v(values);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8044
  Item *value;
8045
  TABLE *table= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8046 8047 8048
  DBUG_ENTER("fill_record");

  Field *field;
8049 8050 8051 8052 8053 8054 8055 8056 8057 8058 8059 8060 8061
  /*
    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;
  }
8062
  while ((field = *ptr++) && ! thd->is_error())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8063 8064
  {
    value=v++;
8065
    table= field->table;
8066
    if (field == table->next_number_field)
8067
      table->auto_increment_field_not_null= TRUE;
8068
    if (value->save_in_field(field, 0) < 0)
8069
      goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8070
  }
8071
  DBUG_RETURN(thd->is_error());
8072 8073 8074 8075 8076

err:
  if (table)
    table->auto_increment_field_not_null= FALSE;
  DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8077 8078 8079
}


8080 8081 8082 8083 8084 8085 8086 8087 8088 8089 8090 8091 8092 8093 8094 8095 8096 8097 8098 8099 8100 8101 8102 8103 8104 8105 8106 8107 8108 8109 8110 8111 8112 8113 8114
/*
  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) ||
          triggers && triggers->process_triggers(thd, event,
                                                 TRG_ACTION_BEFORE, TRUE));
}


8115
my_bool mysql_rm_tmp_tables(void)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8116
{
8117
  uint i, idx;
8118
  char	filePath[FN_REFLEN], *tmpdir, filePathCopy[FN_REFLEN];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8119 8120
  MY_DIR *dirp;
  FILEINFO *file;
8121
  TABLE_SHARE share;
8122
  THD *thd;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8123 8124
  DBUG_ENTER("mysql_rm_tmp_tables");

8125 8126
  if (!(thd= new THD))
    DBUG_RETURN(1);
8127
  thd->thread_stack= (char*) &thd;
8128 8129
  thd->store_globals();

8130 8131 8132
  for (i=0; i<=mysql_tmpdir_list.max; i++)
  {
    tmpdir=mysql_tmpdir_list.list[i];
8133
    /* See if the directory exists */
8134 8135
    if (!(dirp = my_dir(tmpdir,MYF(MY_WME | MY_DONT_SORT))))
      continue;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8136

8137
    /* Remove all SQLxxx tables from directory */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8138

8139 8140 8141
    for (idx=0 ; idx < (uint) dirp->number_off_files ; idx++)
    {
      file=dirp->dir_entry+idx;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
8142

8143 8144 8145 8146
      /* skiping . and .. */
      if (file->name[0] == '.' && (!file->name[1] ||
                                   (file->name[1] == '.' &&  !file->name[2])))
        continue;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
8147

8148 8149
      if (!bcmp((uchar*) file->name, (uchar*) tmp_file_prefix,
                tmp_file_prefix_length))
8150
      {
8151 8152 8153 8154 8155
        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);
8156
        if (!bcmp((uchar*) reg_ext, (uchar*) ext, ext_len))
8157
        {
8158 8159 8160 8161
          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;
8162
          init_tmp_table_share(thd, &share, "", 0, "", filePathCopy);
8163 8164
          if (!open_table_def(thd, &share, 0) &&
              ((handler_file= get_new_handler(&share, thd->mem_root,
antony@ppcg5.local's avatar
antony@ppcg5.local committed
8165
                                              share.db_type()))))
8166
          {
8167
            handler_file->ha_delete_table(filePathCopy);
8168 8169 8170
            delete handler_file;
          }
          free_table_share(&share);
8171
        }
8172 8173 8174 8175 8176 8177
        /*
          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)).
        */
        VOID(my_delete(filePath, MYF(0))); 
8178
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8179
    }
8180
    my_dirend(dirp);
8181
  }
8182 8183 8184
  delete thd;
  my_pthread_setspecific_ptr(THR_THD,  0);
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8185 8186 8187 8188 8189 8190 8191 8192 8193
}



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

/*
8194 8195 8196 8197 8198 8199 8200 8201 8202 8203
  Invalidate any cache entries that are for some DB

  SYNOPSIS
    remove_db_from_cache()
    db		Database name. This will be in lower case if
		lower_case_table_name is set

  NOTE:
  We can't use hash_delete when looping hash_elements. We mark them first
  and afterwards delete those marked unused.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8204 8205
*/

8206
void remove_db_from_cache(const char *db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8207 8208 8209 8210
{
  for (uint idx=0 ; idx < open_cache.records ; idx++)
  {
    TABLE *table=(TABLE*) hash_element(&open_cache,idx);
8211
    if (!strcmp(table->s->db.str, db))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8212
    {
8213
      table->s->version= 0L;			/* Free when thread is ready */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8214 8215 8216 8217
      if (!table->in_use)
	relink_unused(table);
    }
  }
8218
  while (unused_tables && !unused_tables->s->version)
8219
    VOID(hash_delete(&open_cache,(uchar*) unused_tables));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8220 8221 8222 8223
}


/*
8224 8225 8226 8227 8228
  free all unused tables

  NOTE
    This is called by 'handle_manager' when one wants to periodicly flush
    all not used tables.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8229 8230 8231 8232 8233 8234
*/

void flush_tables()
{
  (void) pthread_mutex_lock(&LOCK_open);
  while (unused_tables)
8235
    hash_delete(&open_cache,(uchar*) unused_tables);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8236 8237 8238 8239 8240
  (void) pthread_mutex_unlock(&LOCK_open);
}


/*
8241 8242 8243 8244 8245
  Mark all entries with the table as deleted to force an reopen of the table

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

monty@mysql.com's avatar
monty@mysql.com committed
8246 8247 8248
  PREREQUISITES
    Lock on LOCK_open()

8249 8250 8251 8252
  RETURN
    0  This thread now have exclusive access to this table and no other thread
       can access the table until close_thread_tables() is called.
    1  Table is in use by another thread
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8253 8254
*/

8255
bool remove_table_from_cache(THD *thd, const char *db, const char *table_name,
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8256
                             uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8257 8258 8259 8260
{
  char key[MAX_DBKEY_LENGTH];
  uint key_length;
  TABLE *table;
8261 8262
  TABLE_SHARE *share;
  bool result= 0, signalled= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8263
  DBUG_ENTER("remove_table_from_cache");
8264
  DBUG_PRINT("enter", ("table: '%s'.'%s'  flags: %u", db, table_name, flags));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8265 8266

  key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
8267
  for (;;)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8268
  {
8269
    HASH_SEARCH_STATE state;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8270 8271
    result= signalled= 0;

8272
    for (table= (TABLE*) hash_first(&open_cache, (uchar*) key, key_length,
8273
                                    &state);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8274
         table;
8275
         table= (TABLE*) hash_next(&open_cache, (uchar*) key, key_length,
8276
                                   &state))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8277
    {
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8278
      THD *in_use;
8279 8280
      DBUG_PRINT("tcache", ("found table: '%s'.'%s' 0x%lx", table->s->db.str,
                            table->s->table_name.str, (long) table));
8281

8282
      table->s->version=0L;		/* Free when thread is ready */
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8283
      if (!(in_use=table->in_use))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8284
      {
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8285 8286
        DBUG_PRINT("info",("Table was not in use"));
        relink_unused(table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8287
      }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8288
      else if (in_use != thd)
8289
      {
8290
        DBUG_PRINT("info", ("Table was in use by other thread"));
8291 8292 8293 8294 8295 8296
        /*
          Mark that table is going to be deleted from cache. This will
          force threads that are in mysql_lock_tables() (but not yet
          in thr_multi_lock()) to abort it's locks, close all tables and retry
        */
        in_use->some_tables_deleted= 1;
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
8297
        if (table->is_name_opened())
monty@mysql.com's avatar
monty@mysql.com committed
8298 8299
        {
          DBUG_PRINT("info", ("Found another active instance of the table"));
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8300
  	  result=1;
monty@mysql.com's avatar
monty@mysql.com committed
8301
        }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8302 8303 8304 8305
        /* Kill delayed insert threads */
        if ((in_use->system_thread & SYSTEM_THREAD_DELAYED_INSERT) &&
            ! in_use->killed)
        {
8306
	  in_use->killed= THD::KILL_CONNECTION;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8307 8308 8309 8310 8311 8312 8313 8314 8315 8316 8317 8318
	  pthread_mutex_lock(&in_use->mysys_var->mutex);
	  if (in_use->mysys_var->current_cond)
	  {
	    pthread_mutex_lock(in_use->mysys_var->current_mutex);
            signalled= 1;
	    pthread_cond_broadcast(in_use->mysys_var->current_cond);
	    pthread_mutex_unlock(in_use->mysys_var->current_mutex);
	  }
	  pthread_mutex_unlock(&in_use->mysys_var->mutex);
        }
        /*
	  Now we must abort all tables locks used by this thread
8319 8320 8321 8322 8323 8324
	  as the thread may be waiting to get a lock for another table.
          Note that we need to hold LOCK_open while going through the
          list. So that the other thread cannot change it. The other
          thread must also hold LOCK_open whenever changing the
          open_tables list. Aborting the MERGE lock after a child was
          closed and before the parent is closed would be fatal.
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8325 8326 8327 8328 8329
        */
        for (TABLE *thd_table= in_use->open_tables;
	     thd_table ;
	     thd_table= thd_table->next)
        {
8330 8331
          /* Do not handle locks of MERGE children. */
	  if (thd_table->db_stat && !thd_table->parent)	// If table is open
8332
	    signalled|= mysql_lock_abort_for_thread(thd, thd_table);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8333
        }
8334
      }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8335
      else
8336 8337 8338
      {
        DBUG_PRINT("info", ("Table was in use by current thread. db_stat: %u",
                            table->db_stat));
8339
        result= result || (flags & RTFC_OWNED_BY_THD_FLAG);
8340
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8341
    }
8342
    while (unused_tables && !unused_tables->s->version)
8343
      VOID(hash_delete(&open_cache,(uchar*) unused_tables));
8344 8345 8346

    DBUG_PRINT("info", ("Removing table from table_def_cache"));
    /* Remove table from table definition cache if it's not in use */
8347
    if ((share= (TABLE_SHARE*) hash_search(&table_def_cache,(uchar*) key,
8348 8349 8350 8351 8352 8353 8354 8355
                                           key_length)))
    {
      DBUG_PRINT("info", ("share version: %lu  ref_count: %u",
                          share->version, share->ref_count));
      share->version= 0;                          // Mark for delete
      if (share->ref_count == 0)
      {
        pthread_mutex_lock(&share->mutex);
8356
        VOID(hash_delete(&table_def_cache, (uchar*) share));
8357 8358 8359
      }
    }

8360
    if (result && (flags & RTFC_WAIT_OTHER_THREAD_FLAG))
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8361
    {
monty@mysql.com's avatar
monty@mysql.com committed
8362 8363 8364 8365
      /*
        Signal any thread waiting for tables to be freed to
        reopen their tables
      */
8366
      broadcast_refresh();
monty@mysql.com's avatar
monty@mysql.com committed
8367
      DBUG_PRINT("info", ("Waiting for refresh signal"));
8368
      if (!(flags & RTFC_CHECK_KILLED_FLAG) || !thd->killed)
8369
      {
monty@mysql.com's avatar
monty@mysql.com committed
8370
        dropping_tables++;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8371 8372 8373 8374
        if (likely(signalled))
          (void) pthread_cond_wait(&COND_refresh, &LOCK_open);
        else
        {
monty@mysql.com's avatar
monty@mysql.com committed
8375
          struct timespec abstime;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8376 8377 8378 8379 8380 8381 8382 8383 8384 8385
          /*
            It can happen that another thread has opened the
            table but has not yet locked any table at all. Since
            it can be locked waiting for a table that our thread
            has done LOCK TABLE x WRITE on previously, we need to
            ensure that the thread actually hears our signal
            before we go to sleep. Thus we wait for a short time
            and then we retry another loop in the
            remove_table_from_cache routine.
          */
monty@mysql.com's avatar
monty@mysql.com committed
8386 8387
          set_timespec(abstime, 10);
          pthread_cond_timedwait(&COND_refresh, &LOCK_open, &abstime);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8388
        }
monty@mysql.com's avatar
monty@mysql.com committed
8389 8390
        dropping_tables--;
        continue;
8391
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8392
    }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8393
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8394 8395 8396 8397
  }
  DBUG_RETURN(result);
}

8398

8399
int setup_ftfuncs(SELECT_LEX *select_lex)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8400
{
8401 8402
  List_iterator<Item_func_match> li(*(select_lex->ftfunc_list)),
                                 lj(*(select_lex->ftfunc_list));
8403
  Item_func_match *ftf, *ftf2;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8404 8405

  while ((ftf=li++))
8406
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8407 8408
    if (ftf->fix_index())
      return 1;
8409 8410
    lj.rewind();
    while ((ftf2=lj++) != ftf)
8411
    {
8412
      if (ftf->eq(ftf2,1) && !ftf2->master)
8413 8414 8415
        ftf2->master=ftf;
    }
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8416 8417 8418

  return 0;
}
8419

8420

8421
int init_ftfuncs(THD *thd, SELECT_LEX *select_lex, bool no_order)
8422
{
8423
  if (select_lex->ftfunc_list->elements)
8424
  {
8425
    List_iterator<Item_func_match> li(*(select_lex->ftfunc_list));
8426 8427
    Item_func_match *ifm;
    DBUG_PRINT("info",("Performing FULLTEXT search"));
8428
    thd_proc_info(thd, "FULLTEXT initialization");
8429

8430 8431 8432
    while ((ifm=li++))
      ifm->init_search(no_order);
  }
8433 8434
  return 0;
}
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8435 8436 8437 8438 8439 8440 8441


/*
  open new .frm format table

  SYNOPSIS
    open_new_frm()
8442
    THD		  thread handler
8443
    path	  path to .frm file (without extension)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8444
    alias	  alias for table
8445 8446
    db            database
    table_name    name of table
8447
    db_stat	  open flags (for example ->OPEN_KEYFILE|HA_OPEN_RNDFILE..)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8448 8449 8450 8451 8452 8453 8454
		  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
*/
8455

8456
static bool
8457
open_new_frm(THD *thd, TABLE_SHARE *share, const char *alias,
8458
             uint db_stat, uint prgflag,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8459 8460 8461 8462
	     uint ha_open_flags, TABLE *outparam, TABLE_LIST *table_desc,
	     MEM_ROOT *mem_root)
{
  LEX_STRING pathstr;
8463
  File_parser *parser;
8464
  char path[FN_REFLEN];
8465 8466
  DBUG_ENTER("open_new_frm");

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

8472
  if ((parser= sql_parse_prepare(&pathstr, mem_root, 1)))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8473
  {
8474
    if (is_equal(&view_type, parser->type()))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8475
    {
8476
      if (table_desc == 0 || table_desc->required_type == FRMTYPE_TABLE)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8477
      {
8478 8479
        my_error(ER_WRONG_OBJECT, MYF(0), share->db.str, share->table_name.str,
                 "BASE TABLE");
8480
        goto err;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8481
      }
8482 8483
      if (mysql_make_view(thd, parser, table_desc,
                          (prgflag & OPEN_VIEW_NO_PARSE)))
8484
        goto err;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8485 8486 8487 8488
    }
    else
    {
      /* only VIEWs are supported now */
8489
      my_error(ER_FRM_UNKNOWN_TYPE, MYF(0), share->path.str,  parser->type()->str);
8490
      goto err;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8491
    }
8492
    DBUG_RETURN(0);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8493
  }
monty@mysql.com's avatar
monty@mysql.com committed
8494
 
8495 8496 8497
err:
  bzero(outparam, sizeof(TABLE));	// do not run repair
  DBUG_RETURN(1);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8498
}
8499 8500 8501 8502 8503 8504


bool is_equal(const LEX_STRING *a, const LEX_STRING *b)
{
  return a->length == b->length && !strncmp(a->str, b->str, a->length);
}
8505 8506 8507 8508 8509 8510 8511


/*
  SYNOPSIS
    abort_and_upgrade_lock()
    lpt                           Parameter passing struct
    All parameters passed through the ALTER_PARTITION_PARAM_TYPE object
8512 8513
  RETURN VALUE
    0
8514 8515 8516 8517 8518 8519 8520 8521 8522 8523 8524 8525 8526
  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
*/

8527
int abort_and_upgrade_lock(ALTER_PARTITION_PARAM_TYPE *lpt)
8528 8529 8530 8531 8532 8533
{
  uint flags= RTFC_WAIT_OTHER_THREAD_FLAG | RTFC_CHECK_KILLED_FLAG;
  DBUG_ENTER("abort_and_upgrade_locks");

  lpt->old_lock_type= lpt->table->reginfo.lock_type;
  VOID(pthread_mutex_lock(&LOCK_open));
8534 8535 8536
  /* If MERGE child, forward lock handling to parent. */
  mysql_lock_abort(lpt->thd, lpt->table->parent ? lpt->table->parent :
                   lpt->table, TRUE);
8537 8538
  VOID(remove_table_from_cache(lpt->thd, lpt->db, lpt->table_name, flags));
  VOID(pthread_mutex_unlock(&LOCK_open));
8539
  DBUG_RETURN(0);
8540 8541 8542 8543 8544 8545 8546 8547 8548 8549 8550 8551 8552 8553 8554 8555 8556
}


/*
  SYNOPSIS
    close_open_tables_and_downgrade()
  RESULT VALUES
    NONE
  DESCRIPTION
    We need to ensure that any thread that has managed to open the table
    but not yet encountered our lock on the table is also thrown out to
    ensure that no threads see our frm changes premature to the final
    version. The intermediate versions are only meant for use after a
    crash and later REPAIR TABLE.
    We also downgrade locks after the upgrade to WRITE_ONLY
*/

8557
/* purecov: begin deadcode */
8558 8559 8560 8561 8562 8563
void close_open_tables_and_downgrade(ALTER_PARTITION_PARAM_TYPE *lpt)
{
  VOID(pthread_mutex_lock(&LOCK_open));
  remove_table_from_cache(lpt->thd, lpt->db, lpt->table_name,
                          RTFC_WAIT_OTHER_THREAD_FLAG);
  VOID(pthread_mutex_unlock(&LOCK_open));
8564 8565 8566
  /* If MERGE child, forward lock handling to parent. */
  mysql_lock_downgrade_write(lpt->thd, lpt->table->parent ? lpt->table->parent :
                             lpt->table, lpt->old_lock_type);
8567
}
8568
/* purecov: end */
8569 8570 8571 8572 8573 8574 8575 8576 8577 8578 8579 8580 8581 8582 8583 8584 8585 8586 8587 8588 8589 8590 8591 8592 8593 8594 8595 8596 8597 8598 8599 8600 8601 8602 8603


/*
  SYNOPSIS
    mysql_wait_completed_table()
    lpt                            Parameter passing struct
    my_table                       My table object
    All parameters passed through the ALTER_PARTITION_PARAM object
  RETURN VALUES
    TRUE                          Failure
    FALSE                         Success
  DESCRIPTION
    We have changed the frm file and now we want to wait for all users of
    the old frm to complete before proceeding to ensure that no one
    remains that uses the old frm definition.
    Start by ensuring that all users of the table will be removed from cache
    once they are done. Then abort all that have stumbled on locks and
    haven't been started yet.

    thd                           Thread object
    table                         Table object
    db                            Database name
    table_name                    Table name
*/

void mysql_wait_completed_table(ALTER_PARTITION_PARAM_TYPE *lpt, TABLE *my_table)
{
  char key[MAX_DBKEY_LENGTH];
  uint key_length;
  TABLE *table;
  DBUG_ENTER("mysql_wait_completed_table");

  key_length=(uint) (strmov(strmov(key,lpt->db)+1,lpt->table_name)-key)+1;
  VOID(pthread_mutex_lock(&LOCK_open));
  HASH_SEARCH_STATE state;
8604
  for (table= (TABLE*) hash_first(&open_cache,(uchar*) key,key_length,
8605 8606
                                  &state) ;
       table;
8607
       table= (TABLE*) hash_next(&open_cache,(uchar*) key,key_length,
8608 8609 8610 8611 8612 8613 8614 8615 8616 8617 8618 8619 8620 8621 8622 8623 8624 8625 8626 8627 8628 8629 8630 8631 8632 8633
                                 &state))
  {
    THD *in_use= table->in_use;
    table->s->version= 0L;
    if (!in_use)
    {
      relink_unused(table);
    }
    else
    {
      /* Kill delayed insert threads */
      if ((in_use->system_thread & SYSTEM_THREAD_DELAYED_INSERT) &&
          ! in_use->killed)
      {
        in_use->killed= THD::KILL_CONNECTION;
        pthread_mutex_lock(&in_use->mysys_var->mutex);
        if (in_use->mysys_var->current_cond)
        {
          pthread_mutex_lock(in_use->mysys_var->current_mutex);
          pthread_cond_broadcast(in_use->mysys_var->current_cond);
          pthread_mutex_unlock(in_use->mysys_var->current_mutex);
        }
        pthread_mutex_unlock(&in_use->mysys_var->mutex);
      }
      /*
        Now we must abort all tables locks used by this thread
8634 8635 8636 8637 8638 8639
        as the thread may be waiting to get a lock for another table.
        Note that we need to hold LOCK_open while going through the
        list. So that the other thread cannot change it. The other
        thread must also hold LOCK_open whenever changing the
        open_tables list. Aborting the MERGE lock after a child was
        closed and before the parent is closed would be fatal.
8640 8641 8642 8643 8644
      */
      for (TABLE *thd_table= in_use->open_tables;
           thd_table ;
           thd_table= thd_table->next)
      {
8645 8646
        /* Do not handle locks of MERGE children. */
        if (thd_table->db_stat && !thd_table->parent) // If table is open
8647 8648 8649 8650 8651 8652 8653 8654 8655
          mysql_lock_abort_for_thread(lpt->thd, thd_table);
      }
    }
  }
  /*
    We start by removing all unused objects from the cache and marking
    those in use for removal after completion. Now we also need to abort
    all that are locked and are not progressing due to being locked
    by our lock. We don't upgrade our lock here.
8656
    If MERGE child, forward lock handling to parent.
8657
  */
8658 8659
  mysql_lock_abort(lpt->thd, my_table->parent ? my_table->parent : my_table,
                   FALSE);
8660 8661 8662 8663
  VOID(pthread_mutex_unlock(&LOCK_open));
  DBUG_VOID_RETURN;
}

8664 8665 8666 8667 8668 8669 8670 8671 8672 8673 8674 8675 8676 8677 8678 8679 8680 8681 8682 8683 8684 8685 8686

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

  SYNOPSIS
    has_two_write_locked_tables_with_auto_increment
      tables        Table list

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

  RETURN
    0  No
    1  Yes
*/

static bool
has_two_write_locked_tables_with_auto_increment(TABLE_LIST *tables)
{
  char *first_table_name= NULL, *first_db;
8687 8688
  LINT_INIT(first_db);

8689 8690 8691
  for (TABLE_LIST *table= tables; table; table= table->next_global)
  {
    /* we must do preliminary checks as table->table may be NULL */
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
8692
    if (!table->placeholder() &&
8693 8694 8695 8696 8697 8698 8699 8700 8701 8702 8703 8704 8705 8706 8707 8708
        table->table->found_next_number_field &&
        (table->lock_type >= TL_WRITE_ALLOW_WRITE))
    {
      if (first_table_name == NULL)
      {
        first_table_name= table->table_name;
        first_db= table->db;
        DBUG_ASSERT(first_db);
      }
      else if (strcmp(first_db, table->db) ||
               strcmp(first_table_name, table->table_name))
        return 1;
    }
  }
  return 0;
}
8709 8710 8711 8712 8713 8714 8715 8716 8717 8718 8719 8720 8721 8722 8723 8724 8725 8726 8727 8728 8729 8730 8731 8732 8733 8734 8735 8736 8737 8738 8739 8740 8741 8742 8743 8744 8745 8746 8747 8748 8749 8750 8751


/*
  Open and lock system tables for read.

  SYNOPSIS
    open_system_tables_for_read()
      thd         Thread context.
      table_list  List of tables to open.
      backup      Pointer to Open_tables_state instance where
                  information about currently open tables will be
                  saved, and from which will be restored when we will
                  end work with system tables.

  NOTES
    Thanks to restrictions which we put on opening and locking of
    system tables for writing, we can open and lock them for reading
    even when we already have some other tables open and locked.  One
    must call close_system_tables() to close systems tables opened
    with this call.

  RETURN
    FALSE   Success
    TRUE    Error
*/

bool
open_system_tables_for_read(THD *thd, TABLE_LIST *table_list,
                            Open_tables_state *backup)
{
  DBUG_ENTER("open_system_tables_for_read");

  thd->reset_n_backup_open_tables_state(backup);

  uint count= 0;
  bool not_used;
  for (TABLE_LIST *tables= table_list; tables; tables= tables->next_global)
  {
    TABLE *table= open_table(thd, tables, thd->mem_root, &not_used,
                             MYSQL_LOCK_IGNORE_FLUSH);
    if (!table)
      goto error;

8752
    DBUG_ASSERT(table->s->table_category == TABLE_CATEGORY_SYSTEM);
8753 8754 8755 8756 8757 8758 8759 8760 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 8789 8790 8791 8792 8793 8794 8795 8796 8797 8798 8799 8800 8801 8802 8803 8804 8805 8806 8807 8808 8809 8810 8811 8812 8813 8814 8815 8816 8817 8818

    table->use_all_columns();
    table->reginfo.lock_type= tables->lock_type;
    tables->table= table;
    count++;
  }

  {
    TABLE **list= (TABLE**) thd->alloc(sizeof(TABLE*) * count);
    TABLE **ptr= list;
    for (TABLE_LIST *tables= table_list; tables; tables= tables->next_global)
      *(ptr++)= tables->table;

    thd->lock= mysql_lock_tables(thd, list, count,
                                 MYSQL_LOCK_IGNORE_FLUSH, &not_used);
  }
  if (thd->lock)
    DBUG_RETURN(FALSE);

error:
  close_system_tables(thd, backup);

  DBUG_RETURN(TRUE);
}


/*
  Close system tables, opened with open_system_tables_for_read().

  SYNOPSIS
    close_system_tables()
      thd     Thread context
      backup  Pointer to Open_tables_state instance which holds
              information about tables which were open before we
              decided to access system tables.
*/

void
close_system_tables(THD *thd, Open_tables_state *backup)
{
  close_thread_tables(thd);
  thd->restore_backup_open_tables_state(backup);
}


/*
  Open and lock one system table for update.

  SYNOPSIS
    open_system_table_for_update()
      thd        Thread context.
      one_table  Table to open.

  NOTES
    Table opened with this call should closed using close_thread_tables().

  RETURN
    0	Error
    #	Pointer to TABLE object of system table
*/

TABLE *
open_system_table_for_update(THD *thd, TABLE_LIST *one_table)
{
  DBUG_ENTER("open_system_table_for_update");

8819
  TABLE *table= open_ltable(thd, one_table, one_table->lock_type, 0);
8820 8821
  if (table)
  {
8822
    DBUG_ASSERT(table->s->table_category == TABLE_CATEGORY_SYSTEM);
8823 8824 8825 8826 8827
    table->use_all_columns();
  }

  DBUG_RETURN(table);
}
8828 8829 8830 8831 8832 8833 8834 8835 8836 8837 8838 8839 8840 8841 8842 8843

/**
  Open a performance schema table.
  Opening such tables is performed internally in the server
  implementation, and is a 'nested' open, since some tables
  might be already opened by the current thread.
  The thread context before this call is saved, and is restored
  when calling close_performance_schema_table().
  @param thd The current thread
  @param one_table Performance schema table to open
  @param backup [out] Temporary storage used to save the thread context
*/
TABLE *
open_performance_schema_table(THD *thd, TABLE_LIST *one_table,
                              Open_tables_state *backup)
{
8844 8845 8846 8847 8848 8849 8850
  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;
8851 8852 8853 8854
  DBUG_ENTER("open_performance_schema_table");

  thd->reset_n_backup_open_tables_state(backup);

8855
  if ((table= open_ltable(thd, one_table, one_table->lock_type, flags)))
8856 8857 8858
  {
    DBUG_ASSERT(table->s->table_category == TABLE_CATEGORY_PERFORMANCE);
    /* Make sure all columns get assigned to a default value */
8859
    table->use_all_columns();
8860
    table->no_replicate= 1;
8861 8862 8863 8864 8865
    /*
      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;
8866
  }
8867
  else
8868 8869 8870 8871 8872 8873 8874 8875 8876
  {
    /*
      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);
8877
    thd->restore_backup_open_tables_state(backup);
8878
  }
8879

8880
  thd->utime_after_lock= save_utime_after_lock;
8881 8882
  DBUG_RETURN(table);
}
8883 8884 8885 8886 8887 8888 8889 8890 8891 8892 8893 8894

/**
  Close a performance schema table.
  The last table opened by open_performance_schema_table()
  is closed, then the thread context is restored.
  @param thd The current thread
  @param backup [in] the context to restore.
*/
void close_performance_schema_table(THD *thd, Open_tables_state *backup)
{
  bool found_old_table;

8895 8896 8897 8898 8899
  /*
    If open_performance_schema_table() fails,
    this function should not be called.
  */
  DBUG_ASSERT(thd->lock != NULL);
8900

8901 8902 8903 8904 8905 8906 8907 8908 8909 8910 8911 8912 8913
  /*
    Note:
    We do not create explicitly a separate transaction for the
    performance table I/O, but borrow the current transaction.
    lock + unlock will autocommit the change done in the
    performance schema table: this is the expected result.
    The current transaction should not be affected by this code.
    TODO: Note that if a transactional engine is used for log tables,
    this code will need to be revised, as a separate transaction
    might be needed.
  */
  mysql_unlock_tables(thd, thd->lock);
  thd->lock= 0;
8914 8915 8916 8917

  pthread_mutex_lock(&LOCK_open);

  found_old_table= false;
8918 8919 8920 8921 8922 8923 8924
  /*
    Note that we need to hold LOCK_open while changing the
    open_tables list. Another thread may work on it.
    (See: remove_table_from_cache(), mysql_wait_completed_table())
    Closing a MERGE child before the parent would be fatal if the
    other thread tries to abort the MERGE lock in between.
  */
8925 8926 8927 8928 8929 8930 8931 8932 8933 8934 8935
  while (thd->open_tables)
    found_old_table|= close_thread_table(thd, &thd->open_tables);

  if (found_old_table)
    broadcast_refresh();

  pthread_mutex_unlock(&LOCK_open);

  thd->restore_backup_open_tables_state(backup);
}

8936 8937 8938
/**
  @} (end of group Data_Dictionary)
*/