sql_base.cc 280 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
                                         key_length)))
    goto found;

  if (!(share= alloc_table_share(table_list, key, key_length)))
  {
348
#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
349 350 351 352 353
    pthread_mutex_unlock(&LOCK_open);
#endif
    DBUG_RETURN(0);
  }

354
#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
355 356 357 358
  // We need a write lock to be able to add a new entry
  pthread_mutex_unlock(&LOCK_open);
  pthread_mutex_lock(&LOCK_open);
  /* Check that another thread didn't insert the same table in between */
359
  if ((old_share= hash_search(&table_def_cache, (uchar*) key, key_length)))
360 361 362 363 364 365 366 367 368 369 370 371 372
  {
    (void) pthread_mutex_lock(&share->mutex);
    free_table_share(share);
    share= old_share;
    goto found;
  }
#endif

  /*
    Lock mutex to be able to read table definition from file without
    conflicts
  */
  (void) pthread_mutex_lock(&share->mutex);
373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388

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

389
  if (my_hash_insert(&table_def_cache, (uchar*) share))
390
  {
391
#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
392 393 394 395 396 397
    pthread_mutex_unlock(&LOCK_open);    
    (void) pthread_mutex_unlock(&share->mutex);
#endif
    free_table_share(share);
    DBUG_RETURN(0);				// return error
  }
398
#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
399 400 401 402
  pthread_mutex_unlock(&LOCK_open);
#endif
  if (open_table_def(thd, share, db_flags))
  {
403
#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
404 405 406 407 408 409 410 411 412 413 414
    /*
      No such table or wrong table definition file
      Lock first the table cache and then the mutex.
      This will ensure that no other thread is using the share
      structure.
    */
    (void) pthread_mutex_unlock(&share->mutex);
    (void) pthread_mutex_lock(&LOCK_open);
    (void) pthread_mutex_lock(&share->mutex);
#endif
    *error= share->error;
415
    (void) hash_delete(&table_def_cache, (uchar*) share);
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);
432
#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469
  pthread_mutex_unlock(&LOCK_open);
#endif
  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);
470
    VOID(hash_delete(&table_def_cache, (uchar*) oldest_unused_share));
471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
  }

  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,
487
                             char *key, uint key_length,
488 489 490 491 492 493
                             uint db_flags, int *error)
{
  TABLE_SHARE *share;
  int tmp;
  DBUG_ENTER("get_table_share_with_create");

494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
  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)

516 517 518 519 520 521 522 523
    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.
524 525 526 527 528
      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.
529
    */
530
    if (thd->is_error() && table_list->belong_to_view)
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 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615
    {
      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"));
616
    hash_delete(&table_def_cache, (uchar*) share);
617 618 619 620 621 622
    DBUG_VOID_RETURN;
  }
  pthread_mutex_unlock(&share->mutex);
  DBUG_VOID_RETURN;


623
#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641
  if (to_be_deleted)
  {
    /*
      We must try again with new locks as we must get LOCK_open
      before share->mutex
    */
    pthread_mutex_unlock(&share->mutex);
    pthread_mutex_lock(&LOCK_open);
    pthread_mutex_lock(&share->mutex);
    if (!share->ref_count)
    {						// No one is using this now
      TABLE_SHARE *name_lock;
      if (share->replace_with_name_lock && (name_lock=get_name_lock(share)))
      {
	/*
	  This code is execured when someone does FLUSH TABLES while on has
	  locked tables.
	 */
642 643
	(void) hash_search(&def_cache,(uchar*) key,key_length);
	hash_replace(&def_cache, def_cache.current_record,(uchar*) name_lock);
644 645 646 647
      }
      else
      {
	/* Remove table definition */
648
	hash_delete(&def_cache,(uchar*) share);
649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684
      }
      pthread_mutex_unlock(&LOCK_open);
      free_table_share(share);
    }
    else
    {
      pthread_mutex_unlock(&LOCK_open);
      if (type == RELEASE_WAIT_FOR_DROP)
	wait_for_table(share, "Waiting for close");
      else
	pthread_mutex_unlock(&share->mutex);
    }
  }
  else if (type == RELEASE_WAIT_FOR_DROP)
    wait_for_table(share, "Waiting for close");
  else
    pthread_mutex_unlock(&share->mutex);
#endif
}


/*
  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)
{
685
  char key[NAME_LEN*2+2];
686 687 688 689 690 691 692
  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);
693
  return (TABLE_SHARE*) hash_search(&table_def_cache,(uchar*) key, key_length);
694 695 696 697 698 699 700 701 702 703 704 705 706 707 708
}  


/*
  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
709 710 711

    If closing a MERGE child, the calling function has to take care for
    closing the parent too, if necessary.
712 713 714
*/


715
void close_handle_and_leave_table_as_lock(TABLE *table)
716 717
{
  TABLE_SHARE *share, *old_share= table->s;
718
  char *key_buff;
719 720 721
  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
722 723
  DBUG_ASSERT(table->db_stat);

724 725 726 727 728
  /*
    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
  */
729 730 731 732
  if (multi_alloc_root(mem_root,
                       &share, sizeof(*share),
                       &key_buff, old_share->table_cache_key.length,
                       NULL))
733 734
  {
    bzero((char*) share, sizeof(*share));
735 736
    share->set_table_cache_key(key_buff, old_share->table_cache_key.str,
                               old_share->table_cache_key.length);
737 738 739
    share->tmp_table= INTERNAL_TMP_TABLE;       // for intern_close_table()
  }

740 741 742 743 744 745
  /*
    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);
746 747 748 749
  table->file->close();
  table->db_stat= 0;                            // Mark file closed
  release_table_share(table->s, RELEASE_NORMAL);
  table->s= share;
750
  table->file->change_table_ptr(table, table->s);
751 752 753 754 755 756

  DBUG_VOID_RETURN;
}



monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774
/*
  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.
*/

775
OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *db, const char *wild)
776 777
{
  int result = 0;
778
  OPEN_TABLE_LIST **start_list, *open_list;
779 780
  TABLE_LIST table_list;
  DBUG_ENTER("list_open_tables");
781

782 783
  VOID(pthread_mutex_lock(&LOCK_open));
  bzero((char*) &table_list,sizeof(table_list));
784 785
  start_list= &open_list;
  open_list=0;
786

787
  for (uint idx=0 ; result == 0 && idx < open_cache.records; idx++)
788
  {
789
    OPEN_TABLE_LIST *table;
790
    TABLE *entry=(TABLE*) hash_element(&open_cache,idx);
791
    TABLE_SHARE *share= entry->s;
792

793
    if (db && my_strcasecmp(system_charset_info, db, share->db.str))
794
      continue;
795
    if (wild && wild_compare(share->table_name.str, wild, 0))
796
      continue;
797

798
    /* Check if user has SELECT privilege for any column in the table */
799 800
    table_list.db=         share->db.str;
    table_list.table_name= share->table_name.str;
801
    table_list.grant.privilege=0;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
802

803
    if (check_table_access(thd,SELECT_ACL | EXTRA_ACL,&table_list, 1, TRUE))
804 805 806
      continue;
    /* need to check if we haven't already listed it */
    for (table= open_list  ; table ; table=table->next)
807
    {
808 809
      if (!strcmp(table->table, share->table_name.str) &&
	  !strcmp(table->db,    share->db.str))
810 811 812 813 814 815 816
      {
	if (entry->in_use)
	  table->in_use++;
	if (entry->locked_by_name)
	  table->locked++;
	break;
      }
817
    }
818
    if (table)
819
      continue;
820
    if (!(*start_list = (OPEN_TABLE_LIST *)
821
	  sql_alloc(sizeof(**start_list)+share->table_cache_key.length)))
822
    {
823
      open_list=0;				// Out of memory
824
      break;
825
    }
826 827
    strmov((*start_list)->table=
	   strmov(((*start_list)->db= (char*) ((*start_list)+1)),
828 829
		  share->db.str)+1,
	   share->table_name.str);
830 831 832
    (*start_list)->in_use= entry->in_use ? 1 : 0;
    (*start_list)->locked= entry->locked_by_name ? 1 : 0;
    start_list= &(*start_list)->next;
833
    *start_list=0;
834 835
  }
  VOID(pthread_mutex_unlock(&LOCK_open));
836
  DBUG_RETURN(open_list);
837
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
838 839 840 841 842 843 844 845

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


void intern_close_table(TABLE *table)
{						// Free all structures
846
  DBUG_ENTER("intern_close_table");
847 848 849 850
  DBUG_PRINT("tcache", ("table: '%s'.'%s' 0x%lx",
                        table->s ? table->s->db.str : "?",
                        table->s ? table->s->table_name.str : "?",
                        (long) table));
851

bk@work.mysql.com's avatar
bk@work.mysql.com committed
852
  free_io_cache(table);
853
  delete table->triggers;
854 855 856
  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
857 858
}

859 860 861 862 863 864 865 866 867 868
/*
  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
869 870 871 872 873

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

874 875 876
  /* 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
877 878 879 880 881 882 883 884 885 886 887 888 889
  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
  }
890
  my_free((uchar*) table,MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
891 892 893
  DBUG_VOID_RETURN;
}

894
/* Free resources allocated by filesort() and read_record() */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
895 896 897

void free_io_cache(TABLE *table)
{
898
  DBUG_ENTER("free_io_cache");
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
899
  if (table->sort.io_cache)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
900
  {
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
901
    close_cached_file(table->sort.io_cache);
902
    my_free((uchar*) table->sort.io_cache,MYF(0));
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
903
    table->sort.io_cache=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
904
  }
905
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
906 907
}

908

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

912 913 914 915 916 917 918 919 920 921
  @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.
922
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
923

924 925
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
926 927 928
{
  bool result=0;
  DBUG_ENTER("close_cached_tables");
929
  DBUG_ASSERT(thd || (!wait_for_refresh && !tables));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
930

tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
931 932
  if (!have_lock)
    VOID(pthread_mutex_lock(&LOCK_open));
933
  if (!tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
934
  {
935
    refresh_version++;				// Force close of open tables
936 937
    while (unused_tables)
    {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
938
#ifdef EXTRA_DEBUG
939
      if (hash_delete(&open_cache,(uchar*) unused_tables))
940
	printf("Warning: Couldn't delete open table from hash\n");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
941
#else
942
      VOID(hash_delete(&open_cache,(uchar*) unused_tables));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
943
#endif
944
    }
945 946 947 948
    /* Free table shares */
    while (oldest_unused_share->next)
    {
      pthread_mutex_lock(&oldest_unused_share->mutex);
949
      VOID(hash_delete(&table_def_cache, (uchar*) oldest_unused_share));
950
    }
951 952
    DBUG_PRINT("tcache", ("incremented global refresh_version to: %lu",
                          refresh_version));
953
    if (wait_for_refresh)
954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998
    {
      /*
        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
999
  }
1000
  else
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1001
  {
1002
    bool found=0;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1003
    for (TABLE_LIST *table= tables; table; table= table->next_local)
1004
    {
1005
      if (remove_table_from_cache(thd, table->db, table->table_name,
1006
                                  RTFC_OWNED_BY_THD_FLAG))
1007 1008 1009
	found=1;
    }
    if (!found)
1010
      wait_for_refresh=0;			// Nothing to wait for
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1011
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1012
#ifndef EMBEDDED_LIBRARY
1013 1014
  if (!tables)
    kill_delayed_threads();
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1015
#endif
1016
  if (wait_for_refresh)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1017 1018 1019 1020 1021 1022 1023
  {
    /*
      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;
1024
    thd_proc_info(thd, "Flushing tables");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1025

1026
    close_old_data_files(thd,thd->open_tables,1,1);
1027 1028
    mysql_ha_flush(thd);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1029 1030
    bool found=1;
    /* Wait until all threads has closed all the tables we had locked */
1031
    DBUG_PRINT("info",
monty@mysql.com's avatar
monty@mysql.com committed
1032
	       ("Waiting for other threads to close their open tables"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1033 1034 1035 1036 1037 1038
    while (found && ! thd->killed)
    {
      found=0;
      for (uint idx=0 ; idx < open_cache.records ; idx++)
      {
	TABLE *table=(TABLE*) hash_element(&open_cache,idx);
1039 1040 1041
        /* Avoid a self-deadlock. */
        if (table->in_use == thd)
          continue;
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055
        /*
          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.
        */
1056 1057
	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
1058 1059
	{
	  found=1;
monty@mysql.com's avatar
monty@mysql.com committed
1060
          DBUG_PRINT("signal", ("Waiting for COND_refresh"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073
	  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;
1074
    /* Set version for table */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1075
    for (TABLE *table=thd->open_tables; table ; table= table->next)
1076 1077 1078 1079 1080 1081 1082 1083
    {
      /*
        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
1084
  }
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
1085 1086
  if (!have_lock)
    VOID(pthread_mutex_unlock(&LOCK_open));
1087
  if (wait_for_refresh)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1088 1089 1090 1091
  {
    pthread_mutex_lock(&thd->mysys_var->mutex);
    thd->mysys_var->current_mutex= 0;
    thd->mysys_var->current_cond= 0;
1092
    thd_proc_info(thd, 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1093 1094 1095 1096 1097 1098
    pthread_mutex_unlock(&thd->mysys_var->mutex);
  }
  DBUG_RETURN(result);
}


1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
/*
  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));
1114

1115 1116
  if (!have_lock)
    VOID(pthread_mutex_lock(&LOCK_open));
1117

1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145
  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)
1146 1147
    result= close_cached_tables(thd, tables, TRUE, FALSE, FALSE);

1148 1149
  if (!have_lock)
    VOID(pthread_mutex_unlock(&LOCK_open));
1150

1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163
  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);
}


1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181
/**
  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();
1182 1183 1184 1185 1186 1187 1188 1189
      /*
        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);
1190 1191 1192 1193 1194
    }
  }
}


1195
/*
1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206
  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.
1207 1208 1209 1210 1211 1212 1213 1214 1215

  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.
1216 1217 1218 1219 1220
*/

static void mark_used_tables_as_free_for_reuse(THD *thd, TABLE *table)
{
  for (; table ; table= table->next)
1221
  {
1222
    if (table->query_id == thd->query_id)
1223
    {
1224
      table->query_id= 0;
1225 1226 1227
      table->file->ha_reset();
    }
  }
1228 1229 1230
}


1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266
/**
  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));
}


1267 1268 1269
/*
  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
1270

1271 1272 1273 1274 1275 1276 1277
  SYNOPSIS
    close_thread_tables()
    thd			Thread handler

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

1279 1280 1281 1282
    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.
1283
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1284

1285
void close_thread_tables(THD *thd)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1286
{
1287
  TABLE *table;
1288
  prelocked_mode_type prelocked_mode= thd->prelocked_mode;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1289 1290
  DBUG_ENTER("close_thread_tables");

1291 1292 1293 1294 1295 1296 1297
#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

1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308
  /*
    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.
  */
1309
  if (thd->derived_tables)
1310
  {
1311
    TABLE *next;
1312
    /*
1313 1314
      Close all derived tables generated in queries like
      SELECT * FROM (SELECT * FROM t1)
1315 1316 1317 1318 1319 1320 1321 1322
    */
    for (table= thd->derived_tables ; table ; table= next)
    {
      next= table->next;
      free_tmp_table(thd, table);
    }
    thd->derived_tables= 0;
  }
1323

1324 1325 1326 1327
  /*
    Mark all temporary tables used by this statement as free for reuse.
  */
  mark_temp_tables_as_free_for_reuse(thd);
1328 1329 1330 1331 1332 1333 1334 1335 1336
  /*
    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))
1337
  {
1338 1339 1340 1341
    thd->main_da.can_overwrite_status= TRUE;
    ha_autocommit_or_rollback(thd, thd->is_error());
    thd->main_da.can_overwrite_status= FALSE;

1342
    /*
1343 1344
      Reset transaction state, but only if we're not inside a
      sub-statement of a prelocked statement.
1345
    */
1346 1347 1348 1349 1350 1351
    if (! prelocked_mode || thd->lex->requires_prelocking())
      thd->transaction.stmt.reset();
  }

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

1353 1354
    /* Ensure we are calling ha_reset() for all used tables */
    mark_used_tables_as_free_for_reuse(thd, thd->open_tables);
1355

1356 1357 1358 1359
    /*
      We are under simple LOCK TABLES or we're inside a sub-statement
      of a prelocked statement, so should not do anything else.
    */
1360
    if (!prelocked_mode || !thd->lex->requires_prelocking())
1361 1362 1363
      DBUG_VOID_RETURN;

    /*
1364 1365 1366
      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.
1367
    */
1368
    DBUG_PRINT("info",("thd->prelocked_mode= NON_PRELOCKED"));
1369 1370 1371 1372 1373 1374 1375 1376
    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 */
1377
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1378 1379 1380

  if (thd->lock)
  {
1381 1382 1383 1384 1385 1386 1387 1388 1389
    /*
      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.
     */
1390
    thd->binlog_flush_pending_rows_event(TRUE);
1391 1392
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1393
  }
1394 1395 1396 1397 1398 1399 1400
  /*
    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.
  */
1401 1402
  if (thd->open_tables)
    close_open_tables(thd);
1403 1404 1405 1406 1407 1408 1409 1410

  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());
1411
    thd->options&= ~(OPTION_TABLE_LOCK);
1412 1413
  }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1414 1415 1416
  DBUG_VOID_RETURN;
}

1417

1418 1419 1420 1421
/* move one table to free list */

bool close_thread_table(THD *thd, TABLE **table_ptr)
{
1422 1423
  bool found_old_table= 0;
  TABLE *table= *table_ptr;
1424
  DBUG_ENTER("close_thread_table");
1425
  DBUG_ASSERT(table->key_read == 0);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
1426
  DBUG_ASSERT(!table->file || table->file->inited == handler::NONE);
1427 1428
  DBUG_PRINT("tcache", ("table: '%s'.'%s' 0x%lx", table->s->db.str,
                        table->s->table_name.str, (long) table));
1429 1430

  *table_ptr=table->next;
1431 1432 1433 1434 1435 1436 1437
  /*
    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
1438
  if (table->needs_reopen_or_name_lock() ||
1439 1440
      thd->version != refresh_version || !table->db_stat)
  {
1441
    VOID(hash_delete(&open_cache,(uchar*) table));
1442 1443 1444 1445
    found_old_table=1;
  }
  else
  {
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
1446 1447 1448 1449 1450 1451
    /*
      Open placeholders have TABLE::db_stat set to 0, so they should be
      handled by the first alternative.
    */
    DBUG_ASSERT(!table->open_placeholder);

1452 1453 1454
    /* Assert that MERGE children are not attached in unused_tables. */
    DBUG_ASSERT(!table->is_children_attached());

1455
    /* Free memory and reset for next loop */
1456
    table->file->ha_reset();
1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470
    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
1471

1472 1473 1474 1475 1476 1477 1478
/* 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);
}


1479 1480
/*
  Close all temporary tables created by 'CREATE TEMPORARY TABLE' for thread
1481
  creates one DROP TEMPORARY TABLE binlog event for each pseudo-thread 
1482
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1483 1484 1485

void close_temporary_tables(THD *thd)
{
1486
  TABLE *table;
1487 1488 1489 1490
  TABLE *next;
  TABLE *prev_table;
  /* Assume thd->options has OPTION_QUOTE_SHOW_CREATE */
  bool was_quote_show= TRUE;
1491
  LINT_INIT(next);
1492

1493 1494
  if (!thd->temporary_tables)
    return;
1495

1496 1497
  if (!mysql_bin_log.is_open() || thd->current_stmt_binlog_row_based)
  {
1498 1499
    TABLE *tmp_next;
    for (table= thd->temporary_tables; table; table= tmp_next)
1500
    {
1501
      tmp_next= table->next;
1502 1503 1504 1505 1506 1507
      close_temporary(table, 1, 1);
    }
    thd->temporary_tables= 0;
    return;
  }

1508
  /* Better add "if exists", in case a RESET MASTER has been done */
1509 1510 1511 1512
  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);
1513
  bool found_user_tables= FALSE;
1514

1515 1516
  memcpy(buf, stub, stub_len);

1517
  /*
1518 1519
    Insertion sort of temp tables by pseudo_thread_id to build ordered list
    of sublists of equal pseudo_thread_id
1520
  */
1521 1522

  for (prev_table= thd->temporary_tables, table= prev_table->next;
1523 1524
       table;
       prev_table= table, table= table->next)
1525
  {
1526 1527
    TABLE *prev_sorted /* same as for prev_table */, *sorted;
    if (is_user_table(table))
1528
    {
1529 1530 1531 1532
      if (!found_user_tables)
        found_user_tables= true;
      for (prev_sorted= NULL, sorted= thd->temporary_tables; sorted != table;
           prev_sorted= sorted, sorted= sorted->next)
1533
      {
1534 1535
        if (!is_user_table(sorted) ||
            tmpkeyval(thd, sorted) > tmpkeyval(thd, table))
1536
        {
1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549
          /* 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;
1550 1551 1552
        }
      }
    }
1553
  }
1554 1555 1556

  /* We always quote db,table names though it is slight overkill */
  if (found_user_tables &&
1557
      !(was_quote_show= test(thd->options & OPTION_QUOTE_SHOW_CREATE)))
1558
  {
1559
    thd->options |= OPTION_QUOTE_SHOW_CREATE;
1560
  }
1561

1562
  /* scan sorted tmps to generate sequence of DROP */
1563
  for (table= thd->temporary_tables; table; table= next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1564
  {
1565
    if (is_user_table(table))
1566
    {
1567
      my_thread_id save_pseudo_thread_id= thd->variables.pseudo_thread_id;
1568 1569
      /* Set pseudo_thread_id to be that of the processed table */
      thd->variables.pseudo_thread_id= tmpkeyval(thd, table);
1570 1571 1572 1573
      /*
        Loop forward through all tables within the sublist of
        common pseudo_thread_id to create single DROP query.
      */
1574 1575
      for (s_query.length(stub_len);
           table && is_user_table(table) &&
1576 1577 1578
             tmpkeyval(thd, table) == thd->variables.pseudo_thread_id;
           table= next)
      {
1579 1580 1581 1582 1583
        /*
          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));
1584
        s_query.append('.');
1585 1586
        append_identifier(thd, &s_query, table->s->table_name.str,
                          strlen(table->s->table_name.str));
1587
        s_query.append(',');
1588 1589 1590 1591
        next= table->next;
        close_temporary(table, 1, 1);
      }
      thd->clear_error();
1592 1593 1594 1595 1596 1597
      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;
1598
      /*
1599 1600 1601 1602 1603 1604 1605 1606
        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.
1607 1608 1609
      */
      qinfo.error_code= 0;
      mysql_bin_log.write(&qinfo);
1610
      thd->variables.pseudo_thread_id= save_pseudo_thread_id;
1611
    }
1612
    else
1613 1614 1615
    {
      next= table->next;
      close_temporary(table, 1, 1);
1616
    }
1617
  }
1618
  if (!was_quote_show)
1619
    thd->options&= ~OPTION_QUOTE_SHOW_CREATE; /* restore option */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1620 1621 1622
  thd->temporary_tables=0;
}

1623
/*
1624
  Find table in list.
1625 1626

  SYNOPSIS
1627
    find_table_in_list()
1628
    table		Pointer to table list
1629
    offset		Offset to which list in table structure to use
1630 1631
    db_name		Data base name
    table_name		Table name
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1632

1633 1634 1635
  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
1636 1637 1638 1639 1640 1641

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

1642
TABLE_LIST *find_table_in_list(TABLE_LIST *table,
1643
                               TABLE_LIST *TABLE_LIST::*link,
1644 1645
                               const char *db_name,
                               const char *table_name)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1646
{
1647
  for (; table; table= table->*link )
1648
  {
1649 1650 1651 1652
    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;
1653
  }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1654 1655 1656 1657
  return table;
}


1658
/*
1659
  Test that table is unique (It's only exists once in the table list)
1660 1661 1662

  SYNOPSIS
    unique_table()
1663
    thd                   thread handle
1664
    table                 table which should be checked
1665
    table_list            list of tables
1666
    check_alias           whether to check tables' aliases
1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681

  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

1682 1683 1684 1685
    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.

1686 1687
    TODO: when we will have table/view change detection we can do this check
          only once for PS/SP
1688 1689

  RETURN
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1690 1691
    found duplicate
    0 if table is unique
1692 1693
*/

1694 1695
TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list,
                         bool check_alias)
1696
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1697
  TABLE_LIST *res;
1698
  const char *d_name, *t_name, *t_alias;
serg@serg.mylan's avatar
serg@serg.mylan committed
1699 1700
  DBUG_ENTER("unique_table");
  DBUG_PRINT("enter", ("table alias: %s", table->alias));
1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712

  /*
    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)
1713
  {
1714 1715 1716 1717 1718 1719 1720 1721 1722
    /* 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);
1723
  }
1724 1725
  d_name= table->db;
  t_name= table->table_name;
1726
  t_alias= table->alias;
1727 1728

  DBUG_PRINT("info", ("real table: %s.%s", d_name, t_name));
1729
  for (;;)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1730
  {
1731 1732 1733
    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) &&
1734
         (!check_alias || !(lower_case_table_names ?
evgen@sunlight.local's avatar
evgen@sunlight.local committed
1735 1736
          my_strcasecmp(files_charset_info, t_alias, res->alias) :
          strcmp(t_alias, res->alias))) &&
1737 1738
         res->select_lex && !res->select_lex->exclude_from_table_unique_test &&
         !res->prelocking_placeholder))
1739
      break;
1740
    /*
1741
      If we found entry of this table or table of SELECT which already
1742
      processed in derived table or top select of multi-update/multi-delete
1743
      (exclude_from_table_unique_test) or prelocking placeholder.
1744
    */
1745
    table_list= res->next_global;
1746 1747
    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
1748
  }
1749
  DBUG_RETURN(res);
1750 1751 1752
}


1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787
/*
  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)
    {
1788
      /* Issue the ER_NON_INSERTABLE_TABLE error for an INSERT */
1789
      if (update->view == duplicate->view)
1790 1791 1792
        my_error(!strncmp(operation, "INSERT", 6) ?
                 ER_NON_INSERTABLE_TABLE : ER_NON_UPDATABLE_TABLE, MYF(0),
                 update->alias, operation);
1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809
      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);
}


1810
TABLE *find_temporary_table(THD *thd, const char *db, const char *table_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1811
{
1812
  TABLE_LIST table_list;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1813

1814 1815 1816 1817
  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
  return find_temporary_table(thd, &table_list);
}
1818

1819 1820 1821 1822 1823 1824

TABLE *find_temporary_table(THD *thd, TABLE_LIST *table_list)
{
  char	key[MAX_DBKEY_LENGTH];
  uint	key_length;
  TABLE *table;
1825 1826 1827
  DBUG_ENTER("find_temporary_table");
  DBUG_PRINT("enter", ("table: '%s'.'%s'",
                       table_list->db, table_list->table_name));
1828 1829 1830

  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
1831
  {
1832 1833
    if (table->s->table_cache_key.length == key_length &&
	!memcmp(table->s->table_cache_key.str, key, key_length))
1834 1835 1836 1837 1838
    {
      DBUG_PRINT("info",
                 ("Found table. server_id: %u  pseudo_thread_id: %lu",
                  (uint) thd->server_id,
                  (ulong) thd->variables.pseudo_thread_id));
1839
      DBUG_RETURN(table);
1840
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1841
  }
1842
  DBUG_RETURN(0);                               // Not a temporary table
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1843 1844
}

1845

1846 1847 1848 1849 1850
/**
  Drop a temporary table.

  Try to locate the table in the list of thd->temporary_tables.
  If the table is found:
1851
   - if the table is being used by some outer statement, fail.
1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865
   - 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.

1866 1867 1868 1869
  @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
1870 1871
*/

1872
int drop_temporary_table(THD *thd, TABLE_LIST *table_list)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1873
{
1874
  TABLE *table;
1875
  DBUG_ENTER("drop_temporary_table");
1876 1877
  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
1878

1879
  if (!(table= find_temporary_table(thd, table_list)))
1880 1881 1882 1883 1884 1885 1886 1887 1888
    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);
  }

1889 1890 1891 1892 1893
  /*
    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);
1894
  close_temporary_table(thd, table, 1, 1);
1895
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1896 1897
}

1898
/*
1899
  unlink from thd->temporary tables and close temporary table
1900 1901 1902 1903 1904
*/

void close_temporary_table(THD *thd, TABLE *table,
                           bool free_share, bool delete_table)
{
1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922
  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);

1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941
  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;
  }
1942
  if (thd->slave_thread)
1943 1944 1945
  {
    /* natural invariant of temporary_tables */
    DBUG_ASSERT(slave_open_temp_tables || !thd->temporary_tables);
1946
    slave_open_temp_tables--;
1947
  }
1948
  close_temporary(table, free_share, delete_table);
1949
  DBUG_VOID_RETURN;
1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962
}


/*
  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
1963
  handlerton *table_type= table->s->db_type();
1964
  DBUG_ENTER("close_temporary");
1965 1966
  DBUG_PRINT("tmptable", ("closing table: '%s'.'%s'",
                          table->s->db.str, table->s->table_name.str));
1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980

  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
1981 1982 1983 1984 1985 1986 1987
/*
  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'.
*/
1988

1989
bool rename_temporary_table(THD* thd, TABLE *table, const char *db,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1990 1991 1992
			    const char *table_name)
{
  char *key;
1993
  uint key_length;
1994
  TABLE_SHARE *share= table->s;
1995 1996 1997
  TABLE_LIST table_list;
  DBUG_ENTER("rename_temporary_table");

1998
  if (!(key=(char*) alloc_root(&share->mem_root, MAX_DBKEY_LENGTH)))
1999 2000 2001 2002
    DBUG_RETURN(1);				/* purecov: inspected */

  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
2003 2004
  key_length= create_table_def_key(thd, key, &table_list, 1);
  share->set_table_cache_key(key, key_length);
2005
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2006 2007 2008 2009 2010 2011 2012
}


	/* move table first in unused links */

static void relink_unused(TABLE *table)
{
2013 2014 2015
  /* 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
2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029
  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
2030
/**
2031
  Prepare an open merge table for close.
2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100

  @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
2101
/**
2102 2103
    Remove all instances of table from thread's open list and
    table cache.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2104 2105 2106 2107 2108 2109 2110 2111

    @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
2112
          any tables locked with LOCK TABLES, tables are assumed to be
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2113 2114
          not locked (for example already unlocked).
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2115

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2116
void unlink_open_table(THD *thd, TABLE *find, bool unlock)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2117 2118
{
  char key[MAX_DBKEY_LENGTH];
2119
  uint key_length= find->s->table_cache_key.length;
2120
  TABLE *list, **prev;
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2121 2122 2123
  DBUG_ENTER("unlink_open_table");

  safe_mutex_assert_owner(&LOCK_open);
2124

2125
  memcpy(key, find->s->table_cache_key.str, key_length);
2126 2127 2128 2129 2130 2131 2132 2133
  /*
    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
2134
  {
2135 2136
    list= *prev;

2137 2138
    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
2139
    {
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2140
      if (unlock && thd->locked_tables)
2141 2142 2143 2144 2145 2146 2147 2148 2149
        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. */
2150
      VOID(hash_delete(&open_cache,(uchar*) list)); // Close table
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2151 2152 2153
    }
    else
    {
2154
      /* Step to next entry in open_tables list. */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2155 2156 2157
      prev= &list->next;
    }
  }
2158

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2159
  // Notify any 'refresh' threads
2160
  broadcast_refresh();
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2161 2162 2163 2164 2165
  DBUG_VOID_RETURN;
}


/**
2166
    Auxiliary routine which closes and drops open table.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2167 2168 2169 2170 2171 2172 2173 2174

    @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
2175 2176 2177 2178 2179
          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.
2180 2181
          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
2182 2183 2184 2185 2186 2187 2188 2189 2190
*/

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
2191
    handlerton *table_type= table->s->db_type();
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2192 2193 2194 2195 2196 2197 2198 2199 2200
    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
2201 2202 2203
}


2204
/*
2205 2206 2207 2208 2209 2210 2211 2212
   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
2213 2214
*/

2215
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
2216 2217 2218
{
  /* Wait until the current table is up to date */
  const char *proc_info;
2219 2220
  thd->mysys_var->current_mutex= mutex;
  thd->mysys_var->current_cond= cond;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2221
  proc_info=thd->proc_info;
2222
  thd_proc_info(thd, "Waiting for table");
2223
  DBUG_ENTER("wait_for_condition");
2224
  if (!thd->killed)
2225
    (void) pthread_cond_wait(cond, mutex);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2226

2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238
  /*
    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
2239 2240 2241
  pthread_mutex_lock(&thd->mysys_var->mutex);
  thd->mysys_var->current_mutex= 0;
  thd->mysys_var->current_cond= 0;
2242
  thd_proc_info(thd, proc_info);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2243
  pthread_mutex_unlock(&thd->mysys_var->mutex);
monty@mysql.com's avatar
monty@mysql.com committed
2244
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2245 2246
}

2247

2248 2249 2250 2251 2252
/**
  Exclusively name-lock a table that is already write-locked by the
  current thread.

  @param thd current thread context
2253
  @param tables table list containing one table to open.
2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282

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


2283 2284 2285 2286 2287 2288 2289 2290 2291
/*
  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
2292 2293 2294 2295 2296
      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.
2297 2298 2299 2300 2301 2302 2303 2304 2305

  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
2306
bool reopen_name_locked_table(THD* thd, TABLE_LIST* table_list, bool link_in)
2307
{
2308
  TABLE *table= table_list->table;
2309
  TABLE_SHARE *share;
2310 2311 2312
  char *table_name= table_list->table_name;
  TABLE orig_table;
  DBUG_ENTER("reopen_name_locked_table");
2313

2314 2315 2316 2317 2318 2319
  safe_mutex_assert_owner(&LOCK_open);

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

  orig_table= *table;
2320

2321 2322
  if (open_unireg_entry(thd, table, table_list, table_name,
                        table->s->table_cache_key.str,
2323
                        table->s->table_cache_key.length, thd->mem_root, 0))
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2324
  {
2325 2326 2327 2328 2329 2330 2331 2332 2333
    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
2334
  }
2335

2336
  share= table->s;
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2337 2338 2339 2340 2341 2342 2343 2344
  /*
    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.
  */
2345
  share->version=0;
2346 2347
  table->in_use = thd;
  check_unused();
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362

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

2363 2364 2365
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
2366
  table->null_row= table->maybe_null= table->force_index= 0;
2367
  table->status=STATUS_NO_RECORD;
2368
  DBUG_RETURN(FALSE);
2369 2370
}

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

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2372
/**
2373 2374 2375
    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
2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412

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

2413
  if (my_hash_insert(&open_cache, (uchar*)table))
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2414
  {
jani@linux-th5m.site's avatar
jani@linux-th5m.site committed
2415
    my_free((uchar*) table, MYF(0));
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2416 2417 2418 2419 2420 2421 2422 2423
    DBUG_RETURN(NULL);
  }

  DBUG_RETURN(table);
}


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

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

2455
  if (hash_search(&open_cache, (uchar *)key, key_length))
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475
  {
    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);
}


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

kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
2479 2480 2481
    @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
2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538
                         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);
  }
}


2539 2540 2541 2542 2543
/*
  Open a table.

  SYNOPSIS
    open_table()
2544 2545 2546 2547 2548 2549 2550 2551 2552 2553
    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
2554 2555
                          MYSQL_OPEN_TEMPORARY_ONLY - Open only temporary
                          table not the base table or view.
2556 2557 2558 2559

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

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2560 2561 2562 2563 2564
    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.

2565 2566
  RETURN
    NULL  Open failed.  If refresh is set then one should close
2567
          all other tables and retry the open.
2568 2569
    #     Success. Pointer to TABLE object for open table.
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2570 2571


bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2572
TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
2573
		  bool *refresh, uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2574 2575 2576 2577
{
  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
2578
  char	*alias= table_list->alias;
2579
  HASH_SEARCH_STATE state;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2580 2581
  DBUG_ENTER("open_table");

2582 2583 2584
  /* 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
2585 2586 2587
  /* find a unused table in the open table cache */
  if (refresh)
    *refresh=0;
2588 2589

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2593 2594
  if (thd->killed)
    DBUG_RETURN(0);
2595 2596 2597

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

2599 2600 2601 2602 2603 2604 2605
  /*
    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
2606
  if (!table_list->skip_temporary)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2607
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2608
    for (table= thd->temporary_tables; table ; table=table->next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2609
    {
2610 2611 2612
      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
2613
		  key_length + TMP_TABLE_KEY_EXTRA))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2614
      {
2615 2616 2617 2618 2619 2620
        /*
          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.
        */
2621
	if (table->query_id)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2622
	{
2623 2624 2625 2626
          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));
2627
	  my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2628 2629 2630
	  DBUG_RETURN(0);
	}
	table->query_id= thd->query_id;
2631
	thd->thread_specific_used= TRUE;
monty@mysql.com's avatar
monty@mysql.com committed
2632 2633
        DBUG_PRINT("info",("Using temporary table"));
        goto reset;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2634 2635 2636 2637
      }
    }
  }

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2638 2639 2640 2641 2642 2643
  if (flags & MYSQL_OPEN_TEMPORARY_ONLY)
  {
    my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->db, table_list->table_name);
    DBUG_RETURN(0);
  }

2644 2645 2646 2647 2648 2649 2650
  /*
    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
2651
  if (thd->locked_tables || thd->prelocked_mode)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2652
  {						// Using table locks
2653
    TABLE *best_table= 0;
2654
    int best_distance= INT_MIN;
2655 2656 2657
    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
2658 2659
    for (table=thd->open_tables; table ; table=table->next)
    {
2660 2661
      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
2662
      {
2663 2664
        if (check_if_used && table->query_id &&
            table->query_id != thd->query_id)
2665
        {
2666 2667 2668 2669 2670 2671 2672
          /*
            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),
2673
                   table->s->table_name.str);
2674 2675
          DBUG_RETURN(0);
        }
2676 2677 2678 2679
        /*
          When looking for a usable TABLE, ignore MERGE children, as they
          belong to their parent and cannot be used explicitly.
        */
2680 2681
        if (!my_strcasecmp(system_charset_info, table->alias, alias) &&
            table->query_id != thd->query_id && /* skip tables already used */
2682 2683
            !(thd->prelocked_mode && table->query_id) &&
            !table->parent)
2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714
        {
          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;
            }
          }
2715
        }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2716
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2717
    }
2718 2719 2720 2721 2722 2723 2724
    if (best_table)
    {
      table= best_table;
      table->query_id= thd->query_id;
      DBUG_PRINT("info",("Using locked table"));
      goto reset;
    }
2725
    /*
2726
      Is this table a view and not a base table?
2727 2728 2729 2730 2731
      (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];
2732
      enum legacy_db_type not_used;
2733
      build_table_filename(path, sizeof(path) - 1,
2734
                           table_list->db, table_list->table_name, reg_ext, 0);
2735
      if (mysql_frm_type(thd, path, &not_used) == FRMTYPE_VIEW)
2736
      {
2737 2738 2739 2740 2741
        /*
          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;
2742
        table= &tab;
2743
        VOID(pthread_mutex_lock(&LOCK_open));
2744
        if (!open_unireg_entry(thd, table, table_list, alias,
2745
                              key, key_length, mem_root, 0))
2746
        {
2747
          DBUG_ASSERT(table_list->view != 0);
2748 2749 2750 2751 2752 2753
          VOID(pthread_mutex_unlock(&LOCK_open));
          DBUG_RETURN(0); // VIEW
        }
        VOID(pthread_mutex_unlock(&LOCK_open));
      }
    }
2754 2755 2756 2757 2758 2759 2760 2761
    /*
      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)
2762
      my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->db, table_list->alias);
2763 2764
    else
      my_error(ER_TABLE_NOT_LOCKED, MYF(0), alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2765 2766
    DBUG_RETURN(0);
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2767

2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783
  /*
    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
2784 2785
  VOID(pthread_mutex_lock(&LOCK_open));

2786 2787 2788 2789 2790 2791 2792 2793
  /*
    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
2794 2795
  if (!thd->open_tables)
    thd->version=refresh_version;
2796
  else if ((thd->version != refresh_version) &&
2797
           ! (flags & MYSQL_LOCK_IGNORE_FLUSH))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2798 2799
  {
    /* Someone did a refresh while thread was opening tables */
2800 2801
    if (refresh)
      *refresh=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2802 2803 2804 2805
    VOID(pthread_mutex_unlock(&LOCK_open));
    DBUG_RETURN(0);
  }

2806 2807 2808 2809 2810 2811 2812
  /*
    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
2813
  if (thd->handler_tables)
2814
    mysql_ha_flush(thd);
2815

2816 2817 2818 2819 2820 2821 2822 2823 2824 2825
  /*
    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.
  */
2826
  for (table= (TABLE*) hash_first(&open_cache, (uchar*) key, key_length,
2827
                                  &state);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2828
       table && table->in_use ;
2829
       table= (TABLE*) hash_next(&open_cache, (uchar*) key, key_length,
2830
                                 &state))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2831
  {
2832 2833
    DBUG_PRINT("tcache", ("in_use table: '%s'.'%s' 0x%lx", table->s->db.str,
                          table->s->table_name.str, (long) table));
2834
    /*
2835
      Here we flush tables marked for flush.
2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850
      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
2851
    */
2852
    if (table->needs_reopen_or_name_lock())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2853
    {
monty@mysql.com's avatar
monty@mysql.com committed
2854 2855 2856
      DBUG_PRINT("note",
                 ("Found table '%s.%s' with different refresh version",
                  table_list->db, table_list->table_name));
2857

2858
      if (flags & MYSQL_LOCK_IGNORE_FLUSH)
2859 2860 2861 2862 2863 2864
      {
        /* Force close at once after usage */
        thd->version= table->s->version;
        continue;
      }

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2865 2866 2867 2868 2869 2870 2871 2872
      /* 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
2873
      /*
2874 2875 2876 2877 2878 2879 2880
        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.
2881 2882 2883 2884

        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
2885
      */
2886
      close_old_data_files(thd,thd->open_tables,0,0);
2887 2888 2889 2890 2891 2892
      /*
        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
2893 2894 2895 2896 2897 2898 2899 2900
        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.
2901
      */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2902
      if (table->in_use != thd)
2903
      {
2904
        /* wait_for_conditionwill unlock LOCK_open for us */
2905
        wait_for_condition(thd, &LOCK_open, &COND_refresh);
2906
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2907
      else
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2908
      {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2909
	VOID(pthread_mutex_unlock(&LOCK_open));
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2910
      }
2911 2912 2913 2914
      /*
        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
2915 2916 2917 2918 2919 2920 2921
      if (refresh)
	*refresh=1;
      DBUG_RETURN(0);
    }
  }
  if (table)
  {
2922 2923
    DBUG_PRINT("tcache", ("unused table: '%s'.'%s' 0x%lx", table->s->db.str,
                          table->s->table_name.str, (long) table));
2924
    /* Unlink the table from "unused_tables" list. */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2925 2926 2927 2928 2929 2930 2931 2932
    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;
2933
    table->in_use= thd;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2934 2935 2936
  }
  else
  {
2937
    /* Insert a new TABLE instance into the open cache */
2938
    int error;
2939
    DBUG_PRINT("tcache", ("opening new table"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2940
    /* Free cache if too big */
2941
    while (open_cache.records > table_cache_size && unused_tables)
2942
      VOID(hash_delete(&open_cache,(uchar*) unused_tables)); /* purecov: tested */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2943

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976
    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
2977 2978 2979

    /* make a new table */
    if (!(table=(TABLE*) my_malloc(sizeof(*table),MYF(MY_WME))))
2980 2981
    {
      VOID(pthread_mutex_unlock(&LOCK_open));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2982
      DBUG_RETURN(NULL);
2983
    }
2984

2985 2986 2987
    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
2988
    {
2989
      my_free((uchar*)table, MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2990 2991 2992
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(NULL);
    }
2993
    if (table_list->view || error < 0)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2994
    {
2995 2996 2997 2998 2999 3000 3001
      /*
        VIEW not really opened, only frm were read.
        Set 1 as a flag here
      */
      if (error < 0)
        table_list->view= (st_lex*)1;

3002
      my_free((uchar*)table, MYF(0));
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3003 3004 3005
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(0); // VIEW
    }
3006 3007 3008
    DBUG_PRINT("info", ("inserting table '%s'.'%s' 0x%lx into the cache",
                        table->s->db.str, table->s->table_name.str,
                        (long) table));
3009
    VOID(my_hash_insert(&open_cache,(uchar*) table));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3010 3011
  }

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3014 3015 3016 3017 3018 3019 3020 3021 3022
  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:
3023 3024
  DBUG_ASSERT(table->s->ref_count > 0 || table->s->tmp_table != NO_TMP_TABLE);

3025 3026
  if (thd->lex->need_correct_ident())
    table->alias_name_used= my_strcasecmp(table_alias_charset,
3027
                                          table->s->table_name.str, alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3028
  /* Fix alias if table name changes */
3029
  if (strcmp(table->alias, alias))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3030
  {
3031
    uint length=(uint) strlen(alias)+1;
3032 3033 3034
    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
3035 3036 3037 3038 3039
  }
  /* These variables are also set in reopen_table() */
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
3040
  table->null_row= table->maybe_null= table->force_index= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3041
  table->status=STATUS_NO_RECORD;
3042
  table->insert_values= 0;
3043 3044
  table->fulltext_searched= 0;
  table->file->ft_handler= 0;
3045 3046 3047
  /* 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
3048
  if (table->timestamp_field)
3049
    table->timestamp_field_type= table->timestamp_field->get_auto_set_type();
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3050
  table->pos_in_table_list= table_list;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3051
  table_list->updatable= 1; // It is not derived table nor non-updatable VIEW
3052
  table->clear_column_bitmaps();
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
3053
  DBUG_ASSERT(table->key_read == 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064
  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)
  {
3065 3066
    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
3067 3068 3069 3070 3071 3072
      return table;
  }
  return(0);
}


3073 3074
/*
  Reopen an table because the definition has changed.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3075

3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088
  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.
*/

3089
bool reopen_table(TABLE *table)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3090 3091
{
  TABLE tmp;
3092
  bool error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3093 3094
  Field **field;
  uint key,part;
3095 3096
  TABLE_LIST table_list;
  THD *thd= table->in_use;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3097
  DBUG_ENTER("reopen_table");
3098 3099
  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
3100

3101 3102
  DBUG_ASSERT(table->s->ref_count == 0);
  DBUG_ASSERT(!table->sort.io_cache);
3103
  DBUG_ASSERT(!table->children_attached);
3104

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3105 3106 3107
#ifdef EXTRA_DEBUG
  if (table->db_stat)
    sql_print_error("Table %s had a open data handler in reopen_table",
3108
		    table->alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3109
#endif
3110
  bzero((char*) &table_list, sizeof(TABLE_LIST));
3111 3112 3113
  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
3114

3115 3116 3117 3118 3119 3120 3121
  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,
3122
                        thd->mem_root, 0))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3123 3124
    goto end;

3125
  /* This list copies variables set by open_table */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3126 3127 3128 3129
  tmp.tablenr=		table->tablenr;
  tmp.used_fields=	table->used_fields;
  tmp.const_table=	table->const_table;
  tmp.null_row=		table->null_row;
3130
  tmp.maybe_null=	table->maybe_null;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3131
  tmp.status=		table->status;
3132

3133 3134
  tmp.s->table_map_id=  table->s->table_map_id;

3135
  /* Get state */
3136
  tmp.in_use=    	thd;
3137
  tmp.reginfo.lock_type=table->reginfo.lock_type;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3138 3139
  tmp.grant=		table->grant;

3140
  /* Replace table in open list */
3141 3142
  tmp.next=		table->next;
  tmp.prev=		table->prev;
3143

3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154
  /* 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;
  }

3155
  delete table->triggers;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3156
  if (table->file)
3157
    VOID(closefrm(table, 1));		// close file, free everything
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3158

3159
  *table= tmp;
3160
  table->default_column_bitmaps();
3161
  table->file->change_table_ptr(table, table->s);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3162

3163
  DBUG_ASSERT(table->alias != 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3164 3165
  for (field=table->field ; *field ; field++)
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3166
    (*field)->table= (*field)->orig_table= table;
3167
    (*field)->table_name= &table->alias;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3168
  }
3169
  for (key=0 ; key < table->s->keys ; key++)
3170
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3171
    for (part=0 ; part < table->key_info[key].usable_key_parts ; part++)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3172
      table->key_info[key].key_part[part].field->table= table;
3173
  }
3174 3175
  if (table->triggers)
    table->triggers->set_table(table);
3176 3177 3178 3179 3180
  /*
    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().
  */
3181

3182
  broadcast_refresh();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3183 3184 3185 3186 3187 3188 3189
  error=0;

 end:
  DBUG_RETURN(error);
}


3190
/**
3191 3192
    Close all instances of a table open by this thread and replace
    them with exclusive name-locks.
3193 3194 3195 3196 3197 3198 3199 3200 3201

    @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.
3202 3203 3204

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

3207 3208
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
3209 3210
{
  TABLE *table;
3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223
  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;
  }
3224

3225 3226 3227 3228 3229
  /*
    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
3230 3231
  for (table=thd->open_tables; table ; table=table->next)
  {
3232 3233
    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
3234
    {
3235
      if (thd->locked_tables)
3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251
      {
        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);
      }
3252
      table->open_placeholder= 1;
3253
      close_handle_and_leave_table_as_lock(table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3254 3255
    }
  }
3256
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3257 3258 3259
}


dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3260
/**
3261
  Reattach MERGE children after reopen.
3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315

  @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
3316
/**
3317
    Reopen all tables with closed data files.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3318 3319 3320

    @param thd         Thread context
    @param get_locks   Should we get locks after reopening tables ?
3321 3322
    @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
3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333

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

3336
bool reopen_tables(THD *thd, bool get_locks, bool mark_share_as_old)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3337
{
3338 3339
  TABLE *table,*next,**prev;
  TABLE **tables,**tables_ptr;			// For locks
3340
  TABLE *err_tables= NULL;
3341
  bool error=0, not_used;
3342
  bool merge_table_found= FALSE;
3343 3344 3345 3346
  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
3347
  DBUG_ENTER("reopen_tables");
3348

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3349 3350 3351
  if (!thd->open_tables)
    DBUG_RETURN(0);

3352
  safe_mutex_assert_owner(&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3353 3354
  if (get_locks)
  {
3355 3356 3357 3358
    /*
      The ptr is checked later
      Do not handle locks of MERGE children.
    */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3359
    uint opens=0;
3360
    for (table= thd->open_tables; table ; table=table->next)
3361 3362 3363
      if (!table->parent)
        opens++;
    DBUG_PRINT("tcache", ("open tables to lock: %u", opens));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374
    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;
3375 3376 3377 3378 3379 3380
    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;
3381
    if (!tables || (!db_stat && reopen_table(table)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3382
    {
3383
      my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394
      /*
        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);
3395
      VOID(hash_delete(&open_cache,(uchar*) table));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3396 3397 3398 3399
      error=1;
    }
    else
    {
3400 3401
      DBUG_PRINT("tcache", ("opened. need lock: %d",
                            get_locks && !db_stat && !table->parent));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3402 3403
      *prev= table;
      prev= &table->next;
3404 3405
      /* 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
3406
	*tables_ptr++= table;			// need new lock on this
3407
      if (mark_share_as_old)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3408
      {
3409
	table->s->version=0;
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3410
	table->open_placeholder= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3411 3412 3413
      }
    }
  }
3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429
  *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
3430 3431 3432
  if (tables != tables_ptr)			// Should we get back old locks
  {
    MYSQL_LOCK *lock;
3433 3434 3435 3436 3437
    /*
      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
3438
    thd->some_tables_deleted=0;
3439
    if ((lock= mysql_lock_tables(thd, tables, (uint) (tables_ptr - tables),
3440
                                 flags, &not_used)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3441 3442 3443 3444
    {
      thd->locked_tables=mysql_lock_merge(thd->locked_tables,lock);
    }
    else
3445 3446 3447 3448 3449 3450 3451
    {
      /*
        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
3452
      error=1;
3453
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3454 3455 3456
  }
  if (get_locks && tables)
  {
3457
    my_afree((uchar*) tables);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3458
  }
3459
  broadcast_refresh();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3460 3461 3462
  DBUG_RETURN(error);
}

3463

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3464
/**
3465 3466
    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
3467 3468 3469 3470 3471 3472 3473 3474 3475

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

3478 3479
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
3480
{
3481
  bool found= send_refresh;
3482
  DBUG_ENTER("close_old_data_files");
3483

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3484 3485
  for (; table ; table=table->next)
  {
3486 3487 3488 3489 3490
    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));
3491
    /*
3492
      Reopen marked for flush.
3493
    */
3494
    if (table->needs_reopen_or_name_lock())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3495 3496 3497 3498
    {
      found=1;
      if (table->db_stat)
      {
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3499
	if (morph_locks)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3500
	{
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3501
          /*
3502 3503
            Forward lock handling to MERGE parent. But unlock parent
            once only.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3504
          */
3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528
          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
3529 3530 3531 3532 3533
          /*
            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
3534
	}
3535
        close_handle_and_leave_table_as_lock(table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3536
      }
3537
      else if (table->open_placeholder && !morph_locks)
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3538 3539 3540 3541 3542 3543 3544
      {
        /*
          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.
3545 3546 3547 3548

          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
3549 3550 3551
        */
        table->open_placeholder= 0;
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3552 3553 3554
    }
  }
  if (found)
3555
    broadcast_refresh();
3556
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3557 3558 3559 3560 3561 3562 3563 3564 3565
}


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

3566
bool table_is_used(TABLE *table, bool wait_for_name_lock)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3567
{
3568
  DBUG_ENTER("table_is_used");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3569 3570
  do
  {
3571 3572 3573 3574
    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
3575
    HASH_SEARCH_STATE state;
3576
    for (TABLE *search= (TABLE*) hash_first(&open_cache, (uchar*) key,
3577
                                             key_length, &state);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3578
	 search ;
3579
         search= (TABLE*) hash_next(&open_cache, (uchar*) key,
3580
                                    key_length, &state))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3581
    {
3582
      DBUG_PRINT("info", ("share: 0x%lx  "
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3583
                          "open_placeholder: %d  locked_by_name: %d "
3584
                          "db_stat: %u  version: %lu",
3585
                          (ulong) search->s,
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3586
                          search->open_placeholder, search->locked_by_name,
3587 3588 3589 3590 3591 3592 3593 3594 3595
                          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
3596
        (We must wait until all engines are shut down to use the table)
3597
      */
3598 3599
      if ( (search->locked_by_name && wait_for_name_lock) ||
           (search->is_name_opened() && search->needs_reopen_or_name_lock()))
3600
        DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3601 3602
    }
  } while ((table=table->next));
3603
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3604 3605 3606 3607 3608 3609 3610 3611 3612 3613
}


/* Wait until all used tables are refreshed */

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

3614
  thd_proc_info(thd, "Waiting for tables");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3615
  pthread_mutex_lock(&LOCK_open);
3616
  while (!thd->killed)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3617
  {
3618 3619
    thd->some_tables_deleted=0;
    close_old_data_files(thd,thd->open_tables,0,dropping_tables != 0);
3620
    mysql_ha_flush(thd);
3621 3622
    if (!table_is_used(thd->open_tables,1))
      break;
3623
    (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3624 3625 3626 3627 3628 3629
  }
  if (thd->killed)
    result= 1;					// aborted
  else
  {
    /* Now we can open all tables without any interference */
3630
    thd_proc_info(thd, "Reopen tables");
antony@ltantony.mysql.com's avatar
antony@ltantony.mysql.com committed
3631
    thd->version= refresh_version;
3632
    result=reopen_tables(thd,0,0);
3633
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3634
  pthread_mutex_unlock(&LOCK_open);
3635
  thd_proc_info(thd, 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3636 3637 3638 3639
  DBUG_RETURN(result);
}


3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656
/*
  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
3657

3658 3659 3660 3661 3662
  RETURN
    #    If table existed, return table
    0	 Table was not locked
*/

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

3664
TABLE *drop_locked_tables(THD *thd,const char *db, const char *table_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3665
{
3666
  TABLE *table,*next,**prev, *found= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3667
  prev= &thd->open_tables;
3668 3669
  DBUG_ENTER("drop_locked_tables");

3670 3671 3672 3673 3674 3675 3676
  /*
    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.
  */
3677
  for (table= thd->open_tables; table ; table=next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3678 3679
  {
    next=table->next;
3680 3681
    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
3682
    {
3683 3684 3685 3686 3687 3688 3689 3690 3691 3692
      /* 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);

3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705
      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 */
3706
        VOID(hash_delete(&open_cache,(uchar*) table));
3707
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3708 3709 3710 3711 3712 3713 3714 3715 3716
    }
    else
    {
      *prev=table;
      prev= &table->next;
    }
  }
  *prev=0;
  if (found)
3717
    broadcast_refresh();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3718 3719
  if (thd->locked_tables && thd->locked_tables->table_count == 0)
  {
3720
    my_free((uchar*) thd->locked_tables,MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3721 3722
    thd->locked_tables=0;
  }
3723
  DBUG_RETURN(found);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3724 3725 3726
}


3727 3728 3729 3730 3731
/*
  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
3732 3733 3734 3735

void abort_locked_tables(THD *thd,const char *db, const char *table_name)
{
  TABLE *table;
3736
  for (table= thd->open_tables; table ; table= table->next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3737
  {
3738 3739
    if (!strcmp(table->s->table_name.str, table_name) &&
	!strcmp(table->s->db.str, db))
3740
    {
3741 3742
      /* If MERGE child, forward lock handling to parent. */
      mysql_lock_abort(thd, table->parent ? table->parent : table, TRUE);
3743 3744
      break;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3745 3746 3747
  }
}

3748

3749
/*
3750
  Function to assign a new table map id to a table share.
3751 3752 3753

  PARAMETERS

3754
    share - Pointer to table share structure
3755

mats@mysql.com's avatar
mats@mysql.com committed
3756 3757 3758 3759 3760 3761 3762
  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).

3763 3764
  PRE-CONDITION(S)

3765
    share is non-NULL
3766 3767 3768 3769
    The LOCK_open mutex is locked

  POST-CONDITION(S)

3770 3771 3772
    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
3773 3774
    share opens have been executed while one table was open all the
    time).
3775

3776
    share->table_map_id is not ~0UL.
3777
 */
3778
void assign_new_table_id(TABLE_SHARE *share)
3779
{
3780
  static ulong last_table_id= ~0UL;
3781

3782
  DBUG_ENTER("assign_new_table_id");
3783 3784

  /* Preconditions */
3785
  DBUG_ASSERT(share != NULL);
3786 3787 3788
  safe_mutex_assert_owner(&LOCK_open);

  ulong tid= ++last_table_id;                   /* get next id */
3789 3790 3791 3792
  /*
    There is one reserved number that cannot be used.  Remember to
    change this when 6-byte global table id's are introduced.
  */
3793
  if (unlikely(tid == ~0UL))
3794
    tid= ++last_table_id;
3795
  share->table_map_id= tid;
3796 3797 3798
  DBUG_PRINT("info", ("table_id=%lu", tid));

  /* Post conditions */
3799
  DBUG_ASSERT(share->table_map_id != ~0UL);
3800 3801 3802 3803

  DBUG_VOID_RETURN;
}

3804 3805 3806 3807 3808 3809 3810
/*
  Load a table definition from file and open unireg table

  SYNOPSIS
    open_unireg_entry()
    thd			Thread handle
    entry		Store open table definition here
3811
    table_list		TABLE_LIST with db, table_name & belong_to_view
3812
    alias		Alias name
3813 3814
    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
3815
    mem_root		temporary mem_root for parsing
3816 3817
    flags               the OPEN_VIEW_NO_PARSE flag to be passed to
                        openfrm()/open_new_frm()
3818 3819 3820

  NOTES
   Extra argument for open is taken from thd->open_options
3821
   One must have a lock on LOCK_open when calling this function
3822 3823 3824 3825

  RETURN
    0	ok
    #	Error
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3826
*/
3827 3828 3829

static int open_unireg_entry(THD *thd, TABLE *entry, TABLE_LIST *table_list,
                             const char *alias,
3830
                             char *cache_key, uint cache_key_length,
3831
                             MEM_ROOT *mem_root, uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3832
{
3833
  int error;
3834
  TABLE_SHARE *share;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3835
  uint discover_retry_count= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3836 3837
  DBUG_ENTER("open_unireg_entry");

3838 3839 3840 3841
  safe_mutex_assert_owner(&LOCK_open);
retry:
  if (!(share= get_table_share_with_create(thd, table_list, cache_key,
                                           cache_key_length, 
3842 3843 3844
                                           OPEN_VIEW |
                                           table_list->i_s_requested_object,
                                           &error)))
3845 3846 3847 3848
    DBUG_RETURN(1);

  if (share->is_view)
  {
3849 3850 3851
    if (table_list->i_s_requested_object &  OPEN_TABLE_ONLY)
      goto err;

3852 3853 3854 3855
    /* Open view */
    error= (int) open_new_frm(thd, share, alias,
                              (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
                                      HA_GET_INDEX | HA_TRY_READ_ONLY),
3856 3857
                              READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD |
                              (flags & OPEN_VIEW_NO_PARSE),
3858
                              thd->open_options, entry, table_list,
3859
                              mem_root);
3860 3861 3862 3863
    if (error)
      goto err;
    /* TODO: Don't free this */
    release_table_share(share, RELEASE_NORMAL);
3864
    DBUG_RETURN((flags & OPEN_VIEW_NO_PARSE)? -1 : 0);
3865
  }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3866

3867 3868 3869
  if (table_list->i_s_requested_object &  OPEN_VIEW_ONLY)
    goto err;

3870 3871 3872 3873 3874 3875 3876
  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),
3877
                                       thd->open_options, entry, FALSE)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3878
  {
3879
    if (error == 7)                             // Table def changed
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3880
    {
3881 3882 3883 3884
      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
3885
      /*
3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896
        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
3897
      */
3898 3899
      if (ha_create_table_from_engine(thd, table_list->db,
                                      table_list->table_name))
monty@mysql.com's avatar
monty@mysql.com committed
3900
        goto err;
3901 3902 3903 3904 3905 3906
      /*
        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
3907
        goto err;
3908 3909 3910
      /* Free share and wait until it's released by all threads */
      release_table_share(share, RELEASE_WAIT_FOR_DROP);
      if (!thd->killed)
3911
      {
3912 3913 3914
        mysql_reset_errors(thd, 1);         // Clear warnings
        thd->clear_error();                 // Clear error message
        goto retry;
3915
      }
3916
      DBUG_RETURN(1);
3917
    }
3918
    if (!entry->s || !entry->s->crashed)
3919
      goto err;
3920
     // Code below is for repairing a crashed file
3921
     if ((error= lock_table_name(thd, table_list, TRUE)))
3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939
     {
       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,
3940
                               entry, FALSE) || ! entry->file ||
3941
        (entry->file->is_crashed() && entry->file->ha_check_and_repair(thd)))
3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960
     {
       /* 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;
   }
3961

3962 3963 3964 3965
  if (Table_triggers_list::check_n_load(thd, share->db.str,
                                        share->table_name.str, entry, 0))
  {
    closefrm(entry, 0);
3966
    goto err;
3967
  }
3968

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3969 3970 3971 3972 3973 3974 3975 3976 3977 3978
  /*
    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;
3979 3980
      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
3981
      {
3982
        /* this DELETE FROM is needed even with row-based binlogging */
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3983
        end = strxmov(strmov(query, "DELETE FROM `"),
3984
                      share->db.str,"`.`",share->table_name.str,"`", NullS);
3985 3986
        thd->binlog_query(THD::STMT_QUERY_TYPE,
                          query, (ulong)(end-query), FALSE, FALSE);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3987 3988 3989 3990 3991 3992 3993 3994 3995
        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).
        */
3996 3997 3998
        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);
3999
        delete entry->triggers;
4000
        closefrm(entry, 0);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4001 4002 4003
        goto err;
      }
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4004 4005
  }
  DBUG_RETURN(0);
4006

4007
err:
4008
  release_table_share(share, RELEASE_NORMAL);
4009
  DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4010 4011
}

4012

4013 4014 4015 4016 4017 4018 4019 4020 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
/**
  @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
4347 4348 4349 4350 4351 4352
/*
  Open all tables in list

  SYNOPSIS
    open_tables()
    thd - thread handler
4353
    start - list of tables in/out
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4354
    counter - number of opened tables will be return using this parameter
4355 4356 4357
    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
4358

4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369
  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.

4370 4371 4372 4373 4374
    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
4375 4376 4377 4378 4379
  RETURN
    0  - OK
    -1 - error
*/

4380
int open_tables(THD *thd, TABLE_LIST **start, uint *counter, uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4381
{
4382
  TABLE_LIST *tables= NULL;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4383 4384
  bool refresh;
  int result=0;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4385
  MEM_ROOT new_frm_mem;
4386 4387
  /* Also used for indicating that prelocking is need */
  TABLE_LIST **query_tables_last_own;
4388 4389
  bool safe_to_ignore_table;

4390
  DBUG_ENTER("open_tables");
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4391 4392 4393 4394
  /*
    temporary mem_root for new .frm parsing.
    TODO: variables for size
  */
4395
  init_sql_alloc(&new_frm_mem, 8024, 8024);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4396

4397
  thd->current_tablenr= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4398
 restart:
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4399
  *counter= 0;
4400
  query_tables_last_own= 0;
4401
  thd_proc_info(thd, "Opening tables");
4402 4403 4404 4405 4406 4407 4408

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

  */
4409 4410

  if (!thd->prelocked_mode && !thd->lex->requires_prelocking() &&
4411
      thd->lex->uses_stored_routines())
4412
  {
4413
    bool first_no_prelocking, need_prelocking;
4414
    TABLE_LIST **save_query_tables_last= thd->lex->query_tables_last;
4415 4416

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

4419
    if (sp_cache_routines_and_add_tables(thd, thd->lex, first_no_prelocking))
4420
    {
4421 4422 4423 4424 4425 4426
      /*
        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;
4427 4428
      goto err;
    }
4429
    else if (need_prelocking)
4430 4431 4432 4433 4434 4435
    {
      query_tables_last_own= save_query_tables_last;
      *start= thd->lex->query_tables;
    }
  }

4436 4437 4438 4439
  /*
    For every table in the list of tables to open, try to find or open
    a table.
  */
4440
  for (tables= *start; tables ;tables= tables->next_global)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4441
  {
4442 4443 4444
    DBUG_PRINT("tcache", ("opening table: '%s'.'%s'  item: 0x%lx",
                          tables->db, tables->table_name, (long) tables));

4445
    safe_to_ignore_table= FALSE;
4446

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4447 4448 4449
    /*
      Ignore placeholders for derived tables. After derived tables
      processing, link to created temporary table will be put here.
4450 4451
      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
4452 4453
     */
    if (tables->derived)
4454 4455 4456
    {
      if (tables->view)
        goto process_view_routines;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4457
      continue;
4458
    }
4459 4460 4461 4462 4463 4464
    /*
      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.
    */
4465 4466 4467 4468 4469 4470
    if (tables->schema_table)
    {
      if (!mysql_schema_table(thd, thd->lex, tables))
        continue;
      DBUG_RETURN(-1);
    }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4471
    (*counter)++;
4472 4473 4474 4475 4476

    /*
      Not a placeholder: must be a base table or a view, and the table is
      not opened yet. Try to open the table.
    */
4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495
    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);
    }
4496 4497 4498 4499
    else
      DBUG_PRINT("tcache", ("referenced table: '%s'.'%s' 0x%lx",
                            tables->db, tables->table_name,
                            (long) tables->table));
4500 4501

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

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4505 4506
      if (tables->view)
      {
4507
        /* VIEW placeholder */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4508
	(*counter)--;
4509

4510
        /*
4511 4512 4513 4514 4515
          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
4516 4517 4518
          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.
4519
        */
4520
        if (query_tables_last_own == &(tables->next_global) &&
4521 4522
            tables->view->query_tables)
          query_tables_last_own= tables->view->query_tables_last;
4523
        /*
4524 4525
          Let us free memory used by 'sroutines' hash here since we never
          call destructor for this LEX.
4526
        */
4527
        hash_free(&tables->view->sroutines);
4528
	goto process_view_routines;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4529 4530
      }

4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543
      /*
        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
4544 4545
      if (refresh)				// Refresh in progress
      {
4546
        /*
4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558
          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.
4559 4560 4561
        */
        if (query_tables_last_own)
          thd->lex->mark_as_requiring_prelocking(query_tables_last_own);
4562
        close_tables_for_reopen(thd, start);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4563 4564
	goto restart;
      }
4565 4566 4567 4568 4569 4570 4571 4572

      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
4573 4574 4575
      result= -1;				// Fatal error
      break;
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4576
    else
4577 4578 4579 4580 4581 4582 4583 4584 4585 4586
    {
      /*
        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() &&
4587
          tables->trg_event_map && tables->table->triggers &&
4588 4589 4590
          tables->lock_type >= TL_WRITE_ALLOW_WRITE)
      {
        if (!query_tables_last_own)
4591 4592
          query_tables_last_own= thd->lex->query_tables_last;
        if (sp_cache_routines_and_add_tables_for_triggers(thd, thd->lex,
4593
                                                          tables))
4594
        {
4595 4596 4597 4598 4599 4600
          /*
            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;
4601 4602
          goto err;
        }
4603
      }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4604
      free_root(&new_frm_mem, MYF(MY_KEEP_PREALLOC));
4605
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4606

4607
    if (tables->lock_type != TL_UNLOCK && ! thd->locked_tables)
4608 4609 4610 4611 4612 4613
    {
      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
4614
    tables->table->grant= tables->grant;
4615

4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633
    /* 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;
    }

4634 4635 4636 4637 4638 4639 4640
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() &&
4641
        tables->view->uses_stored_routines())
4642 4643 4644 4645
    {
      /* We have at least one table in TL here. */
      if (!query_tables_last_own)
        query_tables_last_own= thd->lex->query_tables_last;
4646
      if (sp_cache_routines_and_add_tables_for_view(thd, thd->lex, tables))
4647
      {
4648 4649
        /*
          Serious error during reading stored routines from mysql.proc table.
4650
          Something is wrong with the table or its contents, and an error has
4651 4652 4653
          been emitted; we must abort.
        */
        result= -1;
4654 4655
        goto err;
      }
4656
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4657
  }
4658 4659

 err:
4660
  thd_proc_info(thd, 0);
4661
  free_root(&new_frm_mem, MYF(0));              // Free pre-alloced block
4662 4663 4664 4665

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

4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677
  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)
      tables->parent_l->table= NULL;
    tables->table= NULL;
  }
  DBUG_PRINT("tcache", ("returning: %d", result));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4678 4679 4680 4681
  DBUG_RETURN(result);
}


4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704
/*
  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)
  {
4705
    my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),table->alias);
4706 4707
    DBUG_RETURN(1);
  }
serg@serg.mylan's avatar
serg@serg.mylan committed
4708
  if ((error=table->file->start_stmt(thd, lock_type)))
4709 4710 4711 4712 4713 4714 4715 4716
  {
    table->file->print_error(error,MYF(0));
    DBUG_RETURN(1);
  }
  DBUG_RETURN(0);
}


4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773
/**
  @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);
}


4774 4775 4776 4777 4778 4779 4780 4781
/*
  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
4782
    lock_flags          Flags passed to mysql_lock_table
4783

4784 4785 4786 4787 4788
  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.

4789 4790 4791 4792 4793 4794 4795 4796 4797
  RETURN VALUES
    table		Opened table
    0			Error
  
    If ok, the following are also set:
      table_list->lock_type 	lock_type
      table_list->table		table
*/

4798 4799
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
4800 4801 4802 4803 4804
{
  TABLE *table;
  bool refresh;
  DBUG_ENTER("open_ltable");

4805
  thd_proc_info(thd, "Opening table");
4806
  thd->current_tablenr= 0;
4807 4808
  /* open_ltable can be used only for BASIC TABLEs */
  table_list->required_type= FRMTYPE_TABLE;
4809
  while (!(table= open_table(thd, table_list, thd->mem_root, &refresh, 0)) &&
4810
         refresh)
4811
    ;
4812

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4813 4814
  if (table)
  {
4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825
    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 */
    }

4826 4827
    table_list->lock_type= lock_type;
    table_list->table=	   table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4828 4829 4830
    table->grant= table_list->grant;
    if (thd->locked_tables)
    {
4831 4832 4833 4834 4835
      if (check_lock_and_start_stmt(thd, table, lock_type))
	table= 0;
    }
    else
    {
4836
      DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
4837
      if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)
4838 4839
	if (! (thd->lock= mysql_lock_tables(thd, &table_list->table, 1,
                                            lock_flags, &refresh)))
4840
	  table= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4841 4842
    }
  }
4843 4844

 end:
4845
  thd_proc_info(thd, 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4846 4847 4848
  DBUG_RETURN(table);
}

4849

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4850
/*
4851
  Open all tables in list, locks them and optionally process derived tables.
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4852 4853

  SYNOPSIS
4854
    open_and_lock_tables_derived()
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4855 4856
    thd		- thread handler
    tables	- list of tables for open&locking
4857
    derived     - if to handle derived tables
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4858 4859

  RETURN
4860 4861
    FALSE - ok
    TRUE  - error
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4862 4863

  NOTE
4864
    The lock will automaticaly be freed by close_thread_tables()
4865 4866 4867 4868 4869 4870 4871

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

4874
int open_and_lock_tables_derived(THD *thd, TABLE_LIST *tables, bool derived)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4875 4876
{
  uint counter;
4877
  bool need_reopen;
4878 4879
  DBUG_ENTER("open_and_lock_tables_derived");
  DBUG_PRINT("enter", ("derived handling: %d", derived));
4880 4881 4882 4883 4884

  for ( ; ; ) 
  {
    if (open_tables(thd, &tables, &counter, 0))
      DBUG_RETURN(-1);
4885 4886 4887 4888 4889 4890 4891

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

4892 4893 4894 4895
    if (!lock_tables(thd, tables, counter, &need_reopen))
      break;
    if (!need_reopen)
      DBUG_RETURN(-1);
4896
    close_tables_for_reopen(thd, &tables);
4897
  }
4898 4899 4900 4901
  if (derived &&
      (mysql_handle_derived(thd->lex, &mysql_derived_prepare) ||
       (thd->fill_derived_tables() &&
        mysql_handle_derived(thd->lex, &mysql_derived_filling))))
4902
    DBUG_RETURN(TRUE); /* purecov: inspected */
monty@mysql.com's avatar
monty@mysql.com committed
4903
  DBUG_RETURN(0);
monty@mysql.com's avatar
monty@mysql.com committed
4904 4905 4906
}


4907 4908 4909 4910 4911 4912
/*
  Open all tables in list and process derived tables

  SYNOPSIS
    open_normal_and_derived_tables
    thd		- thread handler
4913
    tables	- list of tables for open
4914 4915 4916
    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.
4917 4918 4919 4920 4921 4922 4923 4924 4925 4926

  RETURN
    FALSE - ok
    TRUE  - error

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

4927
bool open_normal_and_derived_tables(THD *thd, TABLE_LIST *tables, uint flags)
4928 4929 4930
{
  uint counter;
  DBUG_ENTER("open_normal_and_derived_tables");
monty@mysql.com's avatar
monty@mysql.com committed
4931
  DBUG_ASSERT(!thd->fill_derived_tables());
4932
  if (open_tables(thd, &tables, &counter, flags) ||
monty@mysql.com's avatar
monty@mysql.com committed
4933 4934 4935
      mysql_handle_derived(thd->lex, &mysql_derived_prepare))
    DBUG_RETURN(TRUE); /* purecov: inspected */
  DBUG_RETURN(0);
4936 4937 4938
}


4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954
/*
  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)
4955
    if (!table->placeholder())
4956 4957 4958 4959
      table->table->query_id= 0;
}


4960 4961
/**
   Decide on logging format to use for the statement.
4962

4963 4964 4965 4966
   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.
4967

4968 4969
   We now have three alternatives that prevent the statement from
   being loggable:
4970

4971 4972 4973
   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.
4974

4975 4976
   2. Statement mode is set, but the capabilities indicate that
      statement format is not possible.
4977

4978 4979
   3. Row mode is set, but the capabilities indicate that row
      format is not possible.
4980

4981 4982 4983 4984 4985 4986
   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.
4987

4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999
   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))
5000
  {
5001 5002 5003 5004
    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;
5005
    for (TABLE_LIST *table= tables; table; table= table->next_global)
5006
    {
5007 5008
      if (!table->placeholder() && table->lock_type >= TL_WRITE_ALLOW_WRITE)
      {
5009
        ulonglong const flags= table->table->file->ha_table_flags();
5010
        DBUG_PRINT("info", ("table: %s; ha_table_flags: %s%s",
5011
                            table->table_name,
5012 5013
                            FLAGSTR(flags, HA_BINLOG_STMT_CAPABLE),
                            FLAGSTR(flags, HA_BINLOG_ROW_CAPABLE)));
5014 5015 5016 5017 5018
        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;
5019
      }
5020 5021 5022 5023 5024 5025 5026 5027
    }

    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)));
5028 5029
    DBUG_PRINT("info", ("thd->variables.binlog_format: %ld",
                        thd->variables.binlog_format));
5030 5031
    DBUG_PRINT("info", ("multi_engine: %s",
                        multi_engine ? "TRUE" : "FALSE"));
5032 5033

    int error= 0;
5034
    if (flags_all_set == 0)
5035
    {
5036 5037 5038
      my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
               "Statement cannot be logged to the binary log in"
               " row-based nor statement-based format");
5039 5040
    }
    else if (thd->variables.binlog_format == BINLOG_FORMAT_STMT &&
5041
             (flags_all_set & HA_BINLOG_STMT_CAPABLE) == 0)
5042
    {
5043 5044 5045
      my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
                "Statement-based format required for this statement,"
                " but not allowed by this combination of engines");
5046 5047 5048
    }
    else if ((thd->variables.binlog_format == BINLOG_FORMAT_ROW ||
              thd->lex->is_stmt_unsafe()) &&
5049
             (flags_all_set & HA_BINLOG_ROW_CAPABLE) == 0)
5050
    {
5051 5052 5053
      my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
                "Row-based format required for this statement,"
                " but not allowed by this combination of engines");
5054 5055
    }

5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071
    /*
      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");
    }

5072 5073 5074
    DBUG_PRINT("info", ("error: %d", error));

    if (error)
5075
      return -1;
5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087

    /*
      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.
5088
    */
5089
    if (thd->lex->is_stmt_unsafe() ||
5090
        (flags_all_set & HA_BINLOG_STMT_CAPABLE) == 0)
5091 5092 5093 5094
    {
      thd->set_current_stmt_binlog_row_based_if_mixed();
    }
  }
5095

5096 5097 5098
  return 0;
}

5099 5100 5101 5102 5103 5104 5105
/*
  Lock all tables in list

  SYNOPSIS
    lock_tables()
    thd			Thread handler
    tables		Tables to lock
5106 5107 5108 5109 5110 5111
    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).
5112

5113 5114 5115 5116 5117
  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.

5118 5119 5120 5121
    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.

5122 5123 5124 5125 5126
  RETURN VALUES
   0	ok
   -1	Error
*/

5127
int lock_tables(THD *thd, TABLE_LIST *tables, uint count, bool *need_reopen)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5128
{
5129
  TABLE_LIST *table;
5130 5131 5132 5133 5134 5135 5136

  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());
5137 5138
  *need_reopen= FALSE;

5139
  if (!tables && !thd->lex->requires_prelocking())
5140
    DBUG_RETURN(decide_logging_format(thd, tables));
5141

5142 5143 5144 5145 5146 5147 5148 5149 5150 5151
  /*
    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
5152
  {
5153
    DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5154
    TABLE **start,**ptr;
5155
    uint lock_flag= MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN;
5156

5157
    if (!(ptr=start=(TABLE**) thd->alloc(sizeof(TABLE*)*count)))
5158
      DBUG_RETURN(-1);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5159
    for (table= tables; table; table= table->next_global)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5160
    {
5161
      if (!table->placeholder())
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5162 5163
	*(ptr++)= table->table;
    }
5164 5165 5166 5167 5168 5169

    /* 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;
5170 5171 5172 5173 5174 5175 5176 5177
      /*
        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))
      {
5178
        thd->lex->set_stmt_unsafe();
5179 5180
        thd->set_current_stmt_binlog_row_based_if_mixed();
      }
5181 5182
    }

5183
    if (! (thd->lock= mysql_lock_tables(thd, start, (uint) (ptr - start),
5184
                                        lock_flag, need_reopen)))
5185 5186 5187
    {
      if (thd->lex->requires_prelocking())
      {
5188
        thd->options&= ~(OPTION_TABLE_LOCK);
5189 5190 5191 5192
        thd->in_lock_tables=0;
      }
      DBUG_RETURN(-1);
    }
5193

5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211
    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;

5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222
      /*
        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)
5223
      {
5224
        if (!table->placeholder())
5225 5226 5227 5228 5229 5230
        {
          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;
5231
            thd->options&= ~(OPTION_TABLE_LOCK);
5232 5233 5234 5235 5236 5237 5238 5239 5240
            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);
5241
      DBUG_PRINT("info",("prelocked_mode= PRELOCKED"));
5242 5243
      thd->prelocked_mode= PRELOCKED;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5244
  }
5245 5246
  else
  {
5247
    TABLE_LIST *first_not_own= thd->lex->first_not_own_table();
5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258
    /*
      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)
5259
    {
5260
      if (!table->placeholder() &&
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5261
	  check_lock_and_start_stmt(thd, table->table, table->lock_type))
5262
      {
5263
	DBUG_RETURN(-1);
5264 5265
      }
    }
5266 5267 5268 5269 5270 5271 5272 5273
    /*
      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);
5274
      DBUG_PRINT("info", ("thd->prelocked_mode= PRELOCKED_UNDER_LOCK_TABLES"));
5275 5276
      thd->prelocked_mode= PRELOCKED_UNDER_LOCK_TABLES;
    }
5277
  }
5278 5279

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

5282

5283 5284 5285 5286 5287 5288
/*
  Prepare statement for reopening of tables and recalculation of set of
  prelocked tables.

  SYNOPSIS
    close_tables_for_reopen()
5289 5290
      thd    in     Thread context
      tables in/out List of tables which we were trying to open and lock
5291 5292 5293

*/

5294
void close_tables_for_reopen(THD *thd, TABLE_LIST **tables)
5295
{
5296 5297 5298 5299 5300 5301
  /*
    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;
5302 5303
  thd->lex->chop_off_not_own_tables();
  sp_remove_not_own_routines(thd->lex);
5304 5305
  for (TABLE_LIST *tmp= *tables; tmp; tmp= tmp->next_global)
    tmp->table= 0;
5306 5307 5308 5309
  close_thread_tables(thd);
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
5310
/*
5311
  Open a single table without table caching and don't set it in open_list
5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327

  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
5328 5329 5330 5331 5332 5333
*/

TABLE *open_temporary_table(THD *thd, const char *path, const char *db,
			    const char *table_name, bool link_in_list)
{
  TABLE *tmp_table;
5334
  TABLE_SHARE *share;
5335 5336 5337
  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
5338
  DBUG_ENTER("open_temporary_table");
5339 5340 5341 5342 5343
  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));
5344

5345 5346 5347 5348 5349 5350 5351 5352
  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
5353 5354
    DBUG_RETURN(0);				/* purecov: inspected */

5355 5356 5357 5358 5359
  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);

5360
  init_tmp_table_share(thd, share, saved_cache_key, key_length,
5361 5362 5363 5364 5365 5366 5367 5368
                       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,
5369
                            tmp_table, FALSE))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5370
  {
5371 5372
    /* No need to lock share->mutex as this is not needed for tmp tables */
    free_table_share(share);
5373
    my_free((char*) tmp_table,MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5374 5375 5376
    DBUG_RETURN(0);
  }

5377
  tmp_table->reginfo.lock_type= TL_WRITE;	 // Simulate locked
5378
  share->tmp_table= (tmp_table->file->has_transactions() ? 
5379
                     TRANSACTIONAL_TMP_TABLE : NON_TRANSACTIONAL_TMP_TABLE);
5380

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5381 5382
  if (link_in_list)
  {
5383 5384 5385 5386
    /* growing temp list at the head */
    tmp_table->next= thd->temporary_tables;
    if (tmp_table->next)
      tmp_table->next->prev= tmp_table;
5387
    thd->temporary_tables= tmp_table;
5388
    thd->temporary_tables->prev= 0;
5389 5390
    if (thd->slave_thread)
      slave_open_temp_tables++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5391
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5392
  tmp_table->pos_in_table_list= 0;
5393 5394
  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
5395 5396 5397 5398
  DBUG_RETURN(tmp_table);
}


5399
bool rm_temporary_table(handlerton *base, char *path)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5400 5401
{
  bool error=0;
5402 5403
  handler *file;
  char *ext;
5404 5405
  DBUG_ENTER("rm_temporary_table");

5406
  strmov(ext= strend(path), reg_ext);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5407 5408
  if (my_delete(path,MYF(0)))
    error=1; /* purecov: inspected */
5409 5410
  *ext= 0;				// remove extension
  file= get_new_handler((TABLE_SHARE*) 0, current_thd->mem_root, base);
5411
  if (file && file->ha_delete_table(path))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5412
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5413
    error=1;
5414
    sql_print_warning("Could not remove temporary table: '%s', error: %d",
serg@serg.mylan's avatar
serg@serg.mylan committed
5415
                      path, my_errno);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5416
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5417
  delete file;
5418
  DBUG_RETURN(error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5419 5420 5421 5422
}


/*****************************************************************************
5423 5424 5425 5426 5427 5428
* 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
5429 5430
******************************************************************************/

5431
/* Special Field pointers as return values of find_field_in_XXX functions. */
5432 5433
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
5434

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

5437 5438
static void update_field_dependencies(THD *thd, Field *field, TABLE *table)
{
5439 5440
  DBUG_ENTER("update_field_dependencies");
  if (thd->mark_used_columns != MARK_COLUMNS_NONE)
5441
  {
5442 5443 5444 5445 5446 5447 5448
    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).
    */
      
5449
    table->covering_keys.intersect(field->part_of_key);
5450 5451 5452
    table->merge_keys.merge(field->part_of_key);

    if (thd->mark_used_columns == MARK_COLUMNS_READ)
5453
    {
5454 5455
      current_bitmap= table->read_set;
      other_bitmap=   table->write_set;
5456 5457
    }
    else
5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480
    {
      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)
5481
    field->flags|= GET_FIXED_FIELDS_FLAG;
5482
  DBUG_VOID_RETURN;
5483 5484
}

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5485 5486

/*
5487
  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
5488 5489

  SYNOPSIS
5490
    find_field_in_view()
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5491
    thd				thread handler
5492
    table_list			view to search for 'name'
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5493 5494
    name			name of field
    length			length of name
5495
    item_name                   name of item if it will be created (VIEW)
5496 5497
    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
5498
    register_tree_change        TRUE if ref is not stack variable and we
5499
                                need register changes in item tree
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5500 5501 5502 5503

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

5507 5508
static Field *
find_field_in_view(THD *thd, TABLE_LIST *table_list,
5509 5510
                   const char *name, uint length,
                   const char *item_name, Item **ref,
5511
                   bool register_tree_change)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5512
{
5513 5514 5515 5516 5517 5518
  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
5519
  Query_arena *arena= 0, backup;  
5520
  
5521 5522 5523
  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
5524
  {
5525
    if (!my_strcasecmp(system_charset_info, field_it.name(), name))
5526
    {
5527
      // in PS use own arena or data will be freed after prepare
gshchepa/uchum@gleb.loc's avatar
gshchepa/uchum@gleb.loc committed
5528
      if (register_tree_change && thd->stmt_arena->is_stmt_prepare_or_first_sp_execute())
5529
        arena= thd->activate_stmt_arena_if_needed(&backup);
5530 5531 5532 5533
      /*
        create_item() may, or may not create a new Item, depending on
        the column reference. See create_view_field() for details.
      */
5534
      Item *item= field_it.create_item(thd);
gshchepa/uchum@gleb.loc's avatar
gshchepa/uchum@gleb.loc committed
5535
      if (arena)
5536 5537
        thd->restore_active_arena(arena, &backup);
      
5538 5539 5540 5541 5542 5543
      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.
5544
       We need to set alias on both ref itself and on ref real item.
5545 5546
      */
      if (*ref && !(*ref)->is_autogenerated_name)
5547
      {
5548 5549
        item->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
5550 5551 5552
        item->real_item()->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
      }
5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580
      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

5581 5582 5583 5584 5585 5586
  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.

5587
  RETURN
5588 5589 5590
    NULL        if the field was not found
    WRONG_GRANT if no access rights to the found field
    #           Pointer to the found Field
5591 5592 5593 5594
*/

static Field *
find_field_in_natural_join(THD *thd, TABLE_LIST *table_ref, const char *name,
5595
                           uint length, Item **ref, bool register_tree_change,
5596
                           TABLE_LIST **actual_table)
5597
{
5598 5599
  List_iterator_fast<Natural_join_column>
    field_it(*(table_ref->join_columns));
5600
  Natural_join_column *nj_col, *curr_nj_col;
5601
  Field *found_field;
5602
  Query_arena *arena, backup;
5603
  DBUG_ENTER("find_field_in_natural_join");
5604
  DBUG_PRINT("enter", ("field name: '%s', ref 0x%lx",
5605 5606
		       name, (ulong) ref));
  DBUG_ASSERT(table_ref->is_natural_join && table_ref->join_columns);
5607
  DBUG_ASSERT(*actual_table == NULL);
5608

5609
  LINT_INIT(arena);
5610
  LINT_INIT(found_field);
5611

5612 5613
  for (nj_col= NULL, curr_nj_col= field_it++; curr_nj_col; 
       curr_nj_col= field_it++)
5614
  {
5615 5616 5617 5618 5619 5620 5621 5622 5623
    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
5624
  }
5625 5626
  if (!nj_col)
    DBUG_RETURN(NULL);
5627 5628 5629

  if (nj_col->view_field)
  {
monty@mysql.com's avatar
monty@mysql.com committed
5630
    Item *item;
5631
    LINT_INIT(arena);
5632 5633
    if (register_tree_change)
      arena= thd->activate_stmt_arena_if_needed(&backup);
5634 5635 5636 5637
    /*
      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
5638
    item= nj_col->create_item(thd);
5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651
    /*
     *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);
    }
5652 5653 5654
    if (register_tree_change && arena)
      thd->restore_active_arena(arena, &backup);

5655 5656 5657 5658
    if (!item)
      DBUG_RETURN(NULL);
    DBUG_ASSERT(nj_col->table_field == NULL);
    if (nj_col->table_ref->schema_table_reformed)
5659
    {
5660 5661 5662 5663 5664 5665
      /*
        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);
5666
    }
5667 5668 5669 5670 5671 5672 5673 5674 5675 5676
    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);
5677
    DBUG_ASSERT(nj_col->table_ref->table == nj_col->table_field->table);
5678 5679 5680 5681 5682 5683 5684
    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
5685 5686
}

5687

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5688
/*
5689
  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
5690 5691

  SYNOPSIS
5692
    find_field_in_table()
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5693
    thd				thread handler
5694
    table			table where to search for the field
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5695 5696 5697
    name			name of field
    length			length of name
    allow_rowid			do allow finding of "_rowid" field?
5698 5699
    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
5700 5701

  RETURN
5702 5703
    0	field is not found
    #	pointer to field
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5704 5705
*/

5706 5707
Field *
find_field_in_table(THD *thd, TABLE *table, const char *name, uint length,
5708
                    bool allow_rowid, uint *cached_field_index_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5709
{
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5710 5711
  Field **field_ptr, *field;
  uint cached_field_index= *cached_field_index_ptr;
5712 5713
  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
5714 5715

  /* We assume here that table->field < NO_CACHED_FIELD_INDEX = UINT_MAX */
5716
  if (cached_field_index < table->s->fields &&
5717
      !my_strcasecmp(system_charset_info,
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5718 5719
                     table->field[cached_field_index]->field_name, name))
    field_ptr= table->field + cached_field_index;
5720
  else if (table->s->name_hash.records)
5721
  {
5722
    field_ptr= (Field**) hash_search(&table->s->name_hash, (uchar*) name,
5723
                                     length);
5724 5725 5726 5727 5728 5729 5730 5731 5732
    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
5733 5734 5735
  else
  {
    if (!(field_ptr= table->field))
5736
      DBUG_RETURN((Field *)0);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5737 5738 5739 5740 5741 5742
    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
5743
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5744 5745
    *cached_field_index_ptr= field_ptr - table->field;
    field= *field_ptr;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5746 5747 5748
  }
  else
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5749 5750
    if (!allow_rowid ||
        my_strcasecmp(system_charset_info, name, "_rowid") ||
5751
        table->s->rowid_field_offset == 0)
5752
      DBUG_RETURN((Field*) 0);
5753
    field= table->field[table->s->rowid_field_offset-1];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5754 5755
  }

5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769
  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
5770
    length		   [in]  field length of name
5771 5772
    item_name              [in]  name of item if it will be created (VIEW)
    db_name                [in]  optional database name that qualifies the
5773
    table_name             [in]  optional table name that qualifies the field
5774 5775
    ref		       [in/out] if 'name' is resolved to a view field, ref
                                 is set to point to the found view field
5776
    check_privileges       [in]  check privileges
5777 5778 5779 5780 5781 5782 5783 5784 5785
    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
5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797
  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.

5798 5799 5800 5801 5802 5803 5804 5805
  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,
5806 5807 5808
                        const char *name, uint length,
                        const char *item_name, const char *db_name,
                        const char *table_name, Item **ref,
5809 5810
                        bool check_privileges, bool allow_rowid,
                        uint *cached_field_index_ptr,
5811 5812 5813 5814
                        bool register_tree_change, TABLE_LIST **actual_table)
{
  Field *fld;
  DBUG_ENTER("find_field_in_table_ref");
5815 5816 5817
  DBUG_ASSERT(table_list->alias);
  DBUG_ASSERT(name);
  DBUG_ASSERT(item_name);
5818 5819 5820 5821 5822 5823
  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
5824 5825
    are the same as the table reference we are going to search for the field.

5826 5827 5828 5829
    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
5830 5831 5832 5833 5834 5835

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

5836 5837
    TODO: Ensure that table_name, db_name and tables->db always points to
          something !
5838
  */
5839 5840
  if (/* Exclude nested joins. */
      (!table_list->nested_join ||
timour@mysql.com's avatar
timour@mysql.com committed
5841 5842 5843 5844 5845 5846
       /* Include merge views and information schema tables. */
       table_list->field_translation) &&
      /*
        Test if the field qualifiers match the table reference we plan
        to search.
      */
5847 5848
      table_name && table_name[0] &&
      (my_strcasecmp(table_alias_charset, table_list->alias, table_name) ||
5849 5850 5851 5852
       (db_name && db_name[0] && table_list->db && table_list->db[0] &&
        strcmp(db_name, table_list->db))))
    DBUG_RETURN(0);

5853
  *actual_table= NULL;
timour@mysql.com's avatar
timour@mysql.com committed
5854

5855 5856
  if (table_list->field_translation)
  {
timour@mysql.com's avatar
timour@mysql.com committed
5857
    /* 'table_list' is a view or an information schema table. */
5858
    if ((fld= find_field_in_view(thd, table_list, name, length, item_name, ref,
5859
                                 register_tree_change)))
5860 5861
      *actual_table= table_list;
  }
5862
  else if (!table_list->nested_join)
5863
  {
5864 5865
    /* 'table_list' is a stored table. */
    DBUG_ASSERT(table_list->table);
timour@mysql.com's avatar
timour@mysql.com committed
5866
    if ((fld= find_field_in_table(thd, table_list->table, name, length,
5867 5868
                                  allow_rowid,
                                  cached_field_index_ptr)))
timour@mysql.com's avatar
timour@mysql.com committed
5869 5870 5871
      *actual_table= table_list;
  }
  else
5872
  {
timour@mysql.com's avatar
timour@mysql.com committed
5873
    /*
timour@mysql.com's avatar
timour@mysql.com committed
5874 5875 5876 5877 5878
      '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
5879
    */
5880 5881 5882 5883 5884 5885
    if (table_name && table_name[0])
    {
      List_iterator<TABLE_LIST> it(table_list->nested_join->join_list);
      TABLE_LIST *table;
      while ((table= it++))
      {
5886 5887
        if ((fld= find_field_in_table_ref(thd, table, name, length, item_name,
                                          db_name, table_name, ref,
5888 5889
                                          check_privileges, allow_rowid,
                                          cached_field_index_ptr,
5890 5891 5892 5893 5894 5895 5896
                                          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
5897 5898 5899
      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.
5900 5901
    */
    fld= find_field_in_natural_join(thd, table_list, name, length, ref,
5902
                                    register_tree_change, actual_table);
5903
  }
5904

5905 5906
  if (fld)
  {
5907
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5908 5909 5910 5911 5912
    /* 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
5913
#endif
5914
      if (thd->mark_used_columns != MARK_COLUMNS_NONE)
5915
      {
5916
        /*
5917 5918 5919
          Get rw_set correct for this field so that the handler
          knows that this field is involved in the query and gets
          retrieved/updated
5920
         */
5921 5922 5923 5924 5925 5926
        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;
5927 5928 5929
          else
          {
            if (thd->mark_used_columns == MARK_COLUMNS_READ)
5930
              it->walk(&Item::register_field_in_read_map, 1, (uchar *) 0);
5931
          }
5932 5933 5934 5935
        }
        else
          field_to_set= fld;
        if (field_to_set)
5936 5937 5938 5939 5940 5941 5942
        {
          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);
        }
5943 5944
      }
  }
5945
  DBUG_RETURN(fld);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5946 5947
}

5948

5949 5950 5951 5952 5953 5954 5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967
/*
  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)
5968
  {
5969
    field_ptr= (Field**)hash_search(&table->s->name_hash,(uchar*) name,
5970
                                    strlen(name));
5971 5972 5973 5974 5975 5976 5977 5978 5979
    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));
    }
  }
5980 5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994
  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;
}


5995 5996 5997 5998 5999
/*
  Find field in table list.

  SYNOPSIS
    find_field_in_tables()
6000 6001 6002 6003 6004 6005
    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
6006
                          point to the found view field
6007
    report_error	  Degree of error reporting:
6008 6009
                          - IGNORE_ERRORS then do not report any error
                          - IGNORE_EXCEPT_NON_UNIQUE report only non-unique
6010
                            fields, suppress all other errors
6011 6012 6013 6014
                          - REPORT_EXCEPT_NON_UNIQUE report all other errors
                            except when non-unique fields were found
                          - REPORT_ALL_ERRORS
    check_privileges      need to check privileges
6015 6016
    register_tree_change  TRUE if ref is not a stack variable and we
                          to need register changes in item tree
6017 6018

  RETURN VALUES
6019 6020 6021
    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.
6022 6023 6024 6025 6026
    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
6027
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6028 6029

Field *
6030 6031
find_field_in_tables(THD *thd, Item_ident *item,
                     TABLE_LIST *first_table, TABLE_LIST *last_table,
6032
		     Item **ref, find_item_error_report_type report_error,
6033
                     bool check_privileges, bool register_tree_change)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6034 6035
{
  Field *found=0;
6036 6037 6038
  const char *db= item->db_name;
  const char *table_name= item->table_name;
  const char *name= item->field_name;
6039
  uint length=(uint) strlen(name);
6040
  char name_buff[NAME_LEN+1];
6041 6042
  TABLE_LIST *cur_table= first_table;
  TABLE_LIST *actual_table;
6043 6044 6045 6046 6047 6048 6049 6050 6051
  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
6052

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6053 6054 6055
  if (item->cached_table)
  {
    /*
6056 6057
      This shortcut is used by prepared statements. We assume that
      TABLE_LIST *first_table is not changed during query execution (which
6058
      is true for all queries except RENAME but luckily RENAME doesn't
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6059
      use fields...) so we can rely on reusing pointer to its member.
timour@mysql.com's avatar
timour@mysql.com committed
6060
      With this optimization we also miss case when addition of one more
6061
      field makes some prepared query ambiguous and so erroneous, but we
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6062 6063
      accept this trade off.
    */
6064 6065 6066 6067 6068 6069 6070 6071
    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,
6072
                                 TRUE, &(item->cached_field_index));
6073
    else
6074
      found= find_field_in_table_ref(thd, table_ref, name, length, item->name,
6075 6076
                                     NULL, NULL, ref, check_privileges,
                                     TRUE, &(item->cached_field_index),
6077 6078
                                     register_tree_change,
                                     &actual_table);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6079 6080 6081
    if (found)
    {
      if (found == WRONG_GRANT)
6082
	return (Field*) 0;
6083 6084 6085 6086 6087 6088

      /*
        Only views fields should be marked as dependent, not an underlying
        fields.
      */
      if (!table_ref->belong_to_view)
6089 6090
      {
        SELECT_LEX *current_sel= thd->lex->current_select;
6091
        SELECT_LEX *last_select= table_ref->select_lex;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6092 6093
        /*
          If the field was an outer referencee, mark all selects using this
6094
          sub query as dependent on the outer query
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6095
        */
6096
        if (current_sel != last_select)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6097
          mark_select_range_as_dependent(thd, last_select, current_sel,
6098 6099
                                         found, *ref, item);
      }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6100 6101 6102 6103
      return found;
    }
  }

6104 6105 6106
  if (db && lower_case_table_names)
  {
    /*
timour@mysql.com's avatar
timour@mysql.com committed
6107
      convert database to lower case for comparison.
6108 6109 6110 6111
      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
6112
    my_casedn_str(files_charset_info, name_buff);
6113 6114
    db= name_buff;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6115

6116 6117 6118 6119 6120
  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
6121
  {
6122 6123
    Field *cur_field= find_field_in_table_ref(thd, cur_table, name, length,
                                              item->name, db, table_name, ref,
6124 6125 6126
                                              (thd->lex->sql_command ==
                                               SQLCOM_SHOW_FIELDS)
                                              ? false : check_privileges,
6127
                                              allow_rowid,
6128 6129 6130 6131
                                              &(item->cached_field_index),
                                              register_tree_change,
                                              &actual_table);
    if (cur_field)
6132
    {
6133
      if (cur_field == WRONG_GRANT)
6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150
      {
        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);
6151
          nf->init(cur_table->table);
6152 6153 6154
          cur_field= nf;
        }
      }
6155 6156 6157 6158 6159 6160 6161 6162

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

6163 6164 6165 6166 6167
      DBUG_ASSERT(thd->where);
      /*
        If we found a fully qualified field we return it directly as it can't
        have duplicates.
       */
6168
      if (db)
6169 6170
        return cur_field;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
6171 6172
      if (found)
      {
6173 6174
        if (report_error == REPORT_ALL_ERRORS ||
            report_error == IGNORE_EXCEPT_NON_UNIQUE)
6175
          my_error(ER_NON_UNIQ_ERROR, MYF(0),
6176
                   table_name ? item->full_name() : name, thd->where);
6177
        return (Field*) 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6178
      }
6179
      found= cur_field;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6180 6181
    }
  }
6182

bk@work.mysql.com's avatar
bk@work.mysql.com committed
6183 6184
  if (found)
    return found;
6185 6186 6187 6188 6189 6190 6191 6192

  /*
    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.
  */
6193
  if (table_name && (cur_table == first_table) &&
6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204
      (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);
  }
6205
  else
6206
  {
6207 6208 6209 6210 6211
    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;
6212
  }
6213
  return found;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6214 6215
}

6216 6217 6218

/*
  Find Item in list of items (find_field_in_tables analog)
6219 6220 6221 6222

  TODO
    is it better return only counter?

6223 6224
  SYNOPSIS
    find_item_in_list()
6225 6226 6227
    find			Item to find
    items			List of items
    counter			To return number of found item
6228
    report_error
6229 6230 6231 6232 6233
      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
6234 6235 6236 6237 6238 6239 6240
    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)
                                
6241
  RETURN VALUES
6242 6243 6244 6245 6246
    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
6247
                        found field
6248 6249
*/

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


bk@work.mysql.com's avatar
bk@work.mysql.com committed
6254
Item **
6255
find_item_in_list(Item *find, List<Item> &items, uint *counter,
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6256 6257
                  find_item_error_report_type report_error,
                  enum_resolution_type *resolution)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6258 6259
{
  List_iterator<Item> li(items);
6260
  Item **found=0, **found_unaliased= 0, *item;
6261
  const char *db_name=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6262 6263
  const char *field_name=0;
  const char *table_name=0;
6264
  bool found_unaliased_non_uniq= 0;
6265 6266 6267 6268 6269
  /*
    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;
6270
  uint unaliased_counter;
6271 6272
  LINT_INIT(unaliased_counter);                 // Dependent on found_unaliased

igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6273
  *resolution= NOT_RESOLVED;
6274

6275 6276 6277
  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
6278 6279 6280
  {
    field_name= ((Item_ident*) find)->field_name;
    table_name= ((Item_ident*) find)->table_name;
6281
    db_name=    ((Item_ident*) find)->db_name;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6282 6283
  }

6284
  for (uint i= 0; (item=li++); i++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6285
  {
6286
    if (field_name && item->real_item()->type() == Item::FIELD_ITEM)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6287
    {
6288
      Item_ident *item_field= (Item_ident*) item;
6289

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6290 6291 6292 6293 6294 6295
      /*
	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
      */ 
6296 6297 6298 6299
      if (!item_field->name)
        continue;

      if (table_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6300
      {
6301 6302 6303
        /*
          If table name is specified we should find field 'field_name' in
          table 'table_name'. According to SQL-standard we should ignore
6304 6305 6306 6307 6308
          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.
6309

6310
          We use strcmp for table names and database names as these may be
6311 6312
          case sensitive. In cases where they are not case sensitive, they
          are always in lower case.
6313 6314

	  item_field->field_name and item_field->table_name can be 0x0 if
6315
	  item is not fix_field()'ed yet.
6316
        */
6317 6318
        if (item_field->field_name && item_field->table_name &&
	    !my_strcasecmp(system_charset_info, item_field->field_name,
6319
                           field_name) &&
6320 6321
            !my_strcasecmp(table_alias_charset, item_field->table_name, 
                           table_name) &&
6322 6323 6324
            (!db_name || (item_field->db_name &&
                          !strcmp(item_field->db_name, db_name))))
        {
6325
          if (found_unaliased)
6326
          {
6327 6328 6329 6330 6331 6332 6333
            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.
            */
6334
            if (report_error != IGNORE_ERRORS)
6335 6336
              my_error(ER_NON_UNIQ_ERROR, MYF(0),
                       find->full_name(), current_thd->where);
6337 6338
            return (Item**) 0;
          }
6339 6340
          found_unaliased= li.ref();
          unaliased_counter= i;
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6341
          *resolution= RESOLVED_IGNORING_ALIAS;
6342 6343
          if (db_name)
            break;                              // Perfect match
6344 6345
        }
      }
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6346
      else
6347
      {
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6348 6349 6350 6351 6352
        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))
6353
        {
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6354 6355 6356 6357 6358 6359 6360 6361 6362 6363 6364 6365 6366 6367 6368 6369 6370 6371 6372 6373
          /*
            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;
6374
        }
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6375
        else if (!fname_cmp)
6376
        {
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6377 6378 6379 6380 6381 6382 6383 6384 6385 6386 6387 6388
          /*
            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;
          }
6389 6390 6391
          found_unaliased= li.ref();
          unaliased_counter= i;
        }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6392 6393
      }
    }
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6394 6395 6396 6397 6398 6399 6400 6401 6402 6403 6404 6405 6406 6407 6408 6409 6410
    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;
      }
6411 6412 6413 6414 6415 6416 6417 6418 6419 6420 6421 6422 6423 6424 6425 6426 6427 6428 6429 6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440
    }
    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
6441
  }
6442 6443 6444 6445 6446
  if (!found)
  {
    if (found_unaliased_non_uniq)
    {
      if (report_error != IGNORE_ERRORS)
6447 6448
        my_error(ER_NON_UNIQ_ERROR, MYF(0),
                 find->full_name(), current_thd->where);
6449 6450 6451 6452 6453 6454
      return (Item **) 0;
    }
    if (found_unaliased)
    {
      found= found_unaliased;
      *counter= unaliased_counter;
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6455
      *resolution= RESOLVED_BEHIND_ALIAS;
6456 6457
    }
  }
6458 6459
  if (found)
    return found;
6460
  if (report_error != REPORT_EXCEPT_NOT_FOUND)
6461 6462
  {
    if (report_error == REPORT_ALL_ERRORS)
6463 6464
      my_error(ER_BAD_FIELD_ERROR, MYF(0),
               find->full_name(), current_thd->where);
6465 6466 6467 6468
    return (Item **) 0;
  }
  else
    return (Item **) not_found_item;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6469 6470
}

6471 6472 6473 6474 6475 6476 6477 6478 6479 6480 6481 6482 6483 6484 6485 6486 6487 6488 6489 6490 6491 6492 6493 6494 6495 6496 6497 6498

/*
  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;
6499
    if (!my_strcasecmp(system_charset_info, find, curr_str->ptr()))
6500 6501 6502 6503 6504 6505 6506 6507 6508 6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520
      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
6521 6522
    FALSE  if all OK
    TRUE   otherwise
6523 6524 6525 6526 6527 6528
*/

static bool
set_new_item_local_context(THD *thd, Item_ident *item, TABLE_LIST *table_ref)
{
  Name_resolution_context *context;
6529
  if (!(context= new (thd->mem_root) Name_resolution_context))
6530 6531
    return TRUE;
  context->init();
6532 6533
  context->first_name_resolution_table=
    context->last_name_resolution_table= table_ref;
6534 6535 6536 6537 6538 6539 6540 6541 6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 6552 6553 6554 6555 6556 6557 6558 6559 6560 6561 6562 6563 6564 6565
  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
6566 6567
    TRUE   error when some common column is non-unique, or out of memory
    FALSE  OK
6568 6569 6570 6571 6572 6573 6574 6575 6576 6577
*/

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
6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588
  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;
6589 6590

  DBUG_ENTER("mark_common_columns");
6591
  DBUG_PRINT("info", ("operand_1: %s  operand_2: %s",
6592 6593
                      table_ref_1->alias, table_ref_2->alias));

6594
  *found_using_fields= 0;
konstantin@mysql.com's avatar
konstantin@mysql.com committed
6595
  arena= thd->activate_stmt_arena_if_needed(&backup);
6596 6597 6598

  for (it_1.set(table_ref_1); !it_1.end_of_fields(); it_1.next())
  {
6599
    bool found= FALSE;
konstantin@mysql.com's avatar
konstantin@mysql.com committed
6600
    const char *field_name_1;
6601 6602
    /* 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
6603
    if (!(nj_col_1= it_1.get_or_create_column_ref(leaf_1)))
6604 6605
      goto err;
    field_name_1= nj_col_1->name();
6606 6607 6608 6609 6610
    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));
6611

6612 6613 6614 6615 6616 6617 6618
    /*
      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.
    */
6619 6620 6621 6622
    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;
6623
      const char *cur_field_name_2;
timour@mysql.com's avatar
timour@mysql.com committed
6624
      if (!(cur_nj_col_2= it_2.get_or_create_column_ref(leaf_2)))
6625
        goto err;
6626
      cur_field_name_2= cur_nj_col_2->name();
6627 6628 6629 6630
      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));
6631

timour@mysql.com's avatar
timour@mysql.com committed
6632 6633 6634 6635 6636 6637
      /*
        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).
6638 6639 6640 6641
        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
6642
      */
6643 6644
      if (!my_strcasecmp(system_charset_info, field_name_1, cur_field_name_2))
      {
6645 6646 6647
        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)))
6648 6649 6650 6651 6652 6653 6654 6655
        {
          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
6656 6657 6658 6659 6660 6661 6662 6663 6664
    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;
    }
6665
    if (!found)
6666
      continue;                                 // No matching field
6667 6668 6669 6670 6671 6672

    /*
      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.
    */
6673
    if (nj_col_2 && (!using_fields ||is_using_column_1))
6674 6675 6676 6677 6678 6679
    {
      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;
6680 6681 6682 6683 6684
      Item_func_eq *eq_cond;

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

6685
      /*
6686
        The following assert checks that the two created items are of
6687 6688 6689 6690 6691 6692 6693 6694 6695 6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710
        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.
      */
6711 6712
      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))
6713 6714
        goto err;

6715 6716
      if (!(eq_cond= new Item_func_eq(item_ident_1, item_ident_2)))
        goto err;                               /* Out of memory. */
6717 6718 6719 6720 6721 6722

      /*
        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.
       */
6723 6724 6725
      add_join_on((table_ref_1->outer_join & JOIN_TYPE_RIGHT ?
                   table_ref_1 : table_ref_2),
                  eq_cond);
6726 6727

      nj_col_1->is_common= nj_col_2->is_common= TRUE;
6728 6729 6730 6731 6732 6733 6734
      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()));
6735 6736 6737

      if (field_1)
      {
6738
        TABLE *table_1= nj_col_1->table_ref->table;
6739
        /* Mark field_1 used for table cache. */
6740
        bitmap_set_bit(table_1->read_set, field_1->field_index);
6741
        table_1->covering_keys.intersect(field_1->part_of_key);
6742
        table_1->merge_keys.merge(field_1->part_of_key);
6743 6744 6745
      }
      if (field_2)
      {
6746
        TABLE *table_2= nj_col_2->table_ref->table;
6747
        /* Mark field_2 used for table cache. */
6748
        bitmap_set_bit(table_2->read_set, field_2->field_index);
6749
        table_2->covering_keys.intersect(field_2->part_of_key);
6750
        table_2->merge_keys.merge(field_2->part_of_key);
6751 6752 6753 6754 6755 6756
      }

      if (using_fields != NULL)
        ++(*found_using_fields);
    }
  }
timour@mysql.com's avatar
timour@mysql.com committed
6757 6758
  if (leaf_1)
    leaf_1->is_join_columns_complete= TRUE;
6759 6760 6761 6762 6763 6764 6765 6766 6767 6768 6769 6770

  /*
    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
6771
    thd->restore_active_arena(arena, &backup);
6772 6773 6774 6775 6776 6777 6778 6779 6780 6781 6782 6783 6784 6785 6786 6787 6788 6789 6790 6791 6792 6793 6794 6795 6796 6797 6798 6799 6800 6801 6802 6803 6804 6805 6806 6807
  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
6808 6809
    TRUE    error: Some common column is ambiguous
    FALSE   OK
6810 6811 6812 6813 6814 6815 6816 6817 6818 6819 6820 6821 6822
*/

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;
6823
  List<Natural_join_column> *non_join_columns;
6824 6825
  DBUG_ENTER("store_natural_using_join_columns");

6826 6827
  DBUG_ASSERT(!natural_using_join->join_columns);

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

6830 6831
  if (!(non_join_columns= new List<Natural_join_column>) ||
      !(natural_using_join->join_columns= new List<Natural_join_column>))
6832 6833 6834 6835 6836
    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())
  {
6837
    nj_col_1= it_1.get_natural_column_ref();
6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849 6850 6851 6852 6853 6854 6855 6856 6857 6858
    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++))
    {
6859
      const char *using_field_name_ptr= using_field_name->c_ptr();
6860 6861 6862
      List_iterator_fast<Natural_join_column>
        it(*(natural_using_join->join_columns));
      Natural_join_column *common_field;
6863 6864

      for (;;)
6865
      {
6866 6867 6868 6869 6870 6871 6872
        /* 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;
        }
6873 6874
        if (!my_strcasecmp(system_charset_info,
                           common_field->name(), using_field_name_ptr))
6875
          break;                                // Found match
6876 6877 6878 6879 6880 6881 6882
      }
    }
  }

  /* 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())
  {
6883
    nj_col_2= it_2.get_natural_column_ref();
6884 6885 6886
    if (!nj_col_2->is_common)
      non_join_columns->push_back(nj_col_2);
    else
6887
    {
6888 6889
      /* Reset the common columns for the next call to mark_common_columns. */
      nj_col_2->is_common= FALSE;
6890
    }
6891 6892 6893 6894 6895 6896 6897 6898 6899 6900
  }

  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
6901
    thd->restore_active_arena(arena, &backup);
6902 6903 6904
  DBUG_RETURN(result);
}

6905

6906 6907 6908 6909 6910 6911 6912 6913 6914 6915 6916 6917 6918 6919 6920 6921 6922 6923 6924 6925 6926 6927 6928 6929 6930 6931
/*
  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
6932 6933
    TRUE   Error
    FALSE  OK
6934 6935 6936 6937 6938 6939 6940
*/

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
6941 6942 6943
  Query_arena *arena, backup;
  bool result= TRUE;

6944
  DBUG_ENTER("store_top_level_join_columns");
6945

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

6948 6949 6950 6951
  /* 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
6952 6953 6954 6955
    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;
6956

timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
6957
    while (same_level_left_neighbor)
6958
    {
timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
6959 6960
      TABLE_LIST *cur_table_ref= same_level_left_neighbor;
      same_level_left_neighbor= nested_it++;
6961 6962 6963 6964
      /*
        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
6965 6966 6967 6968 6969
        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
6970 6971
        swapped in the first loop.
      */
timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
6972
      if (same_level_left_neighbor &&
6973 6974 6975 6976
          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
6977
        swap_variables(TABLE_LIST*, same_level_left_neighbor, cur_table_ref);
6978 6979
      }

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

6989 6990
      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
6991
                                       real_left_neighbor, real_right_neighbor))
timour@mysql.com's avatar
timour@mysql.com committed
6992
        goto err;
timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
6993
      same_level_right_neighbor= cur_table_ref;
6994 6995 6996 6997 6998 6999 7000 7001 7002 7003 7004 7005 7006 7007 7008 7009 7010 7011 7012 7013 7014 7015 7016 7017 7018 7019 7020 7021 7022 7023
    }
  }

  /*
    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
7024
      goto err;
7025 7026 7027 7028 7029 7030 7031 7032 7033 7034 7035

    /*
      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
7036
      goto err;
7037 7038 7039 7040 7041 7042 7043 7044 7045

    /*
      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
7046 7047 7048 7049 7050
    /* 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. */

7051 7052 7053
    /* Change this table reference to become a leaf for name resolution. */
    if (left_neighbor)
    {
7054
      TABLE_LIST *last_leaf_on_the_left;
7055 7056 7057 7058 7059
      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)
    {
7060
      TABLE_LIST *first_leaf_on_the_right;
7061 7062 7063 7064 7065 7066
      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
7067 7068 7069 7070
  result= FALSE; /* All is OK. */

err:
  if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7071
    thd->restore_active_arena(arena, &backup);
timour@mysql.com's avatar
timour@mysql.com committed
7072
  DBUG_RETURN(result);
7073 7074 7075 7076 7077 7078 7079 7080 7081 7082 7083 7084 7085 7086 7087 7088 7089 7090 7091 7092 7093 7094 7095 7096
}


/*
  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
7097 7098
    TRUE   Error
    FALSE  OK
7099
*/
7100 7101
static bool setup_natural_join_row_types(THD *thd,
                                         List<TABLE_LIST> *from_clause,
7102 7103 7104 7105 7106 7107 7108 7109 7110
                                         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. */
7111
  TABLE_LIST *left_neighbor;
7112 7113 7114
  /* Table reference to the right of the current. */
  TABLE_LIST *right_neighbor= NULL;

7115 7116
  /* Note that tables in the list are in reversed order */
  for (left_neighbor= table_ref_it++; left_neighbor ; )
7117 7118 7119
  {
    table_ref= left_neighbor;
    left_neighbor= table_ref_it++;
7120 7121
    /* For stored procedures do not redo work if already done. */
    if (context->select_lex->first_execution)
7122
    {
7123 7124 7125 7126 7127 7128 7129 7130 7131
      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;
      }
7132 7133 7134 7135 7136 7137 7138
    }
    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
7139
    right_neighbor points to the left-most top-level table reference in the
7140 7141 7142 7143 7144 7145 7146 7147 7148 7149
    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
7150
/****************************************************************************
7151
** Expand all '*' in given fields
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7152 7153
****************************************************************************/

7154 7155 7156
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
7157
{
7158
  if (!wild_num)
7159
    return(0);
7160

7161
  Item *item;
7162
  List_iterator<Item> it(fields);
serg@serg.mylan's avatar
serg@serg.mylan committed
7163
  Query_arena *arena, backup;
7164
  DBUG_ENTER("setup_wild");
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7165 7166

  /*
7167 7168
    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
7169
  */
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7170
  arena= thd->activate_stmt_arena_if_needed(&backup);
7171

7172
  thd->lex->current_select->cur_pos_in_select_list= 0;
monty@mysql.com's avatar
monty@mysql.com committed
7173
  while (wild_num && (item= it++))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7174
  {
7175 7176
    if (item->type() == Item::FIELD_ITEM &&
        ((Item_field*) item)->field_name &&
7177 7178
	((Item_field*) item)->field_name[0] == '*' &&
	!((Item_field*) item)->field)
7179
    {
7180
      uint elem= fields.elements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7181
      bool any_privileges= ((Item_field *) item)->any_privileges;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7182 7183 7184 7185 7186 7187 7188 7189 7190
      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.
        */
7191 7192
        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
7193
      }
7194 7195
      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
7196
                             ((Item_field*) item)->table_name, &it,
7197
                             any_privileges))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7198 7199
      {
	if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7200
	  thd->restore_active_arena(arena, &backup);
7201
	DBUG_RETURN(-1);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7202
      }
7203
      if (sum_func_list)
7204 7205 7206 7207 7208 7209 7210 7211
      {
	/*
	  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;
      }
7212
      wild_num--;
7213
    }
7214 7215
    else
      thd->lex->current_select->cur_pos_in_select_list++;
7216
  }
7217
  thd->lex->current_select->cur_pos_in_select_list= UNDEF_POS;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7218 7219 7220 7221 7222 7223 7224
  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
7225
    thd->restore_active_arena(arena, &backup);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7226
  }
7227
  DBUG_RETURN(0);
7228 7229
}

7230 7231 7232 7233
/****************************************************************************
** Check that all given fields exists and fill struct with current data
****************************************************************************/

7234
bool setup_fields(THD *thd, Item **ref_pointer_array,
7235
                  List<Item> &fields, enum_mark_columns mark_used_columns,
7236
                  List<Item> *sum_func_list, bool allow_sum_func)
7237 7238
{
  reg2 Item *item;
7239
  enum_mark_columns save_mark_used_columns= thd->mark_used_columns;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7240
  nesting_map save_allow_sum_func= thd->lex->allow_sum_func;
7241
  List_iterator<Item> it(fields);
7242
  bool save_is_item_list_lookup;
7243 7244
  DBUG_ENTER("setup_fields");

7245 7246
  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
7247 7248
  if (allow_sum_func)
    thd->lex->allow_sum_func|= 1 << thd->lex->current_select->nest_level;
7249
  thd->where= THD::DEFAULT_WHERE;
7250 7251
  save_is_item_list_lookup= thd->lex->current_select->is_item_list_lookup;
  thd->lex->current_select->is_item_list_lookup= 0;
7252

7253 7254 7255 7256 7257 7258 7259 7260 7261 7262 7263 7264 7265 7266
  /*
    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);

7267
  Item **ref= ref_pointer_array;
7268
  thd->lex->current_select->cur_pos_in_select_list= 0;
7269
  while ((item= it++))
7270
  {
7271
    if (!item->fixed && item->fix_fields(thd, it.ref()) ||
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7272
	(item= *(it.ref()))->check_cols(1))
7273
    {
7274
      thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7275
      thd->lex->allow_sum_func= save_allow_sum_func;
7276 7277
      thd->mark_used_columns= save_mark_used_columns;
      DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
7278
      DBUG_RETURN(TRUE); /* purecov: inspected */
7279
    }
7280 7281
    if (ref)
      *(ref++)= item;
7282 7283
    if (item->with_sum_func && item->type() != Item::SUM_FUNC_ITEM &&
	sum_func_list)
7284
      item->split_sum_func(thd, ref_pointer_array, *sum_func_list);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7285
    thd->used_tables|= item->used_tables();
7286
    thd->lex->current_select->cur_pos_in_select_list++;
7287
  }
7288
  thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
7289 7290
  thd->lex->current_select->cur_pos_in_select_list= UNDEF_POS;

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7291
  thd->lex->allow_sum_func= save_allow_sum_func;
7292 7293
  thd->mark_used_columns= save_mark_used_columns;
  DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
7294
  DBUG_RETURN(test(thd->is_error()));
7295
}
7296

7297

7298 7299 7300 7301 7302 7303 7304 7305 7306 7307 7308 7309 7310 7311 7312
/*
  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)
  {
7313 7314 7315 7316 7317 7318
    if (table->merge_underlying_list)
    {
      DBUG_ASSERT(table->view &&
                  table->effective_algorithm == VIEW_ALGORITHM_MERGE);
      list= make_leaves_list(list, table->merge_underlying_list);
    }
7319 7320 7321 7322 7323 7324 7325 7326 7327
    else
    {
      *list= table;
      list= &table->next_leaf;
    }
  }
  return list;
}

7328
/*
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7329 7330 7331 7332
  prepare tables

  SYNOPSIS
    setup_tables()
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7333
    thd		  Thread handler
7334
    context       name resolution contest to setup table list there
7335 7336 7337
    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
7338 7339
    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
7340

monty@mysql.com's avatar
monty@mysql.com committed
7341 7342
  NOTE
    Check also that the 'used keys' and 'ignored keys' exists and set up the
7343 7344 7345 7346
    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.
7347

monty@mysql.com's avatar
monty@mysql.com committed
7348 7349
    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
7350

monty@mysql.com's avatar
monty@mysql.com committed
7351
  RETURN
7352
    FALSE ok;  In this case *map will includes the chosen index
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7353
    TRUE  error
7354 7355
*/

7356
bool setup_tables(THD *thd, Name_resolution_context *context,
7357
                  List<TABLE_LIST> *from_clause, TABLE_LIST *tables,
7358
                  TABLE_LIST **leaves, bool select_insert)
7359
{
monty@mysql.com's avatar
monty@mysql.com committed
7360
  uint tablenr= 0;
7361
  DBUG_ENTER("setup_tables");
7362

7363 7364
  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
7365 7366
  /*
    this is used for INSERT ... SELECT.
7367
    For select we setup tables except first (and its underlying tables)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7368 7369 7370 7371
  */
  TABLE_LIST *first_select_table= (select_insert ?
                                   tables->next_local:
                                   0);
7372 7373 7374
  if (!(*leaves))
    make_leaves_list(leaves, tables);

7375 7376
  TABLE_LIST *table_list;
  for (table_list= *leaves;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7377
       table_list;
7378
       table_list= table_list->next_leaf, tablenr++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7379
  {
7380
    TABLE *table= table_list->table;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7381
    table->pos_in_table_list= table_list;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7382
    if (first_select_table &&
7383
        table_list->top_table() == first_select_table)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7384 7385 7386 7387 7388
    {
      /* new counting for SELECT of INSERT ... SELECT command */
      first_select_table= 0;
      tablenr= 0;
    }
7389
    setup_table_map(table, table_list, tablenr);
7390 7391
    if (table_list->process_index_hints(table))
      DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7392 7393 7394 7395
  }
  if (tablenr > MAX_TABLES)
  {
    my_error(ER_TOO_MANY_TABLES,MYF(0),MAX_TABLES);
7396
    DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7397
  }
7398
  for (table_list= tables;
7399 7400
       table_list;
       table_list= table_list->next_local)
7401
  {
7402
    if (table_list->merge_underlying_list)
7403
    {
7404 7405
      DBUG_ASSERT(table_list->view &&
                  table_list->effective_algorithm == VIEW_ALGORITHM_MERGE);
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7406
      Query_arena *arena= thd->stmt_arena, backup;
7407 7408 7409 7410
      bool res;
      if (arena->is_conventional())
        arena= 0;                                   // For easier test
      else
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7411
        thd->set_n_backup_active_arena(arena, &backup);
7412
      res= table_list->setup_underlying(thd);
7413
      if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7414
        thd->restore_active_arena(arena, &backup);
7415 7416 7417
      if (res)
        DBUG_RETURN(1);
    }
7418
  }
7419 7420 7421 7422 7423

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

7424
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7425
}
7426

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

7428 7429 7430 7431 7432 7433 7434 7435 7436 7437 7438 7439 7440 7441 7442 7443 7444 7445 7446 7447 7448 7449 7450 7451 7452 7453 7454
/*
  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
7455
                                   TABLE_LIST **leaves,
7456
                                   bool select_insert,
7457
                                   ulong want_access_first,
7458 7459
                                   ulong want_access)
{
monty@mysql.com's avatar
monty@mysql.com committed
7460
  TABLE_LIST *leaves_tmp= NULL;
7461
  bool first_table= true;
7462

monty@mysql.com's avatar
monty@mysql.com committed
7463 7464
  if (setup_tables(thd, context, from_clause, tables,
                   &leaves_tmp, select_insert))
7465 7466
    return TRUE;

7467 7468
  if (leaves)
    *leaves= leaves_tmp;
7469 7470

  for (; leaves_tmp; leaves_tmp= leaves_tmp->next_leaf)
monty@mysql.com's avatar
monty@mysql.com committed
7471
  {
7472
    if (leaves_tmp->belong_to_view && 
7473
        check_single_table_access(thd, first_table ? want_access_first :
7474
                                  want_access, leaves_tmp, FALSE))
7475 7476 7477 7478
    {
      tables->hide_view_error(thd);
      return TRUE;
    }
7479
    first_table= 0;
monty@mysql.com's avatar
monty@mysql.com committed
7480
  }
7481 7482 7483 7484
  return FALSE;
}


7485 7486 7487 7488 7489 7490 7491 7492 7493 7494 7495 7496 7497 7498 7499
/*
   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,
7500
                               List<String> *index_list)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7501
{
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
7502
  List_iterator_fast<String> it(*index_list);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7503 7504
  String *name;
  uint pos;
7505 7506

  map->clear_all();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7507 7508
  while ((name=it++))
  {
7509 7510 7511
    if (table->s->keynames.type_names == 0 ||
        (pos= find_type(&table->s->keynames, name->ptr(),
                        name->length(), 1)) <=
7512
        0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7513
    {
7514
      my_error(ER_KEY_DOES_NOT_EXITS, MYF(0), name->c_ptr(),
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7515
	       table->pos_in_table_list->alias);
7516
      map->set_all();
7517
      return 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7518
    }
7519
    map->set_bit(pos-1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7520
  }
7521
  return 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7522 7523
}

7524

7525 7526 7527 7528 7529 7530
/*
  Drops in all fields instead of current '*' field

  SYNOPSIS
    insert_fields()
    thd			Thread handler
7531
    context             Context for name resolution
7532 7533 7534 7535 7536 7537 7538
    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
7539
    0	ok     'it' is updated to point at last inserted
monty@mysql.com's avatar
monty@mysql.com committed
7540
    1	error.  Error message is generated but not sent to client
7541
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7542

sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
7543
bool
7544
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
7545
	      const char *table_name, List_iterator<Item> *it,
7546
              bool any_privileges)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7547
{
7548 7549
  Field_iterator_table_ref field_iterator;
  bool found;
monty@mysql.com's avatar
monty@mysql.com committed
7550
  char name_buff[NAME_LEN+1];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7551
  DBUG_ENTER("insert_fields");
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7552
  DBUG_PRINT("arena", ("stmt arena: 0x%lx", (ulong)thd->stmt_arena));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7553

7554 7555
  if (db_name && lower_case_table_names)
  {
monty@mysql.com's avatar
monty@mysql.com committed
7556 7557 7558 7559 7560
    /*
      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
7561
    strmake(name_buff, db_name, sizeof(name_buff)-1);
monty@mysql.com's avatar
monty@mysql.com committed
7562
    my_casedn_str(files_charset_info, name_buff);
monty@mysql.com's avatar
monty@mysql.com committed
7563
    db_name= name_buff;
7564 7565
  }

7566
  found= FALSE;
7567 7568 7569 7570 7571 7572 7573 7574

  /*
    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);
7575
       tables;
7576 7577 7578
       tables= (table_name ? tables->next_local :
                tables->next_name_resolution_table)
       )
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7579
  {
7580 7581 7582
    Field *field;
    TABLE *table= tables->table;

7583 7584
    DBUG_ASSERT(tables->is_leaf_for_name_resolution());

7585 7586 7587 7588
    if (table_name && my_strcasecmp(table_alias_charset, table_name,
                                    tables->alias) ||
        (db_name && strcmp(tables->db,db_name)))
      continue;
7589

hf@deer.(none)'s avatar
hf@deer.(none) committed
7590
#ifndef NO_EMBEDDED_ACCESS_CHECKS
7591 7592 7593 7594 7595 7596
    /* Ensure that we have access rights to all fields to be inserted. */
    if (!((table && (table->grant.privilege & SELECT_ACL) ||
           tables->view && (tables->grant.privilege & SELECT_ACL))) &&
        !any_privileges)
    {
      field_iterator.set(tables);
7597
      if (check_grant_all_columns(thd, SELECT_ACL, &field_iterator))
7598 7599
        DBUG_RETURN(TRUE);
    }
hf@deer.(none)'s avatar
hf@deer.(none) committed
7600
#endif
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7601

7602 7603 7604 7605 7606 7607 7608 7609 7610 7611 7612 7613 7614 7615 7616 7617 7618 7619 7620 7621 7622 7623 7624
    /*
      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)
7625
      {
7626
        found= TRUE;
7627
        it->replace(item); /* Replace '*' with the first found item. */
7628
      }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7629
      else
7630 7631 7632 7633 7634 7635 7636
        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,
7637 7638 7639
        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.
7640 7641
      */
      if (any_privileges)
7642
      {
7643 7644 7645 7646
        DBUG_ASSERT(tables->field_translation == NULL && table ||
                    tables->is_natural_join);
        DBUG_ASSERT(item->type() == Item::FIELD_ITEM);
        Item_field *fld= (Item_field*) item;
7647
        const char *field_table_name= field_iterator.table_name();
7648

7649 7650 7651 7652
        if (!tables->schema_table && 
            !(fld->have_privileges=
              (get_column_grant(thd, field_iterator.grant(),
                                field_iterator.db_name(),
7653
                                field_table_name, fld->field_name) &
7654 7655 7656
               VIEW_ANY_ACL)))
        {
          my_error(ER_COLUMNACCESS_DENIED_ERROR, MYF(0), "ANY",
7657 7658
                   thd->security_ctx->priv_user,
                   thd->security_ctx->host_or_ip,
7659
                   fld->field_name, field_table_name);
7660 7661
          DBUG_RETURN(TRUE);
        }
7662
      }
7663
#endif
7664

7665
      if ((field= field_iterator.field()))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7666
      {
7667 7668
        /* Mark fields as used to allow storage engine to optimze access */
        bitmap_set_bit(field->table->read_set, field->field_index);
7669
        if (table)
7670
        {
7671
          table->covering_keys.intersect(field->part_of_key);
7672 7673
          table->merge_keys.merge(field->part_of_key);
        }
7674
        if (tables->is_natural_join)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7675
        {
7676 7677
          TABLE *field_table;
          /*
7678
            In this case we are sure that the column ref will not be created
7679
            because it was already created and stored with the natural join.
7680
          */
7681
          Natural_join_column *nj_col;
timour@mysql.com's avatar
timour@mysql.com committed
7682
          if (!(nj_col= field_iterator.get_natural_column_ref()))
7683
            DBUG_RETURN(TRUE);
timour@mysql.com's avatar
timour@mysql.com committed
7684
          DBUG_ASSERT(nj_col->table_field);
7685 7686
          field_table= nj_col->table_ref->table;
          if (field_table)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7687
          {
7688
            thd->used_tables|= field_table->map;
7689
            field_table->covering_keys.intersect(field->part_of_key);
7690
            field_table->merge_keys.merge(field->part_of_key);
7691
            field_table->used_fields++;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7692
          }
7693
        }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7694
      }
7695 7696
      else
        thd->used_tables|= item->used_tables();
7697
      thd->lex->current_select->cur_pos_in_select_list++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7698
    }
7699 7700 7701 7702 7703 7704 7705 7706
    /*
      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
7707
  }
7708
  if (found)
7709
    DBUG_RETURN(FALSE);
7710

7711
  /*
7712 7713 7714
    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.
7715
  */
7716
  if (!table_name)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7717
    my_message(ER_NO_TABLES_USED, ER(ER_NO_TABLES_USED), MYF(0));
7718 7719
  else
    my_error(ER_BAD_TABLE_ERROR, MYF(0), table_name);
7720 7721

  DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7722 7723 7724 7725
}


/*
7726
  Fix all conditions and outer join expressions.
7727 7728 7729 7730

  SYNOPSIS
    setup_conds()
    thd     thread handler
7731 7732 7733 7734 7735 7736 7737 7738 7739 7740
    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
7741 7742
*/

7743 7744
int setup_conds(THD *thd, TABLE_LIST *tables, TABLE_LIST *leaves,
                COND **conds)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7745
{
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7746
  SELECT_LEX *select_lex= thd->lex->current_select;
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7747
  Query_arena *arena= thd->stmt_arena, backup;
pem@mysql.comhem.se's avatar
pem@mysql.comhem.se committed
7748
  TABLE_LIST *table= NULL;	// For HP compilers
7749 7750 7751 7752 7753 7754 7755 7756 7757 7758
  /*
    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();
7759 7760
  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
7761
  DBUG_ENTER("setup_conds");
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7762

monty@mysql.com's avatar
monty@mysql.com committed
7763
  if (select_lex->conds_processed_with_permanent_arena ||
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7764
      arena->is_conventional())
monty@mysql.com's avatar
monty@mysql.com committed
7765 7766
    arena= 0;                                   // For easier test

7767 7768
  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
7769
  select_lex->cond_count= 0;
7770
  select_lex->between_count= 0;
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
7771
  select_lex->max_equal_elems= 0;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7772

7773 7774 7775 7776 7777 7778
  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
7779 7780 7781
  if (*conds)
  {
    thd->where="where clause";
7782
    if (!(*conds)->fixed && (*conds)->fix_fields(thd, conds) ||
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7783
	(*conds)->check_cols(1))
7784
      goto err_no_arena;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7785 7786
  }

7787 7788 7789 7790
  /*
    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
7791
  for (table= leaves; table; table= table->next_leaf)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7792
  {
7793 7794
    TABLE_LIST *embedded; /* The table at the current level of nesting. */
    TABLE_LIST *embedding= table; /* The parent nested table reference. */
7795
    do
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7796
    {
7797 7798
      embedded= embedding;
      if (embedded->on_expr)
7799
      {
7800 7801
        /* Make a join an a expression */
        thd->where="on clause";
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7802
        if (!embedded->on_expr->fixed &&
7803
            embedded->on_expr->fix_fields(thd, &embedded->on_expr) ||
7804
	    embedded->on_expr->check_cols(1))
7805
	  goto err_no_arena;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7806
        select_lex->cond_count++;
7807
      }
7808
      embedding= embedded->embedding;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7809
    }
7810 7811
    while (embedding &&
           embedding->nested_join->join_list.head() == embedded);
7812 7813 7814 7815

    /* process CHECK OPTION */
    if (it_is_update)
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7816
      TABLE_LIST *view= table->top_table();
7817 7818 7819 7820 7821 7822 7823
      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
7824
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7825

konstantin@mysql.com's avatar
konstantin@mysql.com committed
7826
  if (!thd->stmt_arena->is_conventional())
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7827 7828 7829 7830 7831 7832 7833 7834 7835 7836
  {
    /*
      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;
  }
7837
  thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
7838
  DBUG_RETURN(test(thd->is_error()));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7839

7840
err_no_arena:
7841
  select_lex->is_item_list_lookup= save_is_item_list_lookup;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7842
  DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7843 7844 7845 7846 7847 7848 7849 7850
}


/******************************************************************************
** 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
7851 7852 7853 7854 7855 7856 7857 7858 7859 7860 7861

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

7862 7863 7864 7865 7866
  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
7867 7868 7869 7870 7871
  RETURN
    FALSE   OK
    TRUE    error occured
*/

7872
static bool
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7873 7874
fill_record(THD * thd, List<Item> &fields, List<Item> &values,
            bool ignore_errors)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7875
{
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
7876
  List_iterator_fast<Item> f(fields),v(values);
7877
  Item *value, *fld;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7878
  Item_field *field;
7879
  TABLE *table= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7880 7881
  DBUG_ENTER("fill_record");

7882 7883 7884 7885 7886 7887 7888 7889 7890 7891 7892 7893 7894 7895 7896 7897 7898 7899 7900 7901
  /*
    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();
  }
7902
  while ((fld= f++))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7903
  {
7904 7905 7906
    if (!(field= fld->filed_for_view_update()))
    {
      my_error(ER_NONUPDATEABLE_COLUMN, MYF(0), fld->name);
7907
      goto err;
7908
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7909
    value=v++;
7910
    Field *rfield= field->field;
7911
    table= rfield->table;
7912
    if (rfield == table->next_number_field)
7913
      table->auto_increment_field_not_null= TRUE;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7914
    if ((value->save_in_field(rfield, 0) < 0) && !ignore_errors)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7915 7916
    {
      my_message(ER_UNKNOWN_ERROR, ER(ER_UNKNOWN_ERROR), MYF(0));
7917
      goto err;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7918
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7919
  }
7920
  DBUG_RETURN(thd->is_error());
7921 7922 7923 7924
err:
  if (table)
    table->auto_increment_field_not_null= FALSE;
  DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7925 7926 7927
}


7928 7929 7930 7931 7932 7933 7934 7935 7936 7937 7938 7939 7940 7941 7942 7943 7944 7945 7946 7947 7948 7949 7950 7951 7952 7953 7954 7955 7956 7957 7958 7959 7960 7961 7962
/*
  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
7963 7964 7965 7966 7967 7968 7969 7970 7971 7972
/*
  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

7973 7974 7975 7976 7977
  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
7978 7979 7980 7981 7982 7983 7984
  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
7985
{
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
7986
  List_iterator_fast<Item> v(values);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7987
  Item *value;
7988
  TABLE *table= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7989 7990 7991
  DBUG_ENTER("fill_record");

  Field *field;
7992 7993 7994 7995 7996 7997 7998 7999 8000 8001 8002 8003 8004
  /*
    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;
  }
8005
  while ((field = *ptr++) && ! thd->is_error())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8006 8007
  {
    value=v++;
8008
    table= field->table;
8009
    if (field == table->next_number_field)
8010
      table->auto_increment_field_not_null= TRUE;
8011
    if (value->save_in_field(field, 0) < 0)
8012
      goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8013
  }
8014
  DBUG_RETURN(thd->is_error());
8015 8016 8017 8018 8019

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


8023 8024 8025 8026 8027 8028 8029 8030 8031 8032 8033 8034 8035 8036 8037 8038 8039 8040 8041 8042 8043 8044 8045 8046 8047 8048 8049 8050 8051 8052 8053 8054 8055 8056 8057
/*
  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));
}


8058
my_bool mysql_rm_tmp_tables(void)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8059
{
8060
  uint i, idx;
8061
  char	filePath[FN_REFLEN], *tmpdir, filePathCopy[FN_REFLEN];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8062 8063
  MY_DIR *dirp;
  FILEINFO *file;
8064
  TABLE_SHARE share;
8065
  THD *thd;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8066 8067
  DBUG_ENTER("mysql_rm_tmp_tables");

8068 8069
  if (!(thd= new THD))
    DBUG_RETURN(1);
8070
  thd->thread_stack= (char*) &thd;
8071 8072
  thd->store_globals();

8073 8074 8075
  for (i=0; i<=mysql_tmpdir_list.max; i++)
  {
    tmpdir=mysql_tmpdir_list.list[i];
8076
    /* See if the directory exists */
8077 8078
    if (!(dirp = my_dir(tmpdir,MYF(MY_WME | MY_DONT_SORT))))
      continue;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8079

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

8082 8083 8084
    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
8085

8086 8087 8088 8089
      /* 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
8090

8091 8092
      if (!bcmp((uchar*) file->name, (uchar*) tmp_file_prefix,
                tmp_file_prefix_length))
8093
      {
8094 8095 8096 8097 8098
        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);
8099
        if (!bcmp((uchar*) reg_ext, (uchar*) ext, ext_len))
8100
        {
8101 8102 8103 8104
          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;
8105
          init_tmp_table_share(thd, &share, "", 0, "", filePathCopy);
8106 8107
          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
8108
                                              share.db_type()))))
8109
          {
8110
            handler_file->ha_delete_table(filePathCopy);
8111 8112 8113
            delete handler_file;
          }
          free_table_share(&share);
8114
        }
8115 8116 8117 8118 8119 8120
        /*
          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))); 
8121
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8122
    }
8123
    my_dirend(dirp);
8124
  }
8125 8126 8127
  delete thd;
  my_pthread_setspecific_ptr(THR_THD,  0);
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8128 8129 8130 8131 8132 8133 8134 8135 8136
}



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

/*
8137 8138 8139 8140 8141 8142 8143 8144 8145 8146
  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
8147 8148
*/

8149
void remove_db_from_cache(const char *db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8150 8151 8152 8153
{
  for (uint idx=0 ; idx < open_cache.records ; idx++)
  {
    TABLE *table=(TABLE*) hash_element(&open_cache,idx);
8154
    if (!strcmp(table->s->db.str, db))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8155
    {
8156
      table->s->version= 0L;			/* Free when thread is ready */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8157 8158 8159 8160
      if (!table->in_use)
	relink_unused(table);
    }
  }
8161
  while (unused_tables && !unused_tables->s->version)
8162
    VOID(hash_delete(&open_cache,(uchar*) unused_tables));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8163 8164 8165 8166
}


/*
8167 8168 8169 8170 8171
  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
8172 8173 8174 8175 8176 8177
*/

void flush_tables()
{
  (void) pthread_mutex_lock(&LOCK_open);
  while (unused_tables)
8178
    hash_delete(&open_cache,(uchar*) unused_tables);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8179 8180 8181 8182 8183
  (void) pthread_mutex_unlock(&LOCK_open);
}


/*
8184 8185 8186 8187 8188
  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
8189 8190 8191
  PREREQUISITES
    Lock on LOCK_open()

8192 8193 8194 8195
  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
8196 8197
*/

8198
bool remove_table_from_cache(THD *thd, const char *db, const char *table_name,
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8199
                             uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8200 8201 8202 8203
{
  char key[MAX_DBKEY_LENGTH];
  uint key_length;
  TABLE *table;
8204 8205
  TABLE_SHARE *share;
  bool result= 0, signalled= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8206
  DBUG_ENTER("remove_table_from_cache");
8207
  DBUG_PRINT("enter", ("table: '%s'.'%s'  flags: %u", db, table_name, flags));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8208 8209

  key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
8210
  for (;;)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8211
  {
8212
    HASH_SEARCH_STATE state;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8213 8214
    result= signalled= 0;

8215
    for (table= (TABLE*) hash_first(&open_cache, (uchar*) key, key_length,
8216
                                    &state);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8217
         table;
8218
         table= (TABLE*) hash_next(&open_cache, (uchar*) key, key_length,
8219
                                   &state))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8220
    {
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8221
      THD *in_use;
8222 8223
      DBUG_PRINT("tcache", ("found table: '%s'.'%s' 0x%lx", table->s->db.str,
                            table->s->table_name.str, (long) table));
8224

8225
      table->s->version=0L;		/* Free when thread is ready */
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8226
      if (!(in_use=table->in_use))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8227
      {
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8228 8229
        DBUG_PRINT("info",("Table was not in use"));
        relink_unused(table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8230
      }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8231
      else if (in_use != thd)
8232
      {
8233
        DBUG_PRINT("info", ("Table was in use by other thread"));
8234 8235 8236 8237 8238 8239
        /*
          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
8240
        if (table->is_name_opened())
monty@mysql.com's avatar
monty@mysql.com committed
8241 8242
        {
          DBUG_PRINT("info", ("Found another active instance of the table"));
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8243
  	  result=1;
monty@mysql.com's avatar
monty@mysql.com committed
8244
        }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8245 8246 8247 8248
        /* Kill delayed insert threads */
        if ((in_use->system_thread & SYSTEM_THREAD_DELAYED_INSERT) &&
            ! in_use->killed)
        {
8249
	  in_use->killed= THD::KILL_CONNECTION;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8250 8251 8252 8253 8254 8255 8256 8257 8258 8259 8260 8261
	  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
8262 8263 8264 8265 8266 8267
	  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
8268 8269 8270 8271 8272
        */
        for (TABLE *thd_table= in_use->open_tables;
	     thd_table ;
	     thd_table= thd_table->next)
        {
8273 8274
          /* Do not handle locks of MERGE children. */
	  if (thd_table->db_stat && !thd_table->parent)	// If table is open
8275
	    signalled|= mysql_lock_abort_for_thread(thd, thd_table);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8276
        }
8277
      }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8278
      else
8279 8280 8281
      {
        DBUG_PRINT("info", ("Table was in use by current thread. db_stat: %u",
                            table->db_stat));
8282
        result= result || (flags & RTFC_OWNED_BY_THD_FLAG);
8283
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8284
    }
8285
    while (unused_tables && !unused_tables->s->version)
8286
      VOID(hash_delete(&open_cache,(uchar*) unused_tables));
8287 8288 8289

    DBUG_PRINT("info", ("Removing table from table_def_cache"));
    /* Remove table from table definition cache if it's not in use */
8290
    if ((share= (TABLE_SHARE*) hash_search(&table_def_cache,(uchar*) key,
8291 8292 8293 8294 8295 8296 8297 8298
                                           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);
8299
        VOID(hash_delete(&table_def_cache, (uchar*) share));
8300 8301 8302
      }
    }

8303
    if (result && (flags & RTFC_WAIT_OTHER_THREAD_FLAG))
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8304
    {
monty@mysql.com's avatar
monty@mysql.com committed
8305 8306 8307 8308
      /*
        Signal any thread waiting for tables to be freed to
        reopen their tables
      */
8309
      broadcast_refresh();
monty@mysql.com's avatar
monty@mysql.com committed
8310
      DBUG_PRINT("info", ("Waiting for refresh signal"));
8311
      if (!(flags & RTFC_CHECK_KILLED_FLAG) || !thd->killed)
8312
      {
monty@mysql.com's avatar
monty@mysql.com committed
8313
        dropping_tables++;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8314 8315 8316 8317
        if (likely(signalled))
          (void) pthread_cond_wait(&COND_refresh, &LOCK_open);
        else
        {
monty@mysql.com's avatar
monty@mysql.com committed
8318
          struct timespec abstime;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8319 8320 8321 8322 8323 8324 8325 8326 8327 8328
          /*
            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
8329 8330
          set_timespec(abstime, 10);
          pthread_cond_timedwait(&COND_refresh, &LOCK_open, &abstime);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8331
        }
monty@mysql.com's avatar
monty@mysql.com committed
8332 8333
        dropping_tables--;
        continue;
8334
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8335
    }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8336
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8337 8338 8339 8340
  }
  DBUG_RETURN(result);
}

8341

8342
int setup_ftfuncs(SELECT_LEX *select_lex)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8343
{
8344 8345
  List_iterator<Item_func_match> li(*(select_lex->ftfunc_list)),
                                 lj(*(select_lex->ftfunc_list));
8346
  Item_func_match *ftf, *ftf2;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8347 8348

  while ((ftf=li++))
8349
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8350 8351
    if (ftf->fix_index())
      return 1;
8352 8353
    lj.rewind();
    while ((ftf2=lj++) != ftf)
8354
    {
8355
      if (ftf->eq(ftf2,1) && !ftf2->master)
8356 8357 8358
        ftf2->master=ftf;
    }
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8359 8360 8361

  return 0;
}
8362

8363

8364
int init_ftfuncs(THD *thd, SELECT_LEX *select_lex, bool no_order)
8365
{
8366
  if (select_lex->ftfunc_list->elements)
8367
  {
8368
    List_iterator<Item_func_match> li(*(select_lex->ftfunc_list));
8369 8370
    Item_func_match *ifm;
    DBUG_PRINT("info",("Performing FULLTEXT search"));
8371
    thd_proc_info(thd, "FULLTEXT initialization");
8372

8373 8374 8375
    while ((ifm=li++))
      ifm->init_search(no_order);
  }
8376 8377
  return 0;
}
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8378 8379 8380 8381 8382 8383 8384


/*
  open new .frm format table

  SYNOPSIS
    open_new_frm()
8385
    THD		  thread handler
8386
    path	  path to .frm file (without extension)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8387
    alias	  alias for table
8388 8389
    db            database
    table_name    name of table
8390
    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
8391 8392 8393 8394 8395 8396 8397
		  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
*/
8398

8399
static bool
8400
open_new_frm(THD *thd, TABLE_SHARE *share, const char *alias,
8401
             uint db_stat, uint prgflag,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8402 8403 8404 8405
	     uint ha_open_flags, TABLE *outparam, TABLE_LIST *table_desc,
	     MEM_ROOT *mem_root)
{
  LEX_STRING pathstr;
8406
  File_parser *parser;
8407
  char path[FN_REFLEN];
8408 8409
  DBUG_ENTER("open_new_frm");

8410 8411 8412 8413
  /* Create path with extension */
  pathstr.length= (uint) (strxmov(path, share->normalized_path.str, reg_ext,
                                  NullS)- path);
  pathstr.str=    path;
8414

8415
  if ((parser= sql_parse_prepare(&pathstr, mem_root, 1)))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8416
  {
8417
    if (is_equal(&view_type, parser->type()))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8418
    {
8419
      if (table_desc == 0 || table_desc->required_type == FRMTYPE_TABLE)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8420
      {
8421 8422
        my_error(ER_WRONG_OBJECT, MYF(0), share->db.str, share->table_name.str,
                 "BASE TABLE");
8423
        goto err;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8424
      }
8425 8426
      if (mysql_make_view(thd, parser, table_desc,
                          (prgflag & OPEN_VIEW_NO_PARSE)))
8427
        goto err;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8428 8429 8430 8431
    }
    else
    {
      /* only VIEWs are supported now */
8432
      my_error(ER_FRM_UNKNOWN_TYPE, MYF(0), share->path.str,  parser->type()->str);
8433
      goto err;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8434
    }
8435
    DBUG_RETURN(0);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8436
  }
monty@mysql.com's avatar
monty@mysql.com committed
8437
 
8438 8439 8440
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
8441
}
8442 8443 8444 8445 8446 8447


bool is_equal(const LEX_STRING *a, const LEX_STRING *b)
{
  return a->length == b->length && !strncmp(a->str, b->str, a->length);
}
8448 8449 8450 8451 8452 8453 8454


/*
  SYNOPSIS
    abort_and_upgrade_lock()
    lpt                           Parameter passing struct
    All parameters passed through the ALTER_PARTITION_PARAM_TYPE object
8455 8456
  RETURN VALUE
    0
8457 8458 8459 8460 8461 8462 8463 8464 8465 8466 8467 8468 8469
  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
*/

8470
int abort_and_upgrade_lock(ALTER_PARTITION_PARAM_TYPE *lpt)
8471 8472 8473 8474 8475 8476
{
  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));
8477 8478 8479
  /* If MERGE child, forward lock handling to parent. */
  mysql_lock_abort(lpt->thd, lpt->table->parent ? lpt->table->parent :
                   lpt->table, TRUE);
8480 8481
  VOID(remove_table_from_cache(lpt->thd, lpt->db, lpt->table_name, flags));
  VOID(pthread_mutex_unlock(&LOCK_open));
8482
  DBUG_RETURN(0);
8483 8484 8485 8486 8487 8488 8489 8490 8491 8492 8493 8494 8495 8496 8497 8498 8499
}


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

8500
/* purecov: begin deadcode */
8501 8502 8503 8504 8505 8506
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));
8507 8508 8509
  /* 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);
8510
}
8511
/* purecov: end */
8512 8513 8514 8515 8516 8517 8518 8519 8520 8521 8522 8523 8524 8525 8526 8527 8528 8529 8530 8531 8532 8533 8534 8535 8536 8537 8538 8539 8540 8541 8542 8543 8544 8545 8546


/*
  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;
8547
  for (table= (TABLE*) hash_first(&open_cache,(uchar*) key,key_length,
8548 8549
                                  &state) ;
       table;
8550
       table= (TABLE*) hash_next(&open_cache,(uchar*) key,key_length,
8551 8552 8553 8554 8555 8556 8557 8558 8559 8560 8561 8562 8563 8564 8565 8566 8567 8568 8569 8570 8571 8572 8573 8574 8575 8576
                                 &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
8577 8578 8579 8580 8581 8582
        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.
8583 8584 8585 8586 8587
      */
      for (TABLE *thd_table= in_use->open_tables;
           thd_table ;
           thd_table= thd_table->next)
      {
8588 8589
        /* Do not handle locks of MERGE children. */
        if (thd_table->db_stat && !thd_table->parent) // If table is open
8590 8591 8592 8593 8594 8595 8596 8597 8598
          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.
8599
    If MERGE child, forward lock handling to parent.
8600
  */
8601 8602
  mysql_lock_abort(lpt->thd, my_table->parent ? my_table->parent : my_table,
                   FALSE);
8603 8604 8605 8606
  VOID(pthread_mutex_unlock(&LOCK_open));
  DBUG_VOID_RETURN;
}

8607 8608 8609 8610 8611 8612 8613 8614 8615 8616 8617 8618 8619 8620 8621 8622 8623 8624 8625 8626 8627 8628 8629

/*
  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;
8630 8631
  LINT_INIT(first_db);

8632 8633 8634
  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
8635
    if (!table->placeholder() &&
8636 8637 8638 8639 8640 8641 8642 8643 8644 8645 8646 8647 8648 8649 8650 8651
        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;
}
8652 8653 8654 8655 8656 8657 8658 8659 8660 8661 8662 8663 8664 8665 8666 8667 8668 8669 8670 8671 8672 8673 8674 8675 8676 8677 8678 8679 8680 8681 8682 8683 8684 8685 8686 8687 8688 8689 8690 8691 8692 8693 8694


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

8695
    DBUG_ASSERT(table->s->table_category == TABLE_CATEGORY_SYSTEM);
8696 8697 8698 8699 8700 8701 8702 8703 8704 8705 8706 8707 8708 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 8752 8753 8754 8755 8756 8757 8758 8759 8760 8761

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

8762
  TABLE *table= open_ltable(thd, one_table, one_table->lock_type, 0);
8763 8764
  if (table)
  {
8765
    DBUG_ASSERT(table->s->table_category == TABLE_CATEGORY_SYSTEM);
8766 8767 8768 8769 8770
    table->use_all_columns();
  }

  DBUG_RETURN(table);
}
8771 8772 8773 8774 8775 8776 8777 8778 8779 8780 8781 8782 8783 8784 8785 8786

/**
  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)
{
8787 8788 8789 8790 8791 8792 8793
  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;
8794 8795 8796 8797
  DBUG_ENTER("open_performance_schema_table");

  thd->reset_n_backup_open_tables_state(backup);

8798
  if ((table= open_ltable(thd, one_table, one_table->lock_type, flags)))
8799 8800 8801
  {
    DBUG_ASSERT(table->s->table_category == TABLE_CATEGORY_PERFORMANCE);
    /* Make sure all columns get assigned to a default value */
8802
    table->use_all_columns();
8803
    table->no_replicate= 1;
8804 8805 8806 8807 8808
    /*
      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;
8809
  }
8810
  else
8811 8812 8813 8814 8815 8816 8817 8818 8819
  {
    /*
      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);
8820
    thd->restore_backup_open_tables_state(backup);
8821
  }
8822

8823
  thd->utime_after_lock= save_utime_after_lock;
8824 8825
  DBUG_RETURN(table);
}
8826 8827 8828 8829 8830 8831 8832 8833 8834 8835 8836 8837

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

8838 8839 8840 8841 8842
  /*
    If open_performance_schema_table() fails,
    this function should not be called.
  */
  DBUG_ASSERT(thd->lock != NULL);
8843

8844 8845 8846 8847 8848 8849 8850 8851 8852 8853 8854 8855 8856
  /*
    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;
8857 8858 8859 8860

  pthread_mutex_lock(&LOCK_open);

  found_old_table= false;
8861 8862 8863 8864 8865 8866 8867
  /*
    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.
  */
8868 8869 8870 8871 8872 8873 8874 8875 8876 8877 8878
  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);
}

8879 8880 8881
/**
  @} (end of group Data_Dictionary)
*/