sql_base.cc 193 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
2

unknown's avatar
unknown committed
3 4 5 6
   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
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
7

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

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


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

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

TABLE *unused_tables;				/* Used by mysql_test */
HASH open_cache;				/* Used by mysql_test */
unknown's avatar
unknown committed
34 35 36 37 38 39 40
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,
41
                             char *cache_key, uint cache_key_length,
unknown's avatar
unknown committed
42
			     MEM_ROOT *mem_root);
unknown's avatar
unknown committed
43 44
static void free_cache_entry(TABLE *entry);
static void mysql_rm_tmp_tables(void);
unknown's avatar
unknown committed
45
static bool open_new_frm(THD *thd, TABLE_SHARE *share, const char *alias,
46 47 48
                         uint db_stat, uint prgflag,
                         uint ha_open_flags, TABLE *outparam,
                         TABLE_LIST *table_desc, MEM_ROOT *mem_root);
unknown's avatar
unknown committed
49 50 51 52
static void close_old_data_files(THD *thd, TABLE *table, bool abort_locks,
                                 bool send_refresh);
static bool reopen_table(TABLE *table);

unknown's avatar
unknown committed
53

54 55
extern "C" byte *table_cache_key(const byte *record,uint *length,
				 my_bool not_used __attribute__((unused)))
unknown's avatar
unknown committed
56 57
{
  TABLE *entry=(TABLE*) record;
unknown's avatar
unknown committed
58 59
  *length= entry->s->table_cache_key.length;
  return (byte*) entry->s->table_cache_key.str;
unknown's avatar
unknown committed
60 61
}

unknown's avatar
unknown committed
62

unknown's avatar
unknown committed
63
bool table_cache_init(void)
unknown's avatar
unknown committed
64 65
{
  mysql_rm_tmp_tables();
unknown's avatar
unknown committed
66 67 68
  return hash_init(&open_cache, &my_charset_bin, table_cache_size+16,
		   0, 0,table_cache_key,
		   (hash_free_key) free_cache_entry, 0) != 0;
unknown's avatar
unknown committed
69 70 71 72 73
}

void table_cache_free(void)
{
  DBUG_ENTER("table_cache_free");
unknown's avatar
unknown committed
74 75 76 77 78 79
  if (table_def_inited)
  {
    close_cached_tables((THD*) 0,0,(TABLE_LIST*) 0);
    if (!open_cache.records)			// Safety first
      hash_free(&open_cache);
  }
unknown's avatar
unknown committed
80 81 82
  DBUG_VOID_RETURN;
}

unknown's avatar
unknown committed
83
uint cached_open_tables(void)
unknown's avatar
unknown committed
84 85 86 87
{
  return open_cache.records;
}

unknown's avatar
unknown committed
88

unknown's avatar
unknown committed
89 90 91
#ifdef EXTRA_DEBUG
static void check_unused(void)
{
unknown's avatar
unknown committed
92
  uint count= 0, open_files= 0, idx= 0;
unknown's avatar
unknown committed
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
  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--;
unknown's avatar
unknown committed
116 117
    if (entry->file)
      open_files++;
unknown's avatar
unknown committed
118 119 120
  }
  if (count != 0)
  {
121
    DBUG_PRINT("error",("Unused_links doesn't match open_cache: diff: %d", /* purecov: inspected */
unknown's avatar
unknown committed
122 123
			count)); /* purecov: inspected */
  }
unknown's avatar
unknown committed
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142

#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
unknown's avatar
unknown committed
143 144 145 146 147
}
#else
#define check_unused()
#endif

unknown's avatar
unknown committed
148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173

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

174
uint create_table_def_key(THD *thd, char *key, TABLE_LIST *table_list,
unknown's avatar
unknown committed
175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
                          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)
*****************************************************************************/

extern "C" byte *table_def_key(const byte *record, uint *length,
                               my_bool not_used __attribute__((unused)))
{
  TABLE_SHARE *entry=(TABLE_SHARE*) record;
  *length= entry->table_cache_key.length;
  return (byte*) entry->table_cache_key.str;
}


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()
  thd			Table share
  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
*/

276
TABLE_SHARE *get_table_share(THD *thd, TABLE_LIST *table_list, char *key,
unknown's avatar
unknown committed
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 312 313 314 315
                             uint key_length, uint db_flags, int *error)
{
  TABLE_SHARE *share;
  DBUG_ENTER("get_table_share");

  *error= 0;

  /* Read table definition from cache */
  if ((share= (TABLE_SHARE*) hash_search(&table_def_cache,(byte*) key,
                                         key_length)))
    goto found;

  if (!(share= alloc_table_share(table_list, key, key_length)))
  {
#ifdef NOT_YET
    pthread_mutex_unlock(&LOCK_open);
#endif
    DBUG_RETURN(0);
  }

#ifdef NOT_YET
  // 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 */
  if ((old_share= hash_search(&table_def_cache, (byte*) key, key_length)))
  {
    (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);
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331

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

unknown's avatar
unknown committed
332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
  if (my_hash_insert(&table_def_cache, (byte*) share))
  {
#ifdef NOT_YET
    pthread_mutex_unlock(&LOCK_open);    
    (void) pthread_mutex_unlock(&share->mutex);
#endif
    free_table_share(share);
    DBUG_RETURN(0);				// return error
  }
#ifdef NOT_YET
  pthread_mutex_unlock(&LOCK_open);
#endif
  if (open_table_def(thd, share, db_flags))
  {
#ifdef NOT_YET
    /*
      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;
358
    (void) hash_delete(&table_def_cache, (byte*) share);
unknown's avatar
unknown committed
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429
    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);
#ifdef NOT_YET
  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);
    VOID(hash_delete(&table_def_cache, (byte*) oldest_unused_share));
  }

  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,
430
                             char *key, uint key_length,
unknown's avatar
unknown committed
431 432 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 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 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
                             uint db_flags, int *error)
{
  TABLE_SHARE *share;
  int tmp;
  DBUG_ENTER("get_table_share_with_create");

  if ((share= get_table_share(thd, table_list, key, key_length, 
                              db_flags, error)) ||
      thd->net.last_errno != ER_NO_SUCH_TABLE)
    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.
      Hide "Table doesn't exist" errors if table belong to view
    */
    if (table_list->belong_to_view)
    {
      TABLE_LIST *view= table_list->belong_to_view;
      thd->clear_error();
      my_error(ER_VIEW_INVALID, MYF(0),
               view->view_db.str, view->view_name.str);
    }
    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"));
    hash_delete(&table_def_cache, (byte*) share);
    DBUG_VOID_RETURN;
  }
  pthread_mutex_unlock(&share->mutex);
  DBUG_VOID_RETURN;


#ifdef NOT_YET
  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.
	 */
	(void) hash_search(&def_cache,(byte*) key,key_length);
	hash_replace(&def_cache, def_cache.current_record,(byte*) name_lock);
      }
      else
      {
	/* Remove table definition */
	hash_delete(&def_cache,(byte*) share);
      }
      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)
{
605
  char key[NAME_LEN*2+2];
unknown's avatar
unknown committed
606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669
  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);
  return (TABLE_SHARE*) hash_search(&table_def_cache,(byte*) key, key_length);
}  


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


static void close_handle_and_leave_table_as_lock(TABLE *table)
{
  TABLE_SHARE *share, *old_share= table->s;
  MEM_ROOT *mem_root= &table->mem_root;
  DBUG_ENTER("close_handle_and_leave_table_as_lock");

  /*
    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
  */
  if ((share= (TABLE_SHARE*) alloc_root(mem_root, sizeof(*share))))
  {
    bzero((char*) share, sizeof(*share));
    share->db.str= memdup_root(mem_root, old_share->db.str,
                               old_share->db.length+1);
    share->db.length= old_share->db.length;
    share->table_name.str= memdup_root(mem_root,
                                       old_share->table_name.str,
                                       old_share->table_name.length+1);
    share->table_name.length= old_share->table_name.length;
    share->table_cache_key.str= memdup_root(mem_root,
                                            old_share->table_cache_key.str,
                                            old_share->table_cache_key.length);
    share->table_cache_key.length= old_share->table_cache_key.length;
    share->tmp_table= INTERNAL_TMP_TABLE;       // for intern_close_table()
  }

  table->file->close();
  table->db_stat= 0;                            // Mark file closed
  release_table_share(table->s, RELEASE_NORMAL);
  table->s= share;

  DBUG_VOID_RETURN;
}



unknown's avatar
unknown committed
670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687
/*
  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.
*/

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

695 696
  VOID(pthread_mutex_lock(&LOCK_open));
  bzero((char*) &table_list,sizeof(table_list));
697 698
  start_list= &open_list;
  open_list=0;
699

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

unknown's avatar
unknown committed
706
    if (db && my_strcasecmp(system_charset_info, db, share->db.str))
707
      continue;
unknown's avatar
unknown committed
708
    if (wild && wild_compare(share->table_name.str, wild, 0))
709
      continue;
710

711
    /* Check if user has SELECT privilege for any column in the table */
unknown's avatar
unknown committed
712 713
    table_list.db=         share->db.str;
    table_list.table_name= share->table_name.str;
714
    table_list.grant.privilege=0;
unknown's avatar
unknown committed
715

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

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


void intern_close_table(TABLE *table)
{						// Free all structures
unknown's avatar
unknown committed
759 760
  DBUG_ENTER("intern_close_table");

unknown's avatar
unknown committed
761
  free_io_cache(table);
762
  delete table->triggers;
unknown's avatar
unknown committed
763 764 765
  if (table->file)                              // Not true if name lock
    VOID(closefrm(table, 1));			// close file
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
766 767
}

768 769 770 771 772 773 774 775 776 777
/*
  Remove table from the open table cache

  SYNOPSIS
    free_cache_entry()
    table		Table to remove

  NOTE
    We need to have a lock on LOCK_open when calling this
*/
unknown's avatar
unknown committed
778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799

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

  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
  }
  my_free((gptr) table,MYF(0));
  DBUG_VOID_RETURN;
}

800
/* Free resources allocated by filesort() and read_record() */
unknown's avatar
unknown committed
801 802 803

void free_io_cache(TABLE *table)
{
804
  DBUG_ENTER("free_io_cache");
unknown's avatar
unknown committed
805
  if (table->sort.io_cache)
unknown's avatar
unknown committed
806
  {
unknown's avatar
unknown committed
807 808 809
    close_cached_file(table->sort.io_cache);
    my_free((gptr) table->sort.io_cache,MYF(0));
    table->sort.io_cache=0;
unknown's avatar
unknown committed
810
  }
811
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
812 813
}

814 815 816 817 818 819
/*
  Close all tables which aren't in use by any thread

  THD can be NULL, but then if_wait_for_refresh must be FALSE
  and tables must be NULL.
*/
unknown's avatar
unknown committed
820

unknown's avatar
unknown committed
821
bool close_cached_tables(THD *thd, bool if_wait_for_refresh,
unknown's avatar
unknown committed
822
			 TABLE_LIST *tables, bool have_lock)
unknown's avatar
unknown committed
823 824 825
{
  bool result=0;
  DBUG_ENTER("close_cached_tables");
826
  DBUG_ASSERT(thd || (!if_wait_for_refresh && !tables));
unknown's avatar
unknown committed
827

unknown's avatar
unknown committed
828 829
  if (!have_lock)
    VOID(pthread_mutex_lock(&LOCK_open));
unknown's avatar
unknown committed
830
  if (!tables)
unknown's avatar
unknown committed
831
  {
unknown's avatar
unknown committed
832
    refresh_version++;				// Force close of open tables
unknown's avatar
unknown committed
833 834
    while (unused_tables)
    {
unknown's avatar
unknown committed
835
#ifdef EXTRA_DEBUG
unknown's avatar
unknown committed
836 837
      if (hash_delete(&open_cache,(byte*) unused_tables))
	printf("Warning: Couldn't delete open table from hash\n");
unknown's avatar
unknown committed
838
#else
unknown's avatar
unknown committed
839
      VOID(hash_delete(&open_cache,(byte*) unused_tables));
unknown's avatar
unknown committed
840
#endif
unknown's avatar
unknown committed
841
    }
unknown's avatar
unknown committed
842 843 844 845 846 847
    /* Free table shares */
    while (oldest_unused_share->next)
    {
      pthread_mutex_lock(&oldest_unused_share->mutex);
      VOID(hash_delete(&table_def_cache, (byte*) oldest_unused_share));
    }
unknown's avatar
unknown committed
848
  }
unknown's avatar
unknown committed
849
  else
unknown's avatar
unknown committed
850
  {
unknown's avatar
unknown committed
851
    bool found=0;
unknown's avatar
VIEW  
unknown committed
852
    for (TABLE_LIST *table= tables; table; table= table->next_local)
unknown's avatar
unknown committed
853
    {
854 855
      if ((!table->table || !table->table->s->log_table) &&
          remove_table_from_cache(thd, table->db, table->table_name,
unknown's avatar
unknown committed
856
                                  RTFC_OWNED_BY_THD_FLAG))
unknown's avatar
unknown committed
857 858 859 860
	found=1;
    }
    if (!found)
      if_wait_for_refresh=0;			// Nothing to wait for
unknown's avatar
unknown committed
861
  }
unknown's avatar
unknown committed
862
#ifndef EMBEDDED_LIBRARY
863 864
  if (!tables)
    kill_delayed_threads();
unknown's avatar
unknown committed
865
#endif
unknown's avatar
unknown committed
866 867 868 869 870 871 872 873 874 875
  if (if_wait_for_refresh)
  {
    /*
      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;
    thd->proc_info="Flushing tables";

unknown's avatar
unknown committed
876
    close_old_data_files(thd,thd->open_tables,1,1);
877 878
    mysql_ha_flush(thd, tables, MYSQL_HA_REOPEN_ON_USAGE | MYSQL_HA_FLUSH_ALL,
                   TRUE);
unknown's avatar
unknown committed
879 880
    bool found=1;
    /* Wait until all threads has closed all the tables we had locked */
881 882
    DBUG_PRINT("info",
	       ("Waiting for others threads to close their open tables"));
unknown's avatar
unknown committed
883 884 885 886 887 888
    while (found && ! thd->killed)
    {
      found=0;
      for (uint idx=0 ; idx < open_cache.records ; idx++)
      {
	TABLE *table=(TABLE*) hash_element(&open_cache,idx);
889 890
	if (!table->s->log_table &&
            ((table->s->version) < refresh_version && table->db_stat))
unknown's avatar
unknown committed
891 892 893 894 895 896 897 898 899 900 901 902 903 904 905
	{
	  found=1;
	  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;
906
    /* Set version for table */
unknown's avatar
VIEW  
unknown committed
907
    for (TABLE *table=thd->open_tables; table ; table= table->next)
908
      table->s->version= refresh_version;
unknown's avatar
unknown committed
909
  }
unknown's avatar
unknown committed
910 911
  if (!have_lock)
    VOID(pthread_mutex_unlock(&LOCK_open));
unknown's avatar
unknown committed
912 913 914 915 916 917 918 919 920 921 922 923
  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);
}


924
/*
925 926 927 928 929 930 931 932 933 934 935
  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.
936 937 938 939 940 941 942 943 944

  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.
945 946 947 948 949 950 951 952 953 954 955 956 957
*/

static void mark_used_tables_as_free_for_reuse(THD *thd, TABLE *table)
{
  for (; table ; table= table->next)
    if (table->query_id == thd->query_id)
      table->query_id= 0;
}


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

959 960 961 962 963 964 965
  SYNOPSIS
    close_thread_tables()
    thd			Thread handler
    lock_in_use		Set to 1 (0 = default) if caller has a lock on
			LOCK_open
    skip_derived	Set to 1 (0 = default) if we should not free derived
			tables.
966 967
    stopper             When closing tables from thd->open_tables(->next)*, 
                        don't close/remove tables starting from stopper.
968 969 970 971

  IMPLEMENTATION
    Unlocks tables and frees derived tables.
    Put all normal tables used by thread in free list.
972 973 974 975 976

    When in prelocked mode 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.
977
*/
unknown's avatar
unknown committed
978

979
void close_thread_tables(THD *thd, bool lock_in_use, bool skip_derived)
unknown's avatar
unknown committed
980
{
981
  bool found_old_table;
982
  prelocked_mode_type prelocked_mode= thd->prelocked_mode;
unknown's avatar
unknown committed
983 984
  DBUG_ENTER("close_thread_tables");

985 986 987 988 989 990 991 992 993 994 995
  /*
    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.
  */
996 997 998 999
  if (thd->derived_tables && !skip_derived)
  {
    TABLE *table, *next;
    /*
1000 1001
      Close all derived tables generated in queries like
      SELECT * FROM (SELECT * FROM t1)
1002 1003 1004 1005 1006 1007 1008 1009
    */
    for (table= thd->derived_tables ; table ; table= next)
    {
      next= table->next;
      free_tmp_table(thd, table);
    }
    thd->derived_tables= 0;
  }
1010 1011

  if (prelocked_mode)
1012
  {
1013 1014 1015 1016 1017 1018 1019 1020 1021
    /*
      Mark all temporary tables used by this substatement as free for reuse.
    */
    mark_used_tables_as_free_for_reuse(thd, thd->temporary_tables);
  }

  if (thd->locked_tables || prelocked_mode)
  {
    /*
1022 1023 1024 1025 1026 1027
      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.
1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
    */
    ha_commit_stmt(thd);

    /* We are under simple LOCK TABLES so should not do anything else. */
    if (!prelocked_mode)
      DBUG_VOID_RETURN;

    if (!thd->lex->requires_prelocking())
    {
      /*
        If we are executing one of substatements we have to mark
        all tables which it used as free for reuse.
      */
      mark_used_tables_as_free_for_reuse(thd, thd->open_tables);
      DBUG_VOID_RETURN;
    }

    DBUG_ASSERT(prelocked_mode);
    /*
      We are in prelocked mode, so we have to leave it now with doing
      implicit UNLOCK TABLES if need.
    */
1050
    DBUG_PRINT("info",("thd->prelocked_mode= NON_PRELOCKED"));
1051 1052 1053 1054 1055 1056 1057 1058
    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 */
1059
  }
unknown's avatar
unknown committed
1060 1061 1062

  if (thd->lock)
  {
1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
    /*
      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.
     */
    thd->binlog_flush_pending_rows_event(true);
1073 1074
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;
unknown's avatar
unknown committed
1075
  }
1076 1077 1078 1079 1080 1081 1082 1083
  /*
    assume handlers auto-commit (if some doesn't - transaction handling
    in MySQL should be redesigned to support it; it's a big change,
    and it's not worth it - better to commit explicitly only writing
    transactions, read-only ones should better take care of themselves.
    saves some work in 2pc too)
    see also sql_parse.cc - dispatch_command()
  */
1084 1085
  if (!(thd->state_flags & Open_tables_state::BACKUPS_AVAIL))
    bzero(&thd->transaction.stmt, sizeof(thd->transaction.stmt));
1086
  if (!thd->active_transaction())
1087
    thd->transaction.xid_state.xid.null();
1088

unknown's avatar
unknown committed
1089
  /* VOID(pthread_sigmask(SIG_SETMASK,&thd->block_signals,NULL)); */
1090
  if (!lock_in_use)
unknown's avatar
unknown committed
1091 1092
    VOID(pthread_mutex_lock(&LOCK_open));

unknown's avatar
unknown committed
1093
  DBUG_PRINT("info", ("thd->open_tables: %p", thd->open_tables));
1094

unknown's avatar
unknown committed
1095
  found_old_table= 0;
1096
  while (thd->open_tables)
1097
    found_old_table|=close_thread_table(thd, &thd->open_tables);
1098
  thd->some_tables_deleted=0;
1099

unknown's avatar
unknown committed
1100
  /* Free tables to hold down open files */
1101
  while (open_cache.records > table_cache_size && unused_tables)
unknown's avatar
unknown committed
1102 1103 1104 1105 1106 1107 1108
    VOID(hash_delete(&open_cache,(byte*) unused_tables)); /* purecov: tested */
  check_unused();
  if (found_old_table)
  {
    /* Tell threads waiting for refresh that something has happened */
    VOID(pthread_cond_broadcast(&COND_refresh));
  }
1109
  if (!lock_in_use)
unknown's avatar
unknown committed
1110 1111
    VOID(pthread_mutex_unlock(&LOCK_open));
  /*  VOID(pthread_sigmask(SIG_SETMASK,&thd->signals,NULL)); */
1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122

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

unknown's avatar
unknown committed
1123 1124 1125
  DBUG_VOID_RETURN;
}

1126 1127 1128 1129
/* move one table to free list */

bool close_thread_table(THD *thd, TABLE **table_ptr)
{
1130 1131
  bool found_old_table= 0;
  TABLE *table= *table_ptr;
1132
  DBUG_ENTER("close_thread_table");
1133
  DBUG_ASSERT(table->key_read == 0);
unknown's avatar
unknown committed
1134
  DBUG_ASSERT(table->file->inited == handler::NONE);
1135 1136

  *table_ptr=table->next;
1137
  if (table->s->version != refresh_version ||
1138 1139 1140 1141 1142 1143 1144
      thd->version != refresh_version || !table->db_stat)
  {
    VOID(hash_delete(&open_cache,(byte*) table));
    found_old_table=1;
  }
  else
  {
1145
    if (table->s->flush_version != flush_version)
1146
    {
1147
      table->s->flush_version= flush_version;
1148 1149 1150 1151 1152
      table->file->extra(HA_EXTRA_FLUSH);
    }
    else
    {
      // Free memory and reset for next loop
1153
      table->file->ha_reset();
1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168
    }
    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);
}

unknown's avatar
unknown committed
1169

1170 1171 1172 1173 1174 1175 1176
/* close_temporary_tables' internal, 4 is due to uint4korr definition */
static inline uint  tmpkeyval(THD *thd, TABLE *table)
{
  return uint4korr(table->s->table_cache_key.str + table->s->table_cache_key.length - 4);
}


unknown's avatar
unknown committed
1177 1178
/*
  Close all temporary tables created by 'CREATE TEMPORARY TABLE' for thread
1179
  creates one DROP TEMPORARY TABLE binlog event for each pseudo-thread 
unknown's avatar
unknown committed
1180
*/
unknown's avatar
unknown committed
1181 1182 1183

void close_temporary_tables(THD *thd)
{
1184 1185 1186 1187 1188 1189
  TABLE *next,
    *prev_table /* prev link is not maintained in TABLE's double-linked list */,
    *table;
  char *query= (gptr) 0, *end;
  uint query_buf_size, max_names_len; 
  bool found_user_tables;
unknown's avatar
unknown committed
1190

1191 1192 1193
  if (!thd->temporary_tables)
    return;
  
1194
  LINT_INIT(end);
unknown's avatar
unknown committed
1195
  query_buf_size= 50;   // Enough for DROP ... TABLE IF EXISTS
1196

1197 1198 1199 1200 1201 1202 1203 1204 1205
  /* 
     insertion sort of temp tables by pseudo_thread_id to build ordered list 
     of sublists of equal pseudo_thread_id
  */
  for (prev_table= thd->temporary_tables, 
         table= prev_table->next,
         found_user_tables= (prev_table->s->table_name.str[0] != '#'); 
       table;
       prev_table= table, table= table->next)
unknown's avatar
unknown committed
1206
  {
1207 1208
    TABLE *prev_sorted /* same as for prev_table */,
      *sorted;
unknown's avatar
unknown committed
1209
    /*
1210 1211 1212
      table not created directly by the user is moved to the tail. 
      Fixme/todo: nothing (I checked the manual) prevents user to create temp
      with `#' 
unknown's avatar
unknown committed
1213
    */
1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 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
    if (table->s->table_name.str[0] == '#')
      continue;
    else 
    {
      found_user_tables = 1;
    }
    for (prev_sorted= NULL, sorted= thd->temporary_tables; sorted != table; 
         prev_sorted= sorted, sorted= sorted->next)
    {
      if (sorted->s->table_name.str[0] == '#' || tmpkeyval(thd, sorted) > tmpkeyval(thd, table))
      {
        /* 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;
      }
    }
  }  
  /* 
     calc query_buf_size as max per sublists, one sublist per pseudo thread id.
     Also stop at first occurence of `#'-named table that starts 
     all implicitly created temp tables
  */
  for (max_names_len= 0, table=thd->temporary_tables; 
       table && table->s->table_name.str[0] != '#';
       table=table->next)
  {
    uint tmp_names_len;
    for (tmp_names_len= table->s->table_cache_key.length + 1;
         table->next && table->s->table_name.str[0] != '#' &&
           tmpkeyval(thd, table) == tmpkeyval(thd, table->next);
         table=table->next)
    {
      /*
        We are going to add 4 ` around the db/table names, so 1 might not look
        enough; indeed it is enough, because table->s->table_cache_key.length is
        greater (by 8, because of server_id and thread_id) than db||table.
      */
      tmp_names_len += table->next->s->table_cache_key.length + 1;
    }
    if (tmp_names_len > max_names_len) max_names_len= tmp_names_len;
unknown's avatar
unknown committed
1264
  }
1265 1266 1267 1268 1269
  
  /* allocate */
  if (found_user_tables && mysql_bin_log.is_open() &&
      !thd->current_stmt_binlog_row_based &&
      (query = alloc_root(thd->mem_root, query_buf_size+= max_names_len)))
unknown's avatar
unknown committed
1270
    // Better add "if exists", in case a RESET MASTER has been done
1271
    end= strmov(query, "DROP /*!40005 TEMPORARY */ TABLE IF EXISTS ");
1272

1273 1274
  /* scan sorted tmps to generate sequence of DROP */
  for (table=thd->temporary_tables; table; table= next)
unknown's avatar
unknown committed
1275
  {
1276 1277
    if (query // we might be out of memory, but this is not fatal 
        && table->s->table_name.str[0] != '#') 
1278
    {
1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312
      char *end_cur;
      /* Set pseudo_thread_id to be that of the processed table */
      thd->variables.pseudo_thread_id= tmpkeyval(thd, table);
      /* Loop forward through all tables within the sublist of
         common pseudo_thread_id to create single DROP query */
      for (end_cur= end;
           table && table->s->table_name.str[0] != '#' &&
             tmpkeyval(thd, table) == thd->variables.pseudo_thread_id;
           table= next)
      {
        end_cur= strxmov(end_cur, "`", table->s->db.str, "`.`",
                      table->s->table_name.str, "`,", NullS);
        next= table->next;
        close_temporary(table, 1, 1);
      }
      thd->clear_error();
      /* The -1 is to remove last ',' */
      Query_log_event qinfo(thd, query, (ulong)(end_cur - query) - 1, 0, FALSE);
      /*
        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.
      */
      qinfo.error_code= 0;
      mysql_bin_log.write(&qinfo);
    }
    else 
    {
      next= table->next;
      close_temporary(table, 1, 1);
1313
    }
unknown's avatar
unknown committed
1314
  }
unknown's avatar
unknown committed
1315 1316 1317 1318
  thd->temporary_tables=0;
}


1319
/*
1320
  Find table in list.
1321 1322

  SYNOPSIS
1323
    find_table_in_list()
1324
    table		Pointer to table list
1325
    offset		Offset to which list in table structure to use
1326 1327
    db_name		Data base name
    table_name		Table name
unknown's avatar
VIEW  
unknown committed
1328

1329 1330 1331
  NOTES:
    This is called by find_table_in_local_list() and
    find_table_in_global_list().
unknown's avatar
VIEW  
unknown committed
1332 1333 1334 1335 1336 1337

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

1338
TABLE_LIST *find_table_in_list(TABLE_LIST *table,
1339
                               st_table_list *TABLE_LIST::*link,
1340 1341
                               const char *db_name,
                               const char *table_name)
unknown's avatar
VIEW  
unknown committed
1342
{
1343
  for (; table; table= table->*link )
1344
  {
1345 1346 1347 1348
    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;
1349
  }
unknown's avatar
VIEW  
unknown committed
1350 1351 1352 1353
  return table;
}


1354
/*
1355
  Test that table is unique (It's only exists once in the table list)
1356 1357 1358

  SYNOPSIS
    unique_table()
1359
    thd                   thread handle
1360
    table                 table which should be checked
1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378
    table_list            list of tables

  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

    TODO: when we will have table/view change detection we can do this check
          only once for PS/SP
1379 1380

  RETURN
unknown's avatar
unknown committed
1381 1382
    found duplicate
    0 if table is unique
1383 1384
*/

1385
TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list)
1386
{
unknown's avatar
unknown committed
1387
  TABLE_LIST *res;
1388
  const char *d_name, *t_name;
unknown's avatar
unknown committed
1389 1390
  DBUG_ENTER("unique_table");
  DBUG_PRINT("enter", ("table alias: %s", table->alias));
1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402

  /*
    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)
1403
  {
1404 1405 1406 1407 1408 1409 1410 1411 1412
    /* 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);
1413
  }
1414 1415
  d_name= table->db;
  t_name= table->table_name;
1416 1417

  DBUG_PRINT("info", ("real table: %s.%s", d_name, t_name));
unknown's avatar
unknown committed
1418
  for (;;)
unknown's avatar
unknown committed
1419
  {
1420 1421 1422 1423
    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) &&
         res->select_lex && !res->select_lex->exclude_from_table_unique_test))
1424
      break;
1425 1426 1427 1428 1429
    /*
      If we found entry of this table or or table of SELECT which already
      processed in derived table or top select of multi-update/multi-delete
      (exclude_from_table_unique_test).
    */
1430
    table_list= res->next_global;
1431 1432
    DBUG_PRINT("info",
               ("found same copy of table or table which we should skip"));
unknown's avatar
unknown committed
1433
  }
1434
  DBUG_RETURN(res);
1435 1436 1437
}


1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491
/*
  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)
    {
      if (update->view == duplicate->view)
        my_error(ER_NON_UPDATABLE_TABLE, MYF(0), update->alias, operation);
      else
        my_error(ER_VIEW_PREVENT_UPDATE, MYF(0),
                 (duplicate->view ? duplicate->alias : update->alias),
                 operation, update->alias);
      return;
    }
    if (duplicate->view)
    {
      my_error(ER_VIEW_PREVENT_UPDATE, MYF(0), duplicate->alias, operation,
               update->alias);
      return;
    }
  }
  my_error(ER_UPDATE_TABLE_USED, MYF(0), update->alias);
}


unknown's avatar
unknown committed
1492
TABLE *find_temporary_table(THD *thd, const char *db, const char *table_name)
unknown's avatar
unknown committed
1493
{
unknown's avatar
unknown committed
1494
  TABLE_LIST table_list;
unknown's avatar
unknown committed
1495

unknown's avatar
unknown committed
1496 1497 1498 1499
  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
  return find_temporary_table(thd, &table_list);
}
1500

unknown's avatar
unknown committed
1501 1502 1503 1504 1505 1506 1507 1508 1509

TABLE *find_temporary_table(THD *thd, TABLE_LIST *table_list)
{
  char	key[MAX_DBKEY_LENGTH];
  uint	key_length;
  TABLE *table;

  key_length= create_table_def_key(thd, key, table_list, 1);
  for (table=thd->temporary_tables ; table ; table= table->next)
unknown's avatar
unknown committed
1510
  {
unknown's avatar
unknown committed
1511 1512 1513
    if (table->s->table_cache_key.length == key_length &&
	!memcmp(table->s->table_cache_key.str, key, key_length))
      return table;
unknown's avatar
unknown committed
1514 1515 1516 1517
  }
  return 0;					// Not a temporary table
}

unknown's avatar
unknown committed
1518 1519 1520 1521 1522 1523

/*
  Close temporary table and unlink from thd->temporary tables
*/

bool close_temporary_table(THD *thd, TABLE_LIST *table_list)
unknown's avatar
unknown committed
1524
{
unknown's avatar
unknown committed
1525
  TABLE *table;
unknown's avatar
unknown committed
1526

unknown's avatar
unknown committed
1527
  if (!(table= find_temporary_table(thd, table_list)))
unknown's avatar
unknown committed
1528
    return 1;
unknown's avatar
unknown committed
1529
  close_temporary_table(thd, table, 1, 1);
unknown's avatar
unknown committed
1530 1531 1532
  return 0;
}

unknown's avatar
unknown committed
1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558
/*
  Close temporary table and unlink from thd->temporary tables
*/

void close_temporary_table(THD *thd, TABLE *table,
                           bool free_share, bool delete_table)
{
  TABLE **prev= table->open_prev;
  if ((*table->open_prev= table->next))
    table->next->open_prev= prev;
  if (thd->slave_thread)
    slave_open_temp_tables--;
  close_temporary(table, free_share, delete_table);
}


/*
  Close and delete a temporary table

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

void close_temporary(TABLE *table, bool free_share, bool delete_table)
{
unknown's avatar
unknown committed
1559
  handlerton *table_type= table->s->db_type;
unknown's avatar
unknown committed
1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574
  DBUG_ENTER("close_temporary");

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


unknown's avatar
unknown committed
1575 1576 1577 1578 1579 1580 1581
/*
  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'.
*/
1582

1583
bool rename_temporary_table(THD* thd, TABLE *table, const char *db,
unknown's avatar
unknown committed
1584 1585 1586
			    const char *table_name)
{
  char *key;
1587
  TABLE_SHARE *share= table->s;
unknown's avatar
unknown committed
1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609
  TABLE_LIST table_list;
  uint db_length, table_length;
  DBUG_ENTER("rename_temporary_table");

  if (!(key=(char*) alloc_root(&share->mem_root,
			       (uint) (db_length= strlen(db))+
			       (uint) (table_length= strlen(table_name))+6+4)))
    DBUG_RETURN(1);				/* purecov: inspected */

  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
  share->db.str= share->table_cache_key.str= key;
  share->db.length= db_length;
  share->table_cache_key.length= create_table_def_key(thd, key,
                                                      &table_list, 1);
  /*
    Here we use the fact that table_name is stored as the second component
    in the 'key' (after db_name), where components are separated with \0
  */
  share->table_name.str=    key+db_length+1;
  share->table_name.length= table_length;
  DBUG_RETURN(0);
unknown's avatar
unknown committed
1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638
}


	/* move table first in unused links */

static void relink_unused(TABLE *table)
{
  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();
  }
}


/*
  Remove all instances of table from the current open list
  Free all locks on tables that are done with LOCK TABLES
 */

TABLE *unlink_open_table(THD *thd, TABLE *list, TABLE *find)
{
  char key[MAX_DBKEY_LENGTH];
unknown's avatar
unknown committed
1639
  uint key_length= find->s->table_cache_key.length;
unknown's avatar
unknown committed
1640 1641
  TABLE *start=list,**prev,*next;
  prev= &start;
1642

unknown's avatar
unknown committed
1643
  memcpy(key, find->s->table_cache_key.str, key_length);
unknown's avatar
unknown committed
1644 1645 1646
  for (; list ; list=next)
  {
    next=list->next;
unknown's avatar
unknown committed
1647 1648
    if (list->s->table_cache_key.length == key_length &&
	!memcmp(list->s->table_cache_key.str, key, key_length))
unknown's avatar
unknown committed
1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666
    {
      if (thd->locked_tables)
	mysql_lock_remove(thd, thd->locked_tables,list);
      VOID(hash_delete(&open_cache,(byte*) list)); // Close table
    }
    else
    {
      *prev=list;				// put in use list
      prev= &list->next;
    }
  }
  *prev=0;
  // Notify any 'refresh' threads
  pthread_cond_broadcast(&COND_refresh);
  return start;
}


1667
/*
unknown's avatar
unknown committed
1668 1669 1670 1671 1672 1673 1674 1675
   Wait for condition but allow the user to send a kill to mysqld

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

unknown's avatar
unknown committed
1678
void wait_for_condition(THD *thd, pthread_mutex_t *mutex, pthread_cond_t *cond)
unknown's avatar
unknown committed
1679 1680 1681
{
  /* Wait until the current table is up to date */
  const char *proc_info;
unknown's avatar
unknown committed
1682 1683
  thd->mysys_var->current_mutex= mutex;
  thd->mysys_var->current_cond= cond;
unknown's avatar
unknown committed
1684 1685
  proc_info=thd->proc_info;
  thd->proc_info="Waiting for table";
unknown's avatar
unknown committed
1686
  if (!thd->killed)
unknown's avatar
unknown committed
1687
    (void) pthread_cond_wait(cond, mutex);
unknown's avatar
unknown committed
1688

unknown's avatar
unknown committed
1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700
  /*
    We must unlock mutex first to avoid deadlock becasue conditions are
    sent to this thread by doing locks in the following order:
    lock(mysys_var->mutex)
    lock(mysys_var->current_mutex)

    One by effect of this that one can only use wait_for_condition with
    condition variables that are guranteed to not disapper (freed) even if this
    mutex is unlocked
  */
    
  pthread_mutex_unlock(mutex);
unknown's avatar
unknown committed
1701 1702 1703 1704 1705 1706 1707
  pthread_mutex_lock(&thd->mysys_var->mutex);
  thd->mysys_var->current_mutex= 0;
  thd->mysys_var->current_cond= 0;
  thd->proc_info= proc_info;
  pthread_mutex_unlock(&thd->mysys_var->mutex);
}

1708

1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727
/*
  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.

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

  RETURN VALUE
    FALSE - Success
    TRUE  - Error
*/

bool reopen_name_locked_table(THD* thd, TABLE_LIST* table_list)
1728
{
1729
  TABLE *table= table_list->table;
1730
  TABLE_SHARE *share;
1731 1732 1733 1734 1735 1736
  char *db= table_list->db;
  char *table_name= table_list->table_name;
  char key[MAX_DBKEY_LENGTH];
  uint key_length;
  TABLE orig_table;
  DBUG_ENTER("reopen_name_locked_table");
1737

1738 1739 1740 1741 1742 1743
  safe_mutex_assert_owner(&LOCK_open);

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

  orig_table= *table;
1744 1745
  key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;

unknown's avatar
unknown committed
1746 1747 1748
  if (open_unireg_entry(thd, table, table_list, table_name,
                        table->s->table_cache_key.str,
                        table->s->table_cache_key.length, thd->mem_root))
unknown's avatar
unknown committed
1749
  {
1750 1751 1752 1753 1754 1755 1756 1757 1758
    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);
unknown's avatar
unknown committed
1759
  }
1760

1761 1762 1763
  share= table->s;
  share->version=0;
  share->flush_version=0;
1764 1765
  table->in_use = thd;
  check_unused();
unknown's avatar
unknown committed
1766 1767
  table->next = thd->open_tables;
  thd->open_tables = table;
1768 1769 1770
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
1771
  table->null_row= table->maybe_null= table->force_index= 0;
1772
  table->status=STATUS_NO_RECORD;
1773 1774
  table->keys_in_use_for_query= share->keys_in_use;
  table->used_keys= share->keys_for_keyread;
1775
  DBUG_RETURN(FALSE);
1776 1777
}

unknown's avatar
unknown committed
1778

1779 1780 1781 1782 1783
/*
  Open a table.

  SYNOPSIS
    open_table()
1784 1785 1786 1787 1788 1789 1790 1791 1792 1793
    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.
1794 1795 1796 1797 1798 1799

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

  RETURN
    NULL  Open failed.  If refresh is set then one should close
1800
          all other tables and retry the open.
1801 1802
    #     Success. Pointer to TABLE object for open table.
*/
unknown's avatar
unknown committed
1803 1804


unknown's avatar
VIEW  
unknown committed
1805
TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
1806
		  bool *refresh, uint flags)
unknown's avatar
unknown committed
1807 1808 1809 1810
{
  reg1	TABLE *table;
  char	key[MAX_DBKEY_LENGTH];
  uint	key_length;
unknown's avatar
VIEW  
unknown committed
1811
  char	*alias= table_list->alias;
1812
  HASH_SEARCH_STATE state;
unknown's avatar
unknown committed
1813 1814 1815 1816 1817
  DBUG_ENTER("open_table");

  /* find a unused table in the open table cache */
  if (refresh)
    *refresh=0;
1818 1819

  /* an open table operation needs a lot of the stack space */
1820
  if (check_stack_overrun(thd, STACK_MIN_SIZE_FOR_OPEN, (char *)&alias))
unknown's avatar
unknown committed
1821
    DBUG_RETURN(0);
1822

unknown's avatar
unknown committed
1823 1824
  if (thd->killed)
    DBUG_RETURN(0);
unknown's avatar
unknown committed
1825 1826 1827

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

unknown's avatar
VIEW  
unknown committed
1829
  if (!table_list->skip_temporary)
unknown's avatar
unknown committed
1830
  {
unknown's avatar
VIEW  
unknown committed
1831
    for (table= thd->temporary_tables; table ; table=table->next)
unknown's avatar
unknown committed
1832
    {
unknown's avatar
unknown committed
1833 1834 1835
      if (table->s->table_cache_key.length == key_length +
          TMP_TABLE_KEY_EXTRA &&
	  !memcmp(table->s->table_cache_key.str, key,
unknown's avatar
unknown committed
1836
		  key_length + TMP_TABLE_KEY_EXTRA))
unknown's avatar
unknown committed
1837
      {
1838 1839
	if (table->query_id == thd->query_id ||
            thd->prelocked_mode && table->query_id)
unknown's avatar
VIEW  
unknown committed
1840
	{
1841
	  my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
unknown's avatar
VIEW  
unknown committed
1842 1843 1844 1845 1846
	  DBUG_RETURN(0);
	}
	table->query_id= thd->query_id;
	table->clear_query_id= 1;
	thd->tmp_table_used= 1;
unknown's avatar
unknown committed
1847 1848
        DBUG_PRINT("info",("Using temporary table"));
        goto reset;
unknown's avatar
unknown committed
1849 1850 1851 1852
      }
    }
  }

1853
  if (thd->locked_tables || thd->prelocked_mode)
unknown's avatar
unknown committed
1854
  {						// Using table locks
1855
    TABLE *best_table= 0;
unknown's avatar
unknown committed
1856
    int best_distance= INT_MIN;
1857 1858 1859
    bool check_if_used= thd->prelocked_mode &&
                        ((int) table_list->lock_type >=
                         (int) TL_WRITE_ALLOW_WRITE);
unknown's avatar
unknown committed
1860 1861
    for (table=thd->open_tables; table ; table=table->next)
    {
unknown's avatar
unknown committed
1862 1863
      if (table->s->table_cache_key.length == key_length &&
	  !memcmp(table->s->table_cache_key.str, key, key_length))
unknown's avatar
unknown committed
1864
      {
1865 1866
        if (check_if_used && table->query_id &&
            table->query_id != thd->query_id)
1867
        {
1868 1869 1870 1871 1872 1873 1874
          /*
            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),
unknown's avatar
unknown committed
1875
                   table->s->table_name.str);
1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911
          DBUG_RETURN(0);
        }
        if (!my_strcasecmp(system_charset_info, table->alias, alias) &&
            table->query_id != thd->query_id && /* skip tables already used */
            !(thd->prelocked_mode && table->query_id))
        {
          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;
            }
          }
1912
        }
unknown's avatar
unknown committed
1913
      }
unknown's avatar
unknown committed
1914
    }
1915 1916 1917 1918 1919 1920 1921
    if (best_table)
    {
      table= best_table;
      table->query_id= thd->query_id;
      DBUG_PRINT("info",("Using locked table"));
      goto reset;
    }
unknown's avatar
unknown committed
1922 1923 1924 1925 1926 1927 1928
    /*
      is it view?
      (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];
unknown's avatar
unknown committed
1929
      enum legacy_db_type not_used;
1930 1931
      build_table_filename(path, sizeof(path) - 1,
                           table_list->db, table_list->table_name, reg_ext);
1932
      if (mysql_frm_type(thd, path, &not_used) == FRMTYPE_VIEW)
unknown's avatar
unknown committed
1933
      {
1934 1935 1936 1937 1938
        /*
          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;
1939
        table= &tab;
unknown's avatar
unknown committed
1940
        VOID(pthread_mutex_lock(&LOCK_open));
unknown's avatar
unknown committed
1941 1942
        if (!open_unireg_entry(thd, table, table_list, alias,
                              key, key_length, mem_root))
unknown's avatar
unknown committed
1943
        {
1944
          DBUG_ASSERT(table_list->view != 0);
unknown's avatar
unknown committed
1945 1946 1947 1948 1949 1950
          VOID(pthread_mutex_unlock(&LOCK_open));
          DBUG_RETURN(0); // VIEW
        }
        VOID(pthread_mutex_unlock(&LOCK_open));
      }
    }
1951
    my_error(ER_TABLE_NOT_LOCKED, MYF(0), alias);
unknown's avatar
unknown committed
1952 1953
    DBUG_RETURN(0);
  }
unknown's avatar
unknown committed
1954

unknown's avatar
unknown committed
1955 1956 1957 1958
  VOID(pthread_mutex_lock(&LOCK_open));

  if (!thd->open_tables)
    thd->version=refresh_version;
1959
  else if ((thd->version != refresh_version) &&
1960
           ! (flags & MYSQL_LOCK_IGNORE_FLUSH))
unknown's avatar
unknown committed
1961 1962
  {
    /* Someone did a refresh while thread was opening tables */
1963 1964
    if (refresh)
      *refresh=1;
unknown's avatar
unknown committed
1965 1966 1967 1968
    VOID(pthread_mutex_unlock(&LOCK_open));
    DBUG_RETURN(0);
  }

1969
  /* close handler tables which are marked for flush */
unknown's avatar
unknown committed
1970
  if (thd->handler_tables)
1971
    mysql_ha_flush(thd, (TABLE_LIST*) NULL, MYSQL_HA_REOPEN_ON_USAGE, TRUE);
1972

1973 1974
  for (table= (TABLE*) hash_first(&open_cache, (byte*) key, key_length,
                                  &state);
unknown's avatar
unknown committed
1975
       table && table->in_use ;
1976 1977
       table= (TABLE*) hash_next(&open_cache, (byte*) key, key_length,
                                 &state))
unknown's avatar
unknown committed
1978
  {
1979
    if (table->s->version != refresh_version)
unknown's avatar
unknown committed
1980
    {
1981 1982 1983 1984 1985
      /*
        Don't close tables if we are working with a log table or were
        asked not to close the table explicitly
      */
      if (flags & MYSQL_LOCK_IGNORE_FLUSH || table->s->log_table)
1986 1987 1988 1989 1990 1991
      {
        /* Force close at once after usage */
        thd->version= table->s->version;
        continue;
      }

unknown's avatar
unknown committed
1992
      /*
1993 1994
        There is a refresh in progress for this table
        Wait until the table is freed or the thread is killed.
unknown's avatar
unknown committed
1995
      */
unknown's avatar
unknown committed
1996
      close_old_data_files(thd,thd->open_tables,0,0);
unknown's avatar
unknown committed
1997
      if (table->in_use != thd)
unknown's avatar
unknown committed
1998
        wait_for_condition(thd, &LOCK_open, &COND_refresh);
unknown's avatar
unknown committed
1999
      else
unknown's avatar
VIEW  
unknown committed
2000
      {
unknown's avatar
unknown committed
2001
	VOID(pthread_mutex_unlock(&LOCK_open));
unknown's avatar
VIEW  
unknown committed
2002
      }
unknown's avatar
unknown committed
2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017
      if (refresh)
	*refresh=1;
      DBUG_RETURN(0);
    }
  }
  if (table)
  {
    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;
2018
    table->in_use= thd;
unknown's avatar
unknown committed
2019 2020 2021 2022
  }
  else
  {
    /* Free cache if too big */
2023
    while (open_cache.records > table_cache_size && unused_tables)
unknown's avatar
unknown committed
2024 2025 2026 2027
      VOID(hash_delete(&open_cache,(byte*) unused_tables)); /* purecov: tested */

    /* make a new table */
    if (!(table=(TABLE*) my_malloc(sizeof(*table),MYF(MY_WME))))
2028 2029
    {
      VOID(pthread_mutex_unlock(&LOCK_open));
unknown's avatar
unknown committed
2030
      DBUG_RETURN(NULL);
2031
    }
unknown's avatar
unknown committed
2032 2033 2034

    if (open_unireg_entry(thd, table, table_list, alias, key, key_length,
                          mem_root))
unknown's avatar
unknown committed
2035
    {
unknown's avatar
unknown committed
2036
      my_free((gptr)table, MYF(0));
unknown's avatar
unknown committed
2037 2038 2039
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(NULL);
    }
unknown's avatar
VIEW  
unknown committed
2040 2041 2042 2043 2044 2045
    if (table_list->view)
    {
      my_free((gptr)table, MYF(0));
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(0); // VIEW
    }
unknown's avatar
unknown committed
2046
    DBUG_PRINT("info", ("inserting table %p into the cache", table));
unknown's avatar
SCRUM  
unknown committed
2047
    VOID(my_hash_insert(&open_cache,(byte*) table));
unknown's avatar
unknown committed
2048 2049
  }

2050
  check_unused();				// Debugging call
unknown's avatar
VIEW  
unknown committed
2051

unknown's avatar
unknown committed
2052 2053 2054 2055 2056 2057 2058 2059 2060
  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:
unknown's avatar
unknown committed
2061 2062
  DBUG_ASSERT(table->s->ref_count > 0 || table->s->tmp_table != NO_TMP_TABLE);

unknown's avatar
unknown committed
2063 2064
  if (thd->lex->need_correct_ident())
    table->alias_name_used= my_strcasecmp(table_alias_charset,
unknown's avatar
unknown committed
2065
                                          table->s->table_name.str, alias);
unknown's avatar
unknown committed
2066
  /* Fix alias if table name changes */
2067
  if (strcmp(table->alias, alias))
unknown's avatar
unknown committed
2068
  {
unknown's avatar
unknown committed
2069
    uint length=(uint) strlen(alias)+1;
2070 2071 2072
    table->alias= (char*) my_realloc((char*) table->alias, length,
                                     MYF(MY_WME));
    memcpy((char*) table->alias, alias, length);
unknown's avatar
unknown committed
2073 2074 2075 2076 2077
  }
  /* These variables are also set in reopen_table() */
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
2078
  table->null_row= table->maybe_null= table->force_index= 0;
unknown's avatar
unknown committed
2079
  table->status=STATUS_NO_RECORD;
2080
  table->keys_in_use_for_query= table->s->keys_in_use;
2081
  table->insert_values= 0;
2082
  table->used_keys= table->s->keys_for_keyread;
unknown's avatar
unknown committed
2083 2084
  table->fulltext_searched= 0;
  table->file->ft_handler= 0;
unknown's avatar
unknown committed
2085
  if (table->timestamp_field)
2086
    table->timestamp_field_type= table->timestamp_field->get_auto_set_type();
unknown's avatar
VIEW  
unknown committed
2087
  table_list->updatable= 1; // It is not derived table nor non-updatable VIEW
unknown's avatar
unknown committed
2088
  DBUG_ASSERT(table->key_read == 0);
unknown's avatar
unknown committed
2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099
  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)
  {
unknown's avatar
unknown committed
2100 2101
    if (table->s->table_cache_key.length == key_length &&
	!memcmp(table->s->table_cache_key.str, key, key_length))
unknown's avatar
unknown committed
2102 2103 2104 2105 2106 2107
      return table;
  }
  return(0);
}


unknown's avatar
unknown committed
2108 2109
/*
  Reopen an table because the definition has changed.
unknown's avatar
unknown committed
2110

unknown's avatar
unknown committed
2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124
  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.
*/

static bool reopen_table(TABLE *table)
unknown's avatar
unknown committed
2125 2126
{
  TABLE tmp;
2127
  bool error= 1;
unknown's avatar
unknown committed
2128 2129
  Field **field;
  uint key,part;
unknown's avatar
unknown committed
2130 2131
  TABLE_LIST table_list;
  THD *thd= table->in_use;
unknown's avatar
unknown committed
2132 2133
  DBUG_ENTER("reopen_table");

unknown's avatar
unknown committed
2134 2135 2136
  DBUG_ASSERT(table->s->ref_count == 0);
  DBUG_ASSERT(!table->sort.io_cache);

unknown's avatar
unknown committed
2137 2138 2139
#ifdef EXTRA_DEBUG
  if (table->db_stat)
    sql_print_error("Table %s had a open data handler in reopen_table",
2140
		    table->alias);
unknown's avatar
unknown committed
2141 2142
#endif

unknown's avatar
unknown committed
2143 2144 2145 2146 2147
  table_list.db=         table->s->db.str;
  table_list.table_name= table->s->table_name.str;
  table_list.table=      table;
  table_list.belong_to_view= 0;
  table_list.next_local= 0;
unknown's avatar
unknown committed
2148

unknown's avatar
unknown committed
2149 2150 2151 2152 2153 2154 2155 2156
  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,
                        thd->mem_root))
unknown's avatar
unknown committed
2157 2158
    goto end;

2159
  /* This list copies variables set by open_table */
unknown's avatar
unknown committed
2160 2161 2162 2163
  tmp.tablenr=		table->tablenr;
  tmp.used_fields=	table->used_fields;
  tmp.const_table=	table->const_table;
  tmp.null_row=		table->null_row;
2164
  tmp.maybe_null=	table->maybe_null;
unknown's avatar
unknown committed
2165
  tmp.status=		table->status;
2166 2167
  tmp.keys_in_use_for_query= tmp.s->keys_in_use;
  tmp.used_keys= 	tmp.s->keys_for_keyread;
2168

2169 2170
  tmp.s->table_map_id=  table->s->table_map_id;

2171
  /* Get state */
unknown's avatar
unknown committed
2172
  tmp.in_use=    	thd;
2173
  tmp.reginfo.lock_type=table->reginfo.lock_type;
unknown's avatar
unknown committed
2174 2175
  tmp.grant=		table->grant;

2176
  /* Replace table in open list */
2177 2178
  tmp.next=		table->next;
  tmp.prev=		table->prev;
2179

2180
  delete table->triggers;
unknown's avatar
unknown committed
2181
  if (table->file)
unknown's avatar
unknown committed
2182
    VOID(closefrm(table, 1));		// close file, free everything
unknown's avatar
unknown committed
2183

2184
  *table= tmp;
unknown's avatar
unknown committed
2185
  table->file->change_table_ptr(table, table->s);
unknown's avatar
unknown committed
2186

2187
  DBUG_ASSERT(table->alias != 0);
unknown's avatar
unknown committed
2188 2189
  for (field=table->field ; *field ; field++)
  {
unknown's avatar
unknown committed
2190
    (*field)->table= (*field)->orig_table= table;
2191
    (*field)->table_name= &table->alias;
unknown's avatar
unknown committed
2192
  }
2193
  for (key=0 ; key < table->s->keys ; key++)
2194
  {
unknown's avatar
unknown committed
2195
    for (part=0 ; part < table->key_info[key].usable_key_parts ; part++)
unknown's avatar
unknown committed
2196
      table->key_info[key].key_part[part].field->table= table;
2197
  }
2198 2199 2200
  if (table->triggers)
    table->triggers->set_table(table);

unknown's avatar
unknown committed
2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212
  VOID(pthread_cond_broadcast(&COND_refresh));
  error=0;

 end:
  DBUG_RETURN(error);
}


/*
  Used with ALTER TABLE:
  Close all instanses of table when LOCK TABLES is in used;
  Close first all instances of table and then reopen them
unknown's avatar
unknown committed
2213
*/
unknown's avatar
unknown committed
2214 2215 2216 2217

bool close_data_tables(THD *thd,const char *db, const char *table_name)
{
  TABLE *table;
unknown's avatar
unknown committed
2218 2219
  DBUG_ENTER("close_data_tables");

unknown's avatar
unknown committed
2220 2221
  for (table=thd->open_tables; table ; table=table->next)
  {
unknown's avatar
unknown committed
2222 2223
    if (!strcmp(table->s->table_name.str, table_name) &&
	!strcmp(table->s->db.str, db))
unknown's avatar
unknown committed
2224 2225
    {
      mysql_lock_remove(thd, thd->locked_tables,table);
unknown's avatar
unknown committed
2226
      close_handle_and_leave_table_as_lock(table);
unknown's avatar
unknown committed
2227 2228
    }
  }
unknown's avatar
unknown committed
2229
  DBUG_RETURN(0);                               // For the future
unknown's avatar
unknown committed
2230 2231 2232 2233 2234 2235 2236 2237 2238 2239
}


/*
  Reopen all tables with closed data files
  One should have lock on LOCK_open when calling this
*/

bool reopen_tables(THD *thd,bool get_locks,bool in_refresh)
{
unknown's avatar
unknown committed
2240 2241 2242
  TABLE *table,*next,**prev;
  TABLE **tables,**tables_ptr;			// For locks
  bool error=0, not_used;
unknown's avatar
unknown committed
2243
  DBUG_ENTER("reopen_tables");
2244

unknown's avatar
unknown committed
2245 2246 2247
  if (!thd->open_tables)
    DBUG_RETURN(0);

unknown's avatar
unknown committed
2248
  safe_mutex_assert_owner(&LOCK_open);
unknown's avatar
unknown committed
2249 2250 2251 2252
  if (get_locks)
  {
    /* The ptr is checked later */
    uint opens=0;
unknown's avatar
unknown committed
2253 2254
    for (table= thd->open_tables; table ; table=table->next)
      opens++;
unknown's avatar
unknown committed
2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265
    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;
unknown's avatar
unknown committed
2266
    if (!tables || (!db_stat && reopen_table(table)))
unknown's avatar
unknown committed
2267
    {
2268
      my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
unknown's avatar
unknown committed
2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279
      VOID(hash_delete(&open_cache,(byte*) table));
      error=1;
    }
    else
    {
      *prev= table;
      prev= &table->next;
      if (get_locks && !db_stat)
	*tables_ptr++= table;			// need new lock on this
      if (in_refresh)
      {
2280
	table->s->version=0;
unknown's avatar
unknown committed
2281 2282 2283 2284 2285 2286 2287 2288 2289
	table->locked_by_flush=0;
      }
    }
  }
  if (tables != tables_ptr)			// Should we get back old locks
  {
    MYSQL_LOCK *lock;
    /* We should always get these locks */
    thd->some_tables_deleted=0;
2290 2291
    if ((lock= mysql_lock_tables(thd, tables, (uint) (tables_ptr - tables),
                                 0, &not_used)))
unknown's avatar
unknown committed
2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306
    {
      thd->locked_tables=mysql_lock_merge(thd->locked_tables,lock);
    }
    else
      error=1;
  }
  if (get_locks && tables)
  {
    my_afree((gptr) tables);
  }
  VOID(pthread_cond_broadcast(&COND_refresh)); // Signal to refresh
  *prev=0;
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
2307

unknown's avatar
unknown committed
2308 2309 2310 2311 2312 2313
/*
  Close handlers for tables in list, but leave the TABLE structure
  intact so that we can re-open these quickly
  abort_locks is set if called from flush_tables.
*/

unknown's avatar
unknown committed
2314 2315
void close_old_data_files(THD *thd, TABLE *table, bool abort_locks,
			  bool send_refresh)
unknown's avatar
unknown committed
2316
{
unknown's avatar
unknown committed
2317
  bool found= send_refresh;
unknown's avatar
unknown committed
2318
  DBUG_ENTER("close_old_data_files");
unknown's avatar
unknown committed
2319

unknown's avatar
unknown committed
2320 2321
  for (; table ; table=table->next)
  {
2322
    if (table->s->version != refresh_version)
unknown's avatar
unknown committed
2323 2324 2325 2326 2327 2328
    {
      found=1;
      if (table->db_stat)
      {
	if (abort_locks)
	{
unknown's avatar
unknown committed
2329
	  mysql_lock_abort(thd,table, TRUE);	// Close waiting threads
unknown's avatar
unknown committed
2330 2331 2332
	  mysql_lock_remove(thd, thd->locked_tables,table);
	  table->locked_by_flush=1;		// Will be reopened with locks
	}
unknown's avatar
unknown committed
2333
        close_handle_and_leave_table_as_lock(table);
unknown's avatar
unknown committed
2334 2335 2336 2337 2338
      }
    }
  }
  if (found)
    VOID(pthread_cond_broadcast(&COND_refresh)); // Signal to refresh
unknown's avatar
unknown committed
2339
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2340 2341 2342 2343 2344 2345 2346
}


/*
  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
2347 2348 2349 2350
  NOTE: log tables are handled differently by the logging routines.
        E.g. general_log is always opened and locked by the logger
        and the table handler used by the logger, will be skipped by
        this check.
unknown's avatar
unknown committed
2351 2352
*/

unknown's avatar
unknown committed
2353
bool table_is_used(TABLE *table, bool wait_for_name_lock)
unknown's avatar
unknown committed
2354
{
unknown's avatar
unknown committed
2355
  DBUG_ENTER("table_is_used");
unknown's avatar
unknown committed
2356 2357
  do
  {
unknown's avatar
unknown committed
2358 2359 2360 2361
    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));
unknown's avatar
unknown committed
2362 2363
    HASH_SEARCH_STATE state;
    for (TABLE *search= (TABLE*) hash_first(&open_cache, (byte*) key,
2364
                                             key_length, &state);
unknown's avatar
unknown committed
2365
	 search ;
2366 2367
         search= (TABLE*) hash_next(&open_cache, (byte*) key,
                                    key_length, &state))
unknown's avatar
unknown committed
2368
    {
2369 2370 2371 2372
      DBUG_PRINT("info", ("share: 0x%lx  locked_by_logger: %d "
                          "locked_by_flush: %d  locked_by_name: %d "
                          "db_stat: %u  version: %u",
                          (ulong) search->s, search->locked_by_logger,
unknown's avatar
unknown committed
2373 2374 2375 2376 2377 2378 2379 2380 2381 2382
                          search->locked_by_flush, search->locked_by_name,
                          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
2383 2384 2385
        (We must wait until all engines are shut down to use the table)
        However we fo not wait if we encountered a table, locked by the logger.
        Log tables are managed separately by logging routines.
unknown's avatar
unknown committed
2386
      */
2387 2388 2389 2390
      if (!search->locked_by_logger &&
          (search->locked_by_name && wait_for_name_lock ||
           search->locked_by_flush ||
           (search->db_stat && search->s->version < refresh_version)))
2391
        DBUG_RETURN(1);
unknown's avatar
unknown committed
2392 2393
    }
  } while ((table=table->next));
unknown's avatar
unknown committed
2394
  DBUG_RETURN(0);
unknown's avatar
unknown committed
2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406
}


/* Wait until all used tables are refreshed */

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

  thd->proc_info="Waiting for tables";
  pthread_mutex_lock(&LOCK_open);
unknown's avatar
unknown committed
2407
  while (!thd->killed)
unknown's avatar
unknown committed
2408
  {
unknown's avatar
unknown committed
2409 2410
    thd->some_tables_deleted=0;
    close_old_data_files(thd,thd->open_tables,0,dropping_tables != 0);
2411
    mysql_ha_flush(thd, (TABLE_LIST*) NULL, MYSQL_HA_REOPEN_ON_USAGE, TRUE);
unknown's avatar
unknown committed
2412 2413
    if (!table_is_used(thd->open_tables,1))
      break;
2414
    (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
unknown's avatar
unknown committed
2415 2416 2417 2418 2419 2420 2421
  }
  if (thd->killed)
    result= 1;					// aborted
  else
  {
    /* Now we can open all tables without any interference */
    thd->proc_info="Reopen tables";
unknown's avatar
unknown committed
2422
    thd->version= refresh_version;
2423
    result=reopen_tables(thd,0,0);
2424
  }
unknown's avatar
unknown committed
2425 2426 2427 2428 2429 2430
  pthread_mutex_unlock(&LOCK_open);
  thd->proc_info=0;
  DBUG_RETURN(result);
}


2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447
/*
  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.
unknown's avatar
unknown committed
2448

2449 2450 2451 2452 2453
  RETURN
    #    If table existed, return table
    0	 Table was not locked
*/

unknown's avatar
unknown committed
2454

2455
TABLE *drop_locked_tables(THD *thd,const char *db, const char *table_name)
unknown's avatar
unknown committed
2456
{
2457
  TABLE *table,*next,**prev, *found= 0;
unknown's avatar
unknown committed
2458
  prev= &thd->open_tables;
2459 2460
  DBUG_ENTER("drop_locked_tables");

2461
  for (table= thd->open_tables; table ; table=next)
unknown's avatar
unknown committed
2462 2463
  {
    next=table->next;
unknown's avatar
unknown committed
2464 2465
    if (!strcmp(table->s->table_name.str, table_name) &&
	!strcmp(table->s->db.str, db))
unknown's avatar
unknown committed
2466 2467
    {
      mysql_lock_remove(thd, thd->locked_tables,table);
2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482
      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 */
        VOID(hash_delete(&open_cache,(byte*) table));
      }
unknown's avatar
unknown committed
2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495
    }
    else
    {
      *prev=table;
      prev= &table->next;
    }
  }
  *prev=0;
  if (thd->locked_tables && thd->locked_tables->table_count == 0)
  {
    my_free((gptr) thd->locked_tables,MYF(0));
    thd->locked_tables=0;
  }
2496
  DBUG_RETURN(found);
unknown's avatar
unknown committed
2497 2498 2499
}


2500 2501 2502 2503 2504
/*
  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.
*/
unknown's avatar
unknown committed
2505 2506 2507 2508

void abort_locked_tables(THD *thd,const char *db, const char *table_name)
{
  TABLE *table;
2509
  for (table= thd->open_tables; table ; table= table->next)
unknown's avatar
unknown committed
2510
  {
unknown's avatar
unknown committed
2511 2512
    if (!strcmp(table->s->table_name.str, table_name) &&
	!strcmp(table->s->db.str, db))
2513
    {
unknown's avatar
unknown committed
2514
      mysql_lock_abort(thd,table, TRUE);
2515 2516
      break;
    }
unknown's avatar
unknown committed
2517 2518 2519
  }
}

2520

2521
/*
2522
  Function to assign a new table map id to a table share.
2523 2524 2525

  PARAMETERS

2526
    share - Pointer to table share structure
2527

unknown's avatar
unknown committed
2528 2529 2530 2531 2532 2533 2534
  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).

2535 2536
  PRE-CONDITION(S)

2537
    share is non-NULL
2538 2539 2540 2541
    The LOCK_open mutex is locked

  POST-CONDITION(S)

2542 2543 2544 2545
    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
    shares open at the same time).
2546

2547
    share->table_map_id is not ~0UL.
2548
 */
2549
void assign_new_table_id(TABLE_SHARE *share)
2550
{
2551
  static ulong last_table_id= ~0UL;
2552

2553
  DBUG_ENTER("assign_new_table_id");
2554 2555

  /* Preconditions */
2556
  DBUG_ASSERT(share != NULL);
2557 2558 2559
  safe_mutex_assert_owner(&LOCK_open);

  ulong tid= ++last_table_id;                   /* get next id */
2560 2561 2562 2563
  /*
    There is one reserved number that cannot be used.  Remember to
    change this when 6-byte global table id's are introduced.
  */
2564
  if (unlikely(tid == ~0UL))
2565
    tid= ++last_table_id;
2566
  share->table_map_id= tid;
2567 2568 2569
  DBUG_PRINT("info", ("table_id=%lu", tid));

  /* Post conditions */
2570
  DBUG_ASSERT(share->table_map_id != ~0UL);
2571 2572 2573 2574

  DBUG_VOID_RETURN;
}

2575 2576 2577 2578 2579 2580 2581
/*
  Load a table definition from file and open unireg table

  SYNOPSIS
    open_unireg_entry()
    thd			Thread handle
    entry		Store open table definition here
unknown's avatar
unknown committed
2582
    table_list		TABLE_LIST with db, table_name & belong_to_view
2583
    alias		Alias name
unknown's avatar
unknown committed
2584 2585
    cache_key		Key for share_cache
    cache_key_length	length of cache_key
unknown's avatar
VIEW  
unknown committed
2586
    mem_root		temporary mem_root for parsing
2587 2588 2589

  NOTES
   Extra argument for open is taken from thd->open_options
unknown's avatar
unknown committed
2590
   One must have a lock on LOCK_open when calling this function
2591 2592 2593 2594

  RETURN
    0	ok
    #	Error
unknown's avatar
unknown committed
2595
*/
unknown's avatar
unknown committed
2596 2597 2598

static int open_unireg_entry(THD *thd, TABLE *entry, TABLE_LIST *table_list,
                             const char *alias,
2599
                             char *cache_key, uint cache_key_length,
unknown's avatar
unknown committed
2600
                             MEM_ROOT *mem_root)
unknown's avatar
unknown committed
2601
{
2602
  int error;
unknown's avatar
unknown committed
2603
  TABLE_SHARE *share;
unknown's avatar
unknown committed
2604
  uint discover_retry_count= 0;
unknown's avatar
unknown committed
2605 2606
  DBUG_ENTER("open_unireg_entry");

unknown's avatar
unknown committed
2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629
  safe_mutex_assert_owner(&LOCK_open);

retry:
  if (!(share= get_table_share_with_create(thd, table_list, cache_key,
                                           cache_key_length, 
                                           OPEN_VIEW, &error)))
    DBUG_RETURN(1);

  if (share->is_view)
  {
    /* Open view */
    error= (int) open_new_frm(thd, share, alias,
                              (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
                                      HA_GET_INDEX | HA_TRY_READ_ONLY),
                              READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
                              thd->open_options, entry, table_list,
                              mem_root);
    if (error)
      goto err;
    /* TODO: Don't free this */
    release_table_share(share, RELEASE_NORMAL);
    DBUG_RETURN(0);
  }
unknown's avatar
VIEW  
unknown committed
2630

unknown's avatar
unknown committed
2631 2632 2633 2634 2635 2636 2637
  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),
unknown's avatar
unknown committed
2638
                                       thd->open_options, entry, FALSE)))
unknown's avatar
unknown committed
2639
  {
unknown's avatar
unknown committed
2640
    if (error == 7)                             // Table def changed
unknown's avatar
unknown committed
2641
    {
unknown's avatar
unknown committed
2642 2643 2644 2645
      share->version= 0;                        // Mark share as old
      if (discover_retry_count++)               // Retry once
        goto err;

unknown's avatar
unknown committed
2646
      /*
unknown's avatar
unknown committed
2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657
        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
unknown's avatar
unknown committed
2658
      */
unknown's avatar
unknown committed
2659 2660
      if (ha_create_table_from_engine(thd, table_list->db,
                                      table_list->table_name))
unknown's avatar
unknown committed
2661
        goto err;
unknown's avatar
unknown committed
2662 2663 2664 2665 2666 2667
      /*
        TO BE FIXED
        To avoid deadlock, only wait for release if no one else is
        using the share.
      */
      if (share->ref_count != 1)
unknown's avatar
unknown committed
2668
        goto err;
unknown's avatar
unknown committed
2669 2670 2671
      /* Free share and wait until it's released by all threads */
      release_table_share(share, RELEASE_WAIT_FOR_DROP);
      if (!thd->killed)
2672
      {
unknown's avatar
unknown committed
2673 2674 2675
        mysql_reset_errors(thd, 1);         // Clear warnings
        thd->clear_error();                 // Clear error message
        goto retry;
2676
      }
unknown's avatar
unknown committed
2677
      DBUG_RETURN(1);
2678
    }
unknown's avatar
unknown committed
2679
    if (!entry->s || !entry->s->crashed)
2680
      goto err;
unknown's avatar
VIEW  
unknown committed
2681

unknown's avatar
unknown committed
2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701
     // Code below is for repairing a crashed file
     if ((error= lock_table_name(thd, table_list)))
     {
       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,
unknown's avatar
unknown committed
2702
                               entry, FALSE) || ! entry->file ||
unknown's avatar
unknown committed
2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722
 	(entry->file->is_crashed() && entry->file->check_and_repair(thd)))
     {
       /* Give right error message */
       thd->clear_error();
       my_error(ER_NOT_KEYFILE, MYF(0), share->table_name.str, my_errno);
       sql_print_error("Couldn't repair table: %s.%s", share->db.str,
                       share->table_name.str);
       if (entry->file)
 	closefrm(entry, 0);
       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;
   }
2723

unknown's avatar
unknown committed
2724 2725 2726 2727
  if (Table_triggers_list::check_n_load(thd, share->db.str,
                                        share->table_name.str, entry, 0))
  {
    closefrm(entry, 0);
2728
    goto err;
unknown's avatar
unknown committed
2729
  }
2730

unknown's avatar
unknown committed
2731 2732 2733 2734 2735 2736 2737 2738 2739 2740
  /*
    If we are here, there was no fatal error (but error may be still
    unitialized).
  */
  if (unlikely(entry->file->implicit_emptied))
  {
    entry->file->implicit_emptied= 0;
    if (mysql_bin_log.is_open())
    {
      char *query, *end;
unknown's avatar
unknown committed
2741 2742
      uint query_buf_size= 20 + share->db.length + share->table_name.length +1;
      if ((query= (char*) my_malloc(query_buf_size,MYF(MY_WME))))
unknown's avatar
unknown committed
2743
      {
2744
        /* this DELETE FROM is needed even with row-based binlogging */
unknown's avatar
unknown committed
2745
        end = strxmov(strmov(query, "DELETE FROM `"),
unknown's avatar
unknown committed
2746
                      share->db.str,"`.`",share->table_name.str,"`", NullS);
2747 2748
        thd->binlog_query(THD::STMT_QUERY_TYPE,
                          query, (ulong)(end-query), FALSE, FALSE);
unknown's avatar
unknown committed
2749 2750 2751 2752 2753 2754 2755 2756 2757
        my_free(query, MYF(0));
      }
      else
      {
        /*
          As replication is maybe going to be corrupted, we need to warn the
          DBA on top of warning the client (which will automatically be done
          because of MYF(MY_WME) in my_malloc() above).
        */
unknown's avatar
unknown committed
2758 2759 2760
        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);
2761
        delete entry->triggers;
unknown's avatar
unknown committed
2762
        closefrm(entry, 0);
unknown's avatar
unknown committed
2763 2764 2765
        goto err;
      }
    }
unknown's avatar
unknown committed
2766 2767
  }
  DBUG_RETURN(0);
unknown's avatar
unknown committed
2768

2769
err:
unknown's avatar
unknown committed
2770
  release_table_share(share, RELEASE_NORMAL);
2771
  DBUG_RETURN(1);
unknown's avatar
unknown committed
2772 2773
}

2774

unknown's avatar
unknown committed
2775 2776 2777 2778 2779 2780
/*
  Open all tables in list

  SYNOPSIS
    open_tables()
    thd - thread handler
2781
    start - list of tables in/out
unknown's avatar
unknown committed
2782
    counter - number of opened tables will be return using this parameter
2783 2784 2785
    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.
unknown's avatar
unknown committed
2786

2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797
  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.

unknown's avatar
unknown committed
2798 2799 2800 2801 2802
  RETURN
    0  - OK
    -1 - error
*/

2803
int open_tables(THD *thd, TABLE_LIST **start, uint *counter, uint flags)
unknown's avatar
unknown committed
2804 2805 2806 2807
{
  TABLE_LIST *tables;
  bool refresh;
  int result=0;
unknown's avatar
VIEW  
unknown committed
2808
  MEM_ROOT new_frm_mem;
2809 2810 2811
  /* Also used for indicating that prelocking is need */
  TABLE_LIST **query_tables_last_own;
  DBUG_ENTER("open_tables");
unknown's avatar
VIEW  
unknown committed
2812 2813 2814 2815 2816
  /*
    temporary mem_root for new .frm parsing.
    TODO: variables for size
  */
  init_alloc_root(&new_frm_mem, 8024, 8024);
unknown's avatar
unknown committed
2817

2818
  thd->current_tablenr= 0;
unknown's avatar
unknown committed
2819
 restart:
unknown's avatar
unknown committed
2820
  *counter= 0;
2821
  query_tables_last_own= 0;
unknown's avatar
unknown committed
2822
  thd->proc_info="Opening tables";
2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834

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

    NOTE: We will mark statement as requiring prelocking only if we will
    have non empty table list. But this does not guarantee that in prelocked
    mode we will have some locked tables, because queries which use only
    derived/information schema tables and views possible. Thus "counter"
    may be still zero for prelocked statement...
  */
2835 2836

  if (!thd->prelocked_mode && !thd->lex->requires_prelocking() &&
2837
      thd->lex->sroutines_list.elements)
2838
  {
2839
    bool first_no_prelocking, need_prelocking, tabs_changed;
2840
    TABLE_LIST **save_query_tables_last= thd->lex->query_tables_last;
2841 2842

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

2845 2846
    if (sp_cache_routines_and_add_tables(thd, thd->lex,
                                         first_no_prelocking,
2847
                                         &tabs_changed))
2848
    {
2849 2850 2851 2852 2853 2854
      /*
        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;
2855 2856 2857
      goto err;
    }
    else if ((tabs_changed || *start) && need_prelocking)
2858 2859 2860 2861 2862 2863 2864
    {
      query_tables_last_own= save_query_tables_last;
      *start= thd->lex->query_tables;
    }
  }

  for (tables= *start; tables ;tables= tables->next_global)
unknown's avatar
unknown committed
2865
  {
unknown's avatar
unknown committed
2866 2867 2868
    /*
      Ignore placeholders for derived tables. After derived tables
      processing, link to created temporary table will be put here.
2869 2870
      If this is derived table for view then we still want to process
      routines used by this view.
unknown's avatar
unknown committed
2871 2872
     */
    if (tables->derived)
2873 2874 2875
    {
      if (tables->view)
        goto process_view_routines;
unknown's avatar
unknown committed
2876
      continue;
2877
    }
2878 2879 2880 2881 2882 2883
    if (tables->schema_table)
    {
      if (!mysql_schema_table(thd, thd->lex, tables))
        continue;
      DBUG_RETURN(-1);
    }
unknown's avatar
unknown committed
2884
    (*counter)++;
2885
    
unknown's avatar
unknown committed
2886
    if (!tables->table &&
2887
	!(tables->table= open_table(thd, tables, &new_frm_mem, &refresh, flags)))
unknown's avatar
unknown committed
2888
    {
unknown's avatar
VIEW  
unknown committed
2889
      free_root(&new_frm_mem, MYF(MY_KEEP_PREALLOC));
2890

unknown's avatar
VIEW  
unknown committed
2891 2892
      if (tables->view)
      {
2893
        /* VIEW placeholder */
unknown's avatar
VIEW  
unknown committed
2894
	(*counter)--;
2895

2896
        /*
2897 2898 2899 2900 2901
          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
2902 2903 2904
          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.
2905
        */
unknown's avatar
unknown committed
2906
        if (query_tables_last_own == &(tables->next_global) &&
2907 2908
            tables->view->query_tables)
          query_tables_last_own= tables->view->query_tables_last;
2909
        /*
2910 2911
          Let us free memory used by 'sroutines' hash here since we never
          call destructor for this LEX.
2912
        */
2913
        hash_free(&tables->view->sroutines);
2914
	goto process_view_routines;
unknown's avatar
VIEW  
unknown committed
2915 2916
      }

unknown's avatar
unknown committed
2917 2918
      if (refresh)				// Refresh in progress
      {
2919
        /*
2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931
          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.
2932 2933 2934
        */
        if (query_tables_last_own)
          thd->lex->mark_as_requiring_prelocking(query_tables_last_own);
2935
        close_tables_for_reopen(thd, start);
unknown's avatar
unknown committed
2936 2937 2938 2939 2940
	goto restart;
      }
      result= -1;				// Fatal error
      break;
    }
unknown's avatar
VIEW  
unknown committed
2941
    else
2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955
    {
      /*
        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() &&
          tables->table->triggers &&
          tables->lock_type >= TL_WRITE_ALLOW_WRITE)
      {
        if (!query_tables_last_own)
2956 2957
          query_tables_last_own= thd->lex->query_tables_last;
        if (sp_cache_routines_and_add_tables_for_triggers(thd, thd->lex,
2958
                                                          tables))
2959
        {
2960 2961 2962 2963 2964 2965
          /*
            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;
2966 2967
          goto err;
        }
2968
      }
unknown's avatar
VIEW  
unknown committed
2969
      free_root(&new_frm_mem, MYF(MY_KEEP_PREALLOC));
2970
    }
unknown's avatar
VIEW  
unknown committed
2971

2972
    if (tables->lock_type != TL_UNLOCK && ! thd->locked_tables)
unknown's avatar
unknown committed
2973 2974
      tables->table->reginfo.lock_type=tables->lock_type;
    tables->table->grant= tables->grant;
2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987

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() &&
        tables->view->sroutines_list.elements)
    {
      /* We have at least one table in TL here. */
      if (!query_tables_last_own)
        query_tables_last_own= thd->lex->query_tables_last;
2988
      if (sp_cache_routines_and_add_tables_for_view(thd, thd->lex, tables))
2989
      {
2990 2991 2992 2993 2994 2995
        /*
          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;
2996 2997
        goto err;
      }
2998
    }
unknown's avatar
unknown committed
2999
  }
3000 3001

 err:
unknown's avatar
unknown committed
3002
  thd->proc_info=0;
3003
  free_root(&new_frm_mem, MYF(0));              // Free pre-alloced block
3004 3005 3006 3007

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

unknown's avatar
unknown committed
3008 3009 3010 3011
  DBUG_RETURN(result);
}


unknown's avatar
unknown committed
3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034
/*
  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)
  {
3035
    my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),table->alias);
unknown's avatar
unknown committed
3036 3037
    DBUG_RETURN(1);
  }
unknown's avatar
unknown committed
3038
  if ((error=table->file->start_stmt(thd, lock_type)))
unknown's avatar
unknown committed
3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055
  {
    table->file->print_error(error,MYF(0));
    DBUG_RETURN(1);
  }
  DBUG_RETURN(0);
}


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

3056 3057 3058 3059 3060
  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.

unknown's avatar
unknown committed
3061 3062 3063 3064 3065 3066 3067 3068 3069
  RETURN VALUES
    table		Opened table
    0			Error
  
    If ok, the following are also set:
      table_list->lock_type 	lock_type
      table_list->table		table
*/

unknown's avatar
unknown committed
3070 3071 3072 3073 3074 3075 3076
TABLE *open_ltable(THD *thd, TABLE_LIST *table_list, thr_lock_type lock_type)
{
  TABLE *table;
  bool refresh;
  DBUG_ENTER("open_ltable");

  thd->proc_info="Opening table";
3077
  thd->current_tablenr= 0;
3078 3079
  /* open_ltable can be used only for BASIC TABLEs */
  table_list->required_type= FRMTYPE_TABLE;
3080
  while (!(table= open_table(thd, table_list, thd->mem_root, &refresh, 0)) &&
3081
         refresh)
3082
    ;
unknown's avatar
unknown committed
3083

unknown's avatar
unknown committed
3084 3085
  if (table)
  {
3086
#if defined( __WIN__)
3087
    /* Win32 can't drop a file that is open */
unknown's avatar
unknown committed
3088
    if (lock_type == TL_WRITE_ALLOW_READ)
3089 3090 3091
    {
      lock_type= TL_WRITE;
    }
3092
#endif /* __WIN__ */
unknown's avatar
unknown committed
3093 3094
    table_list->lock_type= lock_type;
    table_list->table=	   table;
unknown's avatar
unknown committed
3095 3096 3097
    table->grant= table_list->grant;
    if (thd->locked_tables)
    {
unknown's avatar
unknown committed
3098 3099 3100 3101 3102
      if (check_lock_and_start_stmt(thd, table, lock_type))
	table= 0;
    }
    else
    {
3103
      DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
unknown's avatar
unknown committed
3104
      if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)
3105 3106
	if (! (thd->lock= mysql_lock_tables(thd, &table_list->table, 1, 0,
                                            &refresh)))
unknown's avatar
unknown committed
3107
	  table= 0;
unknown's avatar
unknown committed
3108 3109 3110 3111 3112 3113
    }
  }
  thd->proc_info=0;
  DBUG_RETURN(table);
}

unknown's avatar
unknown committed
3114

unknown's avatar
unknown committed
3115
/*
unknown's avatar
unknown committed
3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128
  Open all tables in list and locks them for read without derived
  tables processing.

  SYNOPSIS
    simple_open_n_lock_tables()
    thd		- thread handler
    tables	- list of tables for open&locking

  RETURN
    0  - ok
    -1 - error

  NOTE
3129
    The lock will automaticaly be freed by close_thread_tables()
unknown's avatar
unknown committed
3130 3131
*/

unknown's avatar
unknown committed
3132
int simple_open_n_lock_tables(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
3133
{
unknown's avatar
unknown committed
3134
  uint counter;
3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145
  bool need_reopen;
  DBUG_ENTER("simple_open_n_lock_tables");

  for ( ; ; ) 
  {
    if (open_tables(thd, &tables, &counter, 0))
      DBUG_RETURN(-1);
    if (!lock_tables(thd, tables, counter, &need_reopen))
      break;
    if (!need_reopen)
      DBUG_RETURN(-1);
3146
    close_tables_for_reopen(thd, &tables);
3147
  }
unknown's avatar
unknown committed
3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161
  DBUG_RETURN(0);
}


/*
  Open all tables in list, locks them and process derived tables
  tables processing.

  SYNOPSIS
    open_and_lock_tables()
    thd		- thread handler
    tables	- list of tables for open&locking

  RETURN
unknown's avatar
unknown committed
3162 3163
    FALSE - ok
    TRUE  - error
unknown's avatar
unknown committed
3164 3165

  NOTE
3166
    The lock will automaticaly be freed by close_thread_tables()
unknown's avatar
unknown committed
3167 3168
*/

unknown's avatar
unknown committed
3169
bool open_and_lock_tables(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
3170 3171
{
  uint counter;
3172
  bool need_reopen;
unknown's avatar
unknown committed
3173
  DBUG_ENTER("open_and_lock_tables");
3174 3175 3176 3177 3178 3179 3180 3181 3182

  for ( ; ; ) 
  {
    if (open_tables(thd, &tables, &counter, 0))
      DBUG_RETURN(-1);
    if (!lock_tables(thd, tables, counter, &need_reopen))
      break;
    if (!need_reopen)
      DBUG_RETURN(-1);
3183
    close_tables_for_reopen(thd, &tables);
3184 3185
  }
  if (mysql_handle_derived(thd->lex, &mysql_derived_prepare) ||
unknown's avatar
unknown committed
3186 3187
      (thd->fill_derived_tables() &&
       mysql_handle_derived(thd->lex, &mysql_derived_filling)))
unknown's avatar
unknown committed
3188
    DBUG_RETURN(TRUE); /* purecov: inspected */
unknown's avatar
unknown committed
3189
  DBUG_RETURN(0);
unknown's avatar
unknown committed
3190 3191 3192
}


3193 3194 3195 3196 3197 3198
/*
  Open all tables in list and process derived tables

  SYNOPSIS
    open_normal_and_derived_tables
    thd		- thread handler
3199
    tables	- list of tables for open
3200 3201 3202
    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.
3203 3204 3205 3206 3207 3208 3209 3210 3211 3212

  RETURN
    FALSE - ok
    TRUE  - error

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

3213
bool open_normal_and_derived_tables(THD *thd, TABLE_LIST *tables, uint flags)
3214 3215 3216
{
  uint counter;
  DBUG_ENTER("open_normal_and_derived_tables");
unknown's avatar
unknown committed
3217
  DBUG_ASSERT(!thd->fill_derived_tables());
3218
  if (open_tables(thd, &tables, &counter, flags) ||
unknown's avatar
unknown committed
3219 3220 3221
      mysql_handle_derived(thd->lex, &mysql_derived_prepare))
    DBUG_RETURN(TRUE); /* purecov: inspected */
  DBUG_RETURN(0);
3222 3223 3224
}


3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245
/*
  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)
    if (!table->placeholder() && !table->schema_table)
      table->table->query_id= 0;
}


unknown's avatar
unknown committed
3246 3247 3248 3249 3250 3251 3252
/*
  Lock all tables in list

  SYNOPSIS
    lock_tables()
    thd			Thread handler
    tables		Tables to lock
3253 3254 3255 3256 3257 3258
    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).
unknown's avatar
unknown committed
3259

3260 3261 3262 3263 3264
  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.

3265 3266 3267 3268
    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.

unknown's avatar
unknown committed
3269 3270 3271 3272 3273
  RETURN VALUES
   0	ok
   -1	Error
*/

3274
int lock_tables(THD *thd, TABLE_LIST *tables, uint count, bool *need_reopen)
unknown's avatar
unknown committed
3275
{
unknown's avatar
unknown committed
3276
  TABLE_LIST *table;
3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289

  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());
  /*
    If statement requires prelocking then it has non-empty table list.
    So it is safe to shortcut.
  */
  DBUG_ASSERT(!thd->lex->requires_prelocking() || tables);

3290 3291
  *need_reopen= FALSE;

unknown's avatar
unknown committed
3292
  if (!tables)
3293
    DBUG_RETURN(0);
unknown's avatar
unknown committed
3294

3295 3296 3297 3298 3299 3300 3301 3302 3303 3304
  /*
    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)
unknown's avatar
unknown committed
3305
  {
3306
    DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
unknown's avatar
unknown committed
3307
    TABLE **start,**ptr;
3308

3309
    if (!(ptr=start=(TABLE**) thd->alloc(sizeof(TABLE*)*count)))
3310
      DBUG_RETURN(-1);
unknown's avatar
VIEW  
unknown committed
3311
    for (table= tables; table; table= table->next_global)
unknown's avatar
unknown committed
3312
    {
unknown's avatar
unknown committed
3313
      if (!table->placeholder() && !table->schema_table)
unknown's avatar
unknown committed
3314 3315
	*(ptr++)= table->table;
    }
3316 3317 3318 3319 3320 3321 3322 3323

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

3324 3325 3326
    if (! (thd->lock= mysql_lock_tables(thd, start, (uint) (ptr - start),
                                        MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN,
                                        need_reopen)))
3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372
    {
      if (thd->lex->requires_prelocking())
      {
        thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
        thd->in_lock_tables=0;
      }
      DBUG_RETURN(-1);
    }
    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;

      for (table= tables; table != first_not_own; table= table->next_global)
      {
        if (!table->placeholder() && !table->schema_table)
        {
          table->table->query_id= thd->query_id;
          if (check_lock_and_start_stmt(thd, table->table, table->lock_type))
          {
            ha_rollback_stmt(thd);
            mysql_unlock_tables(thd, thd->locked_tables);
            thd->locked_tables= 0;
            thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
            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);
3373
      DBUG_PRINT("info",("prelocked_mode= PRELOCKED"));
3374 3375
      thd->prelocked_mode= PRELOCKED;
    }
unknown's avatar
unknown committed
3376
  }
unknown's avatar
unknown committed
3377 3378
  else
  {
3379 3380
    TABLE_LIST *first_not_own= thd->lex->first_not_own_table();
    for (table= tables; table != first_not_own; table= table->next_global)
unknown's avatar
unknown committed
3381
    {
3382
      if (!table->placeholder() && !table->schema_table &&
unknown's avatar
unknown committed
3383
	  check_lock_and_start_stmt(thd, table->table, table->lock_type))
unknown's avatar
unknown committed
3384
      {
unknown's avatar
unknown committed
3385
	ha_rollback_stmt(thd);
3386
	DBUG_RETURN(-1);
unknown's avatar
unknown committed
3387 3388
      }
    }
3389 3390 3391 3392 3393 3394 3395 3396
    /*
      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);
3397
      DBUG_PRINT("info", ("thd->prelocked_mode= PRELOCKED_UNDER_LOCK_TABLES"));
3398 3399
      thd->prelocked_mode= PRELOCKED_UNDER_LOCK_TABLES;
    }
unknown's avatar
unknown committed
3400
  }
3401
  DBUG_RETURN(0);
unknown's avatar
unknown committed
3402 3403
}

unknown's avatar
unknown committed
3404

3405 3406 3407 3408 3409 3410
/*
  Prepare statement for reopening of tables and recalculation of set of
  prelocked tables.

  SYNOPSIS
    close_tables_for_reopen()
3411 3412
      thd    in     Thread context
      tables in/out List of tables which we were trying to open and lock
3413 3414 3415

*/

3416
void close_tables_for_reopen(THD *thd, TABLE_LIST **tables)
3417
{
3418 3419 3420 3421 3422 3423
  /*
    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;
3424 3425
  thd->lex->chop_off_not_own_tables();
  sp_remove_not_own_routines(thd->lex);
3426 3427 3428
  for (TABLE_LIST *tmp= *tables; tmp; tmp= tmp->next_global)
    tmp->table= 0;
  mark_used_tables_as_free_for_reuse(thd, thd->temporary_tables);
3429 3430 3431 3432
  close_thread_tables(thd);
}


unknown's avatar
unknown committed
3433
/*
unknown's avatar
unknown committed
3434
  Open a single table without table caching and don't set it in open_list
unknown's avatar
unknown committed
3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450

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

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

 RETURN
   0  Error
   #  TABLE object
unknown's avatar
unknown committed
3451 3452 3453 3454 3455 3456
*/

TABLE *open_temporary_table(THD *thd, const char *path, const char *db,
			    const char *table_name, bool link_in_list)
{
  TABLE *tmp_table;
3457
  TABLE_SHARE *share;
unknown's avatar
unknown committed
3458 3459 3460
  char cache_key[MAX_DBKEY_LENGTH], *saved_cache_key, *tmp_path;
  uint key_length;
  TABLE_LIST table_list;
unknown's avatar
unknown committed
3461
  DBUG_ENTER("open_temporary_table");
3462

unknown's avatar
unknown committed
3463 3464 3465 3466 3467 3468 3469 3470
  table_list.db=         (char*) db;
  table_list.table_name= (char*) table_name;
  /* Create the cache_key for temporary tables */
  key_length= create_table_def_key(thd, cache_key, &table_list, 1);

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

unknown's avatar
unknown committed
3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486
  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);

  init_tmp_table_share(share, saved_cache_key, key_length,
                       strend(saved_cache_key)+1, tmp_path);

  if (open_table_def(thd, share, 0) ||
      open_table_from_share(thd, share, table_name,
                            (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
                                    HA_GET_INDEX),
                            READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
                            ha_open_options,
unknown's avatar
unknown committed
3487
                            tmp_table, FALSE))
unknown's avatar
unknown committed
3488
  {
unknown's avatar
unknown committed
3489 3490
    /* No need to lock share->mutex as this is not needed for tmp tables */
    free_table_share(share);
3491
    my_free((char*) tmp_table,MYF(0));
unknown's avatar
unknown committed
3492 3493 3494
    DBUG_RETURN(0);
  }

unknown's avatar
unknown committed
3495
  tmp_table->reginfo.lock_type= TL_WRITE;	 // Simulate locked
3496 3497
  share->tmp_table= (tmp_table->file->has_transactions() ? 
                     TRANSACTIONAL_TMP_TABLE : TMP_TABLE);
3498

unknown's avatar
unknown committed
3499 3500
  if (link_in_list)
  {
unknown's avatar
unknown committed
3501 3502 3503 3504
    tmp_table->open_prev= &thd->temporary_tables;
    if ((tmp_table->next= thd->temporary_tables))
      thd->temporary_tables->open_prev= &tmp_table->next;
    thd->temporary_tables= tmp_table;
unknown's avatar
unknown committed
3505 3506
    if (thd->slave_thread)
      slave_open_temp_tables++;
unknown's avatar
unknown committed
3507 3508 3509 3510 3511
  }
  DBUG_RETURN(tmp_table);
}


unknown's avatar
unknown committed
3512
bool rm_temporary_table(handlerton *base, char *path)
unknown's avatar
unknown committed
3513 3514
{
  bool error=0;
unknown's avatar
unknown committed
3515 3516
  handler *file;
  char *ext;
3517 3518
  DBUG_ENTER("rm_temporary_table");

unknown's avatar
unknown committed
3519
  strmov(ext= strend(path), reg_ext);
unknown's avatar
unknown committed
3520 3521
  if (my_delete(path,MYF(0)))
    error=1; /* purecov: inspected */
unknown's avatar
unknown committed
3522 3523
  *ext= 0;				// remove extension
  file= get_new_handler((TABLE_SHARE*) 0, current_thd->mem_root, base);
unknown's avatar
unknown committed
3524
  if (file && file->delete_table(path))
unknown's avatar
unknown committed
3525
  {
unknown's avatar
unknown committed
3526
    error=1;
unknown's avatar
unknown committed
3527
    sql_print_warning("Could not remove temporary table: '%s', error: %d",
unknown's avatar
unknown committed
3528
                      path, my_errno);
unknown's avatar
unknown committed
3529
  }
unknown's avatar
unknown committed
3530
  delete file;
3531
  DBUG_RETURN(error);
unknown's avatar
unknown committed
3532 3533 3534 3535
}


/*****************************************************************************
unknown's avatar
unknown committed
3536 3537 3538 3539 3540 3541
* The following find_field_in_XXX procedures implement the core of the
* name resolution functionality. The entry point to resolve a column name in a
* list of tables is 'find_field_in_tables'. It calls 'find_field_in_table_ref'
* for each table reference. In turn, depending on the type of table reference,
* 'find_field_in_table_ref' calls one of the 'find_field_in_XXX' procedures
* below specific for the type of table reference.
unknown's avatar
unknown committed
3542 3543
******************************************************************************/

unknown's avatar
unknown committed
3544
/* Special Field pointers as return values of find_field_in_XXX functions. */
unknown's avatar
unknown committed
3545 3546
Field *not_found_field= (Field*) 0x1;
Field *view_ref_found= (Field*) 0x2; 
unknown's avatar
VIEW  
unknown committed
3547

unknown's avatar
unknown committed
3548 3549
#define WRONG_GRANT (Field*) -1

unknown's avatar
unknown committed
3550 3551 3552 3553
static void update_field_dependencies(THD *thd, Field *field, TABLE *table)
{
  if (thd->set_query_id)
  {
3554 3555
    table->file->ha_set_bit_in_rw_set(field->fieldnr,
                                      (bool)(thd->set_query_id-1));
unknown's avatar
unknown committed
3556 3557
    if (field->query_id != thd->query_id)
    {
3558 3559
      if (table->get_fields_in_item_tree)
        field->flags|= GET_FIXED_FIELDS_FLAG;
unknown's avatar
unknown committed
3560 3561 3562 3563 3564 3565
      field->query_id= thd->query_id;
      table->used_fields++;
      table->used_keys.intersect(field->part_of_key);
    }
    else
      thd->dupp_field= field;
3566 3567
  } else if (table->get_fields_in_item_tree)
    field->flags|= GET_FIXED_FIELDS_FLAG;
unknown's avatar
unknown committed
3568 3569
}

unknown's avatar
VIEW  
unknown committed
3570 3571

/*
unknown's avatar
unknown committed
3572
  Find a field by name in a view that uses merge algorithm.
unknown's avatar
VIEW  
unknown committed
3573 3574

  SYNOPSIS
unknown's avatar
unknown committed
3575
    find_field_in_view()
unknown's avatar
VIEW  
unknown committed
3576
    thd				thread handler
unknown's avatar
unknown committed
3577
    table_list			view to search for 'name'
unknown's avatar
VIEW  
unknown committed
3578 3579
    name			name of field
    length			length of name
3580
    item_name                   name of item if it will be created (VIEW)
unknown's avatar
unknown committed
3581 3582
    ref				expression substituted in VIEW should be passed
                                using this reference (return view_ref_found)
unknown's avatar
unknown committed
3583
    register_tree_change        TRUE if ref is not stack variable and we
unknown's avatar
unknown committed
3584
                                need register changes in item tree
unknown's avatar
VIEW  
unknown committed
3585 3586 3587 3588

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

unknown's avatar
unknown committed
3592 3593
static Field *
find_field_in_view(THD *thd, TABLE_LIST *table_list,
3594 3595
                   const char *name, uint length,
                   const char *item_name, Item **ref,
unknown's avatar
unknown committed
3596
                   bool register_tree_change)
unknown's avatar
VIEW  
unknown committed
3597
{
unknown's avatar
unknown committed
3598 3599 3600 3601 3602 3603
  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);
3604
  Query_arena *arena, backup;  
3605
  LINT_INIT(arena);
3606
  
unknown's avatar
unknown committed
3607 3608 3609
  DBUG_ASSERT(table_list->schema_table_reformed ||
              (ref != 0 && table_list->view != 0));
  for (; !field_it.end_of_fields(); field_it.next())
unknown's avatar
VIEW  
unknown committed
3610
  {
unknown's avatar
unknown committed
3611
    if (!my_strcasecmp(system_charset_info, field_it.name(), name))
3612
    {
3613 3614 3615
      // in PS use own arena or data will be freed after prepare
      if (register_tree_change)
        arena= thd->activate_stmt_arena_if_needed(&backup);
3616 3617 3618 3619
      /*
        create_item() may, or may not create a new Item, depending on
        the column reference. See create_view_field() for details.
      */
unknown's avatar
unknown committed
3620
      Item *item= field_it.create_item(thd);
3621 3622 3623
      if (register_tree_change && arena)
        thd->restore_active_arena(arena, &backup);
      
unknown's avatar
unknown committed
3624 3625 3626 3627 3628 3629
      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.
3630
       We need to set alias on both ref itself and on ref real item.
unknown's avatar
unknown committed
3631 3632
      */
      if (*ref && !(*ref)->is_autogenerated_name)
3633
      {
unknown's avatar
unknown committed
3634 3635
        item->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
3636 3637 3638
        item->real_item()->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
      }
unknown's avatar
unknown committed
3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666
      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

3667 3668 3669 3670 3671 3672
  DESCRIPTION
    Search for a field among the result fields of a NATURAL/USING join.
    Notice that this procedure is called only for non-qualified field
    names. In the case of qualified fields, we search directly the base
    tables of a natural join.

unknown's avatar
unknown committed
3673
  RETURN
3674 3675 3676
    NULL        if the field was not found
    WRONG_GRANT if no access rights to the found field
    #           Pointer to the found Field
unknown's avatar
unknown committed
3677 3678 3679 3680
*/

static Field *
find_field_in_natural_join(THD *thd, TABLE_LIST *table_ref, const char *name,
3681
                           uint length, Item **ref, bool register_tree_change,
3682
                           TABLE_LIST **actual_table)
unknown's avatar
unknown committed
3683
{
3684 3685 3686 3687
  List_iterator_fast<Natural_join_column>
    field_it(*(table_ref->join_columns));
  Natural_join_column *nj_col;
  Field *found_field;
3688
  Query_arena *arena, backup;
unknown's avatar
unknown committed
3689
  DBUG_ENTER("find_field_in_natural_join");
3690
  DBUG_PRINT("enter", ("field name: '%s', ref 0x%lx",
unknown's avatar
unknown committed
3691 3692
		       name, (ulong) ref));
  DBUG_ASSERT(table_ref->is_natural_join && table_ref->join_columns);
3693
  DBUG_ASSERT(*actual_table == NULL);
unknown's avatar
unknown committed
3694

3695
  LINT_INIT(arena);
3696
  LINT_INIT(found_field);
unknown's avatar
unknown committed
3697

3698
  for (;;)
unknown's avatar
unknown committed
3699
  {
3700 3701 3702
    if (!(nj_col= field_it++))
      DBUG_RETURN(NULL);

unknown's avatar
unknown committed
3703 3704
    if (!my_strcasecmp(system_charset_info, nj_col->name(), name))
      break;
unknown's avatar
VIEW  
unknown committed
3705
  }
unknown's avatar
unknown committed
3706 3707 3708

  if (nj_col->view_field)
  {
unknown's avatar
unknown committed
3709
    Item *item;
3710 3711
    if (register_tree_change)
      arena= thd->activate_stmt_arena_if_needed(&backup);
3712 3713 3714 3715
    /*
      create_item() may, or may not create a new Item, depending on the
      column reference. See create_view_field() for details.
    */
unknown's avatar
unknown committed
3716
    item= nj_col->create_item(thd);
3717 3718 3719
    if (register_tree_change && arena)
      thd->restore_active_arena(arena, &backup);

unknown's avatar
unknown committed
3720 3721 3722 3723
    if (!item)
      DBUG_RETURN(NULL);
    DBUG_ASSERT(nj_col->table_field == NULL);
    if (nj_col->table_ref->schema_table_reformed)
3724
    {
unknown's avatar
unknown committed
3725 3726 3727 3728 3729 3730
      /*
        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);
3731
    }
unknown's avatar
unknown committed
3732 3733 3734 3735 3736 3737 3738 3739 3740 3741
    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);
3742
    DBUG_ASSERT(nj_col->table_ref->table == nj_col->table_field->table);
unknown's avatar
unknown committed
3743 3744 3745 3746 3747 3748 3749
    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);
unknown's avatar
VIEW  
unknown committed
3750 3751
}

3752

unknown's avatar
VIEW  
unknown committed
3753
/*
unknown's avatar
unknown committed
3754
  Find field by name in a base table or a view with temp table algorithm.
unknown's avatar
VIEW  
unknown committed
3755 3756

  SYNOPSIS
unknown's avatar
unknown committed
3757
    find_field_in_table()
unknown's avatar
VIEW  
unknown committed
3758
    thd				thread handler
unknown's avatar
unknown committed
3759
    table			table where to search for the field
unknown's avatar
VIEW  
unknown committed
3760 3761 3762
    name			name of field
    length			length of name
    allow_rowid			do allow finding of "_rowid" field?
unknown's avatar
unknown committed
3763 3764
    cached_field_index_ptr	cached position in field list (used to speedup
                                lookup for fields in prepared tables)
unknown's avatar
VIEW  
unknown committed
3765 3766

  RETURN
3767 3768
    0	field is not found
    #	pointer to field
unknown's avatar
VIEW  
unknown committed
3769 3770
*/

unknown's avatar
unknown committed
3771 3772
Field *
find_field_in_table(THD *thd, TABLE *table, const char *name, uint length,
3773
                    bool allow_rowid, uint *cached_field_index_ptr)
unknown's avatar
unknown committed
3774
{
unknown's avatar
unknown committed
3775 3776
  Field **field_ptr, *field;
  uint cached_field_index= *cached_field_index_ptr;
3777 3778
  DBUG_ENTER("find_field_in_table");
  DBUG_PRINT("enter", ("table: '%s', field name: '%s'", table->alias, name));
unknown's avatar
unknown committed
3779 3780

  /* We assume here that table->field < NO_CACHED_FIELD_INDEX = UINT_MAX */
3781
  if (cached_field_index < table->s->fields &&
3782
      !my_strcasecmp(system_charset_info,
unknown's avatar
unknown committed
3783 3784
                     table->field[cached_field_index]->field_name, name))
    field_ptr= table->field + cached_field_index;
3785
  else if (table->s->name_hash.records)
unknown's avatar
unknown committed
3786
  {
3787 3788
    field_ptr= (Field**) hash_search(&table->s->name_hash, (byte*) name,
                                     length);
unknown's avatar
unknown committed
3789 3790 3791 3792 3793 3794 3795 3796 3797
    if (field_ptr)
    {
      /*
        field_ptr points to field in TABLE_SHARE. Convert it to the matching
        field in table
      */
      field_ptr= (table->field + (field_ptr - table->s->field));
    }
  }
unknown's avatar
unknown committed
3798 3799 3800
  else
  {
    if (!(field_ptr= table->field))
unknown's avatar
unknown committed
3801
      DBUG_RETURN((Field *)0);
unknown's avatar
unknown committed
3802 3803 3804 3805 3806 3807
    for (; *field_ptr; ++field_ptr)
      if (!my_strcasecmp(system_charset_info, (*field_ptr)->field_name, name))
        break;
  }

  if (field_ptr && *field_ptr)
unknown's avatar
unknown committed
3808
  {
unknown's avatar
unknown committed
3809 3810
    *cached_field_index_ptr= field_ptr - table->field;
    field= *field_ptr;
unknown's avatar
unknown committed
3811 3812 3813
  }
  else
  {
unknown's avatar
unknown committed
3814 3815
    if (!allow_rowid ||
        my_strcasecmp(system_charset_info, name, "_rowid") ||
unknown's avatar
unknown committed
3816
        table->s->rowid_field_offset == 0)
unknown's avatar
unknown committed
3817
      DBUG_RETURN((Field*) 0);
unknown's avatar
unknown committed
3818
    field= table->field[table->s->rowid_field_offset-1];
unknown's avatar
unknown committed
3819 3820
  }

unknown's avatar
unknown committed
3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834
  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
3835
    length		   [in]  field length of name
unknown's avatar
unknown committed
3836 3837
    item_name              [in]  name of item if it will be created (VIEW)
    db_name                [in]  optional database name that qualifies the
3838
    table_name             [in]  optional table name that qualifies the field
unknown's avatar
unknown committed
3839 3840
    ref		       [in/out] if 'name' is resolved to a view field, ref
                                 is set to point to the found view field
3841
    check_privileges       [in]  check privileges
unknown's avatar
unknown committed
3842 3843 3844 3845 3846 3847 3848 3849 3850
    allow_rowid		   [in]  do allow finding of "_rowid" field?
    cached_field_index_ptr [in]  cached position in field list (used to
                                 speedup lookup for fields in prepared tables)
    register_tree_change   [in]  TRUE if ref is not stack variable and we
                                 need register changes in item tree
    actual_table           [out] the original table reference where the field
                                 belongs - differs from 'table_list' only for
                                 NATURAL_USING joins.

unknown's avatar
unknown committed
3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862
  DESCRIPTION
    Find a field in a table reference depending on the type of table
    reference. There are three types of table references with respect
    to the representation of their result columns:
    - an array of Field_translator objects for MERGE views and some
      information_schema tables,
    - an array of Field objects (and possibly a name hash) for stored
      tables,
    - a list of Natural_join_column objects for NATURAL/USING joins.
    This procedure detects the type of the table reference 'table_list'
    and calls the corresponding search routine.

unknown's avatar
unknown committed
3863 3864 3865 3866 3867 3868 3869 3870
  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,
3871 3872 3873
                        const char *name, uint length,
                        const char *item_name, const char *db_name,
                        const char *table_name, Item **ref,
3874 3875
                        bool check_privileges, bool allow_rowid,
                        uint *cached_field_index_ptr,
unknown's avatar
unknown committed
3876 3877 3878 3879 3880 3881 3882 3883 3884 3885
                        bool register_tree_change, TABLE_LIST **actual_table)
{
  Field *fld;
  DBUG_ENTER("find_field_in_table_ref");
  DBUG_PRINT("enter",
             ("table: '%s'  field name: '%s'  item name: '%s'  ref 0x%lx",
              table_list->alias, name, item_name, (ulong) ref));

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

3888 3889 3890 3891
    Exclude from the test below nested joins because the columns in a
    nested join generally originate from different tables. Nested joins
    also have no table name, except when a nested join is a merge view
    or an information schema table.
unknown's avatar
unknown committed
3892 3893 3894 3895 3896 3897

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

3898 3899
    TODO: Ensure that table_name, db_name and tables->db always points to
          something !
unknown's avatar
unknown committed
3900
  */
3901 3902
  if (/* Exclude nested joins. */
      (!table_list->nested_join ||
unknown's avatar
unknown committed
3903 3904 3905 3906 3907 3908
       /* Include merge views and information schema tables. */
       table_list->field_translation) &&
      /*
        Test if the field qualifiers match the table reference we plan
        to search.
      */
3909 3910
      table_name && table_name[0] &&
      (my_strcasecmp(table_alias_charset, table_list->alias, table_name) ||
unknown's avatar
unknown committed
3911 3912 3913 3914
       (db_name && db_name[0] && table_list->db && table_list->db[0] &&
        strcmp(db_name, table_list->db))))
    DBUG_RETURN(0);

3915
  *actual_table= NULL;
unknown's avatar
unknown committed
3916

unknown's avatar
unknown committed
3917 3918
  if (table_list->field_translation)
  {
unknown's avatar
unknown committed
3919
    /* 'table_list' is a view or an information schema table. */
3920
    if ((fld= find_field_in_view(thd, table_list, name, length, item_name, ref,
3921
                                 register_tree_change)))
unknown's avatar
unknown committed
3922 3923
      *actual_table= table_list;
  }
3924
  else if (!table_list->nested_join)
3925
  {
3926 3927
    /* 'table_list' is a stored table. */
    DBUG_ASSERT(table_list->table);
unknown's avatar
unknown committed
3928
    if ((fld= find_field_in_table(thd, table_list->table, name, length,
3929 3930
                                  allow_rowid,
                                  cached_field_index_ptr)))
unknown's avatar
unknown committed
3931 3932 3933
      *actual_table= table_list;
  }
  else
3934
  {
unknown's avatar
unknown committed
3935
    /*
unknown's avatar
unknown committed
3936 3937 3938 3939 3940
      'table_list' is a NATURAL/USING join, or an operand of such join that
      is a nested join itself.

      If the field name we search for is qualified, then search for the field
      in the table references used by NATURAL/USING the join.
unknown's avatar
unknown committed
3941
    */
3942 3943 3944 3945 3946 3947
    if (table_name && table_name[0])
    {
      List_iterator<TABLE_LIST> it(table_list->nested_join->join_list);
      TABLE_LIST *table;
      while ((table= it++))
      {
3948 3949
        if ((fld= find_field_in_table_ref(thd, table, name, length, item_name,
                                          db_name, table_name, ref,
3950 3951
                                          check_privileges, allow_rowid,
                                          cached_field_index_ptr,
3952 3953 3954 3955 3956 3957 3958
                                          register_tree_change, actual_table)))
          DBUG_RETURN(fld);
      }
      DBUG_RETURN(0);
    }
    /*
      Non-qualified field, search directly in the result columns of the
unknown's avatar
unknown committed
3959 3960 3961
      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.
3962 3963
    */
    fld= find_field_in_natural_join(thd, table_list, name, length, ref,
unknown's avatar
unknown committed
3964
                                    register_tree_change, actual_table);
3965
  }
unknown's avatar
unknown committed
3966

3967 3968
  if (fld)
  {
3969
#ifndef NO_EMBEDDED_ACCESS_CHECKS
3970 3971 3972 3973 3974
    /* 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
3975
#endif
3976 3977
      if (thd->set_query_id)
      {
3978 3979 3980 3981 3982
        /*
         * get rw_set correct for this field so that the handler
         * knows that this field is involved in the query and gets
         * retrieved/updated
         */
3983 3984 3985 3986 3987 3988 3989 3990 3991 3992
        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;
        }
        else
          field_to_set= fld;
        if (field_to_set)
3993 3994 3995
          field_to_set->table->file->
            ha_set_bit_in_rw_set(field_to_set->fieldnr,
                                 (bool)(thd->set_query_id-1));
3996 3997
      }
  }
unknown's avatar
unknown committed
3998
  DBUG_RETURN(fld);
unknown's avatar
unknown committed
3999 4000
}

4001

4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020
/*
  Find field in table, no side effects, only purpose is to check for field
  in table object and get reference to the field if found.

  SYNOPSIS
  find_field_in_table_sef()

  table                         table where to find
  name                          Name of field searched for

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

Field *find_field_in_table_sef(TABLE *table, const char *name)
{
  Field **field_ptr;
  if (table->s->name_hash.records)
unknown's avatar
unknown committed
4021
  {
4022 4023
    field_ptr= (Field**)hash_search(&table->s->name_hash,(byte*) name,
                                    strlen(name));
unknown's avatar
unknown committed
4024 4025 4026 4027 4028 4029 4030 4031 4032
    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));
    }
  }
4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047
  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;
}


4048 4049 4050 4051 4052
/*
  Find field in table list.

  SYNOPSIS
    find_field_in_tables()
unknown's avatar
unknown committed
4053 4054 4055 4056 4057 4058
    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
4059
                          point to the found view field
unknown's avatar
unknown committed
4060
    report_error	  Degree of error reporting:
4061 4062
                          - IGNORE_ERRORS then do not report any error
                          - IGNORE_EXCEPT_NON_UNIQUE report only non-unique
unknown's avatar
unknown committed
4063
                            fields, suppress all other errors
4064 4065 4066 4067
                          - REPORT_EXCEPT_NON_UNIQUE report all other errors
                            except when non-unique fields were found
                          - REPORT_ALL_ERRORS
    check_privileges      need to check privileges
unknown's avatar
unknown committed
4068 4069
    register_tree_change  TRUE if ref is not a stack variable and we
                          to need register changes in item tree
4070 4071

  RETURN VALUES
4072 4073 4074
    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.
4075 4076 4077 4078 4079
    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
4080
*/
unknown's avatar
unknown committed
4081 4082

Field *
unknown's avatar
unknown committed
4083 4084
find_field_in_tables(THD *thd, Item_ident *item,
                     TABLE_LIST *first_table, TABLE_LIST *last_table,
4085
		     Item **ref, find_item_error_report_type report_error,
4086
                     bool check_privileges, bool register_tree_change)
unknown's avatar
unknown committed
4087 4088
{
  Field *found=0;
unknown's avatar
unknown committed
4089 4090 4091
  const char *db= item->db_name;
  const char *table_name= item->table_name;
  const char *name= item->field_name;
unknown's avatar
unknown committed
4092
  uint length=(uint) strlen(name);
4093
  char name_buff[NAME_LEN+1];
unknown's avatar
unknown committed
4094 4095
  TABLE_LIST *cur_table= first_table;
  TABLE_LIST *actual_table;
unknown's avatar
unknown committed
4096 4097 4098 4099 4100 4101 4102 4103 4104
  bool allow_rowid;

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

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

unknown's avatar
unknown committed
4106 4107 4108
  if (item->cached_table)
  {
    /*
unknown's avatar
unknown committed
4109 4110
      This shortcut is used by prepared statements. We assume that
      TABLE_LIST *first_table is not changed during query execution (which
4111
      is true for all queries except RENAME but luckily RENAME doesn't
unknown's avatar
unknown committed
4112
      use fields...) so we can rely on reusing pointer to its member.
unknown's avatar
unknown committed
4113
      With this optimization we also miss case when addition of one more
4114
      field makes some prepared query ambiguous and so erroneous, but we
unknown's avatar
unknown committed
4115 4116
      accept this trade off.
    */
unknown's avatar
unknown committed
4117 4118 4119 4120 4121 4122 4123 4124
    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,
4125
                                 TRUE, &(item->cached_field_index));
4126
    else
4127
      found= find_field_in_table_ref(thd, table_ref, name, length, item->name,
4128 4129
                                     NULL, NULL, ref, check_privileges,
                                     TRUE, &(item->cached_field_index),
unknown's avatar
unknown committed
4130 4131
                                     register_tree_change,
                                     &actual_table);
unknown's avatar
unknown committed
4132 4133 4134
    if (found)
    {
      if (found == WRONG_GRANT)
4135
	return (Field*) 0;
4136 4137
      {
        SELECT_LEX *current_sel= thd->lex->current_select;
unknown's avatar
unknown committed
4138
        SELECT_LEX *last_select= table_ref->select_lex;
unknown's avatar
unknown committed
4139 4140
        /*
          If the field was an outer referencee, mark all selects using this
unknown's avatar
unknown committed
4141
          sub query as dependent on the outer query
unknown's avatar
unknown committed
4142
        */
4143
        if (current_sel != last_select)
unknown's avatar
unknown committed
4144
          mark_select_range_as_dependent(thd, last_select, current_sel,
4145 4146
                                         found, *ref, item);
      }
unknown's avatar
unknown committed
4147 4148 4149 4150
      return found;
    }
  }

4151 4152 4153
  if (db && lower_case_table_names)
  {
    /*
unknown's avatar
unknown committed
4154
      convert database to lower case for comparison.
4155 4156 4157 4158
      We can't do this in Item_field as this would change the
      'name' of the item which may be used in the select list
    */
    strmake(name_buff, db, sizeof(name_buff)-1);
unknown's avatar
unknown committed
4159
    my_casedn_str(files_charset_info, name_buff);
4160 4161
    db= name_buff;
  }
unknown's avatar
unknown committed
4162

4163 4164 4165 4166 4167
  if (last_table)
    last_table= last_table->next_name_resolution_table;

  for (; cur_table != last_table ;
       cur_table= cur_table->next_name_resolution_table)
unknown's avatar
unknown committed
4168
  {
4169 4170
    Field *cur_field= find_field_in_table_ref(thd, cur_table, name, length,
                                              item->name, db, table_name, ref,
4171
                                              check_privileges, allow_rowid,
unknown's avatar
unknown committed
4172 4173 4174 4175
                                              &(item->cached_field_index),
                                              register_tree_change,
                                              &actual_table);
    if (cur_field)
4176
    {
unknown's avatar
unknown committed
4177
      if (cur_field == WRONG_GRANT)
unknown's avatar
unknown committed
4178
	return (Field*) 0;
unknown's avatar
unknown committed
4179 4180 4181 4182 4183 4184 4185 4186

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

4187 4188 4189 4190 4191
      DBUG_ASSERT(thd->where);
      /*
        If we found a fully qualified field we return it directly as it can't
        have duplicates.
       */
unknown's avatar
unknown committed
4192
      if (db)
4193 4194
        return cur_field;

unknown's avatar
unknown committed
4195 4196
      if (found)
      {
4197 4198
        if (report_error == REPORT_ALL_ERRORS ||
            report_error == IGNORE_EXCEPT_NON_UNIQUE)
4199
          my_error(ER_NON_UNIQ_ERROR, MYF(0),
unknown's avatar
unknown committed
4200
                   table_name ? item->full_name() : name, thd->where);
unknown's avatar
unknown committed
4201 4202
	return (Field*) 0;
      }
unknown's avatar
unknown committed
4203
      found= cur_field;
unknown's avatar
unknown committed
4204 4205
    }
  }
4206

unknown's avatar
unknown committed
4207 4208
  if (found)
    return found;
4209 4210 4211 4212 4213 4214 4215 4216

  /*
    If the field was qualified and there were no tables to search, issue
    an error that an unknown table was given. The situation is detected
    as follows: if there were no tables we wouldn't go through the loop
    and cur_table wouldn't be updated by the loop increment part, so it
    will be equal to the first table.
  */
unknown's avatar
unknown committed
4217
  if (table_name && (cur_table == first_table) &&
4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228
      (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);
  }
4229
  else
unknown's avatar
unknown committed
4230
  {
4231 4232 4233 4234 4235
    if (report_error == REPORT_ALL_ERRORS ||
        report_error == REPORT_EXCEPT_NON_UNIQUE)
      my_error(ER_BAD_FIELD_ERROR, MYF(0), item->full_name(), thd->where);
    else
      found= not_found_field;
unknown's avatar
unknown committed
4236
  }
4237
  return found;
unknown's avatar
unknown committed
4238 4239
}

4240 4241 4242

/*
  Find Item in list of items (find_field_in_tables analog)
4243 4244 4245 4246

  TODO
    is it better return only counter?

4247 4248
  SYNOPSIS
    find_item_in_list()
4249 4250 4251
    find			Item to find
    items			List of items
    counter			To return number of found item
4252
    report_error
4253 4254 4255 4256 4257
      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
4258 4259 4260 4261
    unaliased                   Set to true if item is field which was found
                                by original field name and not by its alias
                                in item list. Set to false otherwise.

4262
  RETURN VALUES
4263 4264 4265 4266 4267
    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
4268
                        found field
4269 4270
*/

4271
/* Special Item pointer to serve as a return value from find_item_in_list(). */
unknown's avatar
unknown committed
4272
Item **not_found_item= (Item**) 0x1;
4273 4274


unknown's avatar
unknown committed
4275
Item **
4276
find_item_in_list(Item *find, List<Item> &items, uint *counter,
4277
                  find_item_error_report_type report_error, bool *unaliased)
unknown's avatar
unknown committed
4278 4279
{
  List_iterator<Item> li(items);
4280
  Item **found=0, **found_unaliased= 0, *item;
4281
  const char *db_name=0;
unknown's avatar
unknown committed
4282 4283
  const char *field_name=0;
  const char *table_name=0;
4284 4285
  bool found_unaliased_non_uniq= 0;
  uint unaliased_counter;
4286

4287 4288
  LINT_INIT(unaliased_counter);                 // Dependent on found_unaliased

4289 4290
  *unaliased= FALSE;

unknown's avatar
unknown committed
4291 4292 4293 4294
  if (find->type() == Item::FIELD_ITEM	|| find->type() == Item::REF_ITEM)
  {
    field_name= ((Item_ident*) find)->field_name;
    table_name= ((Item_ident*) find)->table_name;
4295
    db_name=    ((Item_ident*) find)->db_name;
unknown's avatar
unknown committed
4296 4297
  }

4298
  for (uint i= 0; (item=li++); i++)
unknown's avatar
unknown committed
4299
  {
4300
    if (field_name && item->real_item()->type() == Item::FIELD_ITEM)
unknown's avatar
unknown committed
4301
    {
4302
      Item_ident *item_field= (Item_ident*) item;
4303

unknown's avatar
unknown committed
4304 4305 4306 4307 4308 4309
      /*
	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
      */ 
4310 4311 4312 4313
      if (!item_field->name)
        continue;

      if (table_name)
unknown's avatar
unknown committed
4314
      {
4315 4316 4317
        /*
          If table name is specified we should find field 'field_name' in
          table 'table_name'. According to SQL-standard we should ignore
4318 4319 4320 4321 4322
          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.
4323

4324
          We use strcmp for table names and database names as these may be
4325 4326
          case sensitive. In cases where they are not case sensitive, they
          are always in lower case.
4327 4328

	  item_field->field_name and item_field->table_name can be 0x0 if
4329
	  item is not fix_field()'ed yet.
4330
        */
4331 4332
        if (item_field->field_name && item_field->table_name &&
	    !my_strcasecmp(system_charset_info, item_field->field_name,
4333 4334 4335 4336 4337
                           field_name) &&
            !strcmp(item_field->table_name, table_name) &&
            (!db_name || (item_field->db_name &&
                          !strcmp(item_field->db_name, db_name))))
        {
4338
          if (found_unaliased)
4339
          {
4340 4341 4342 4343 4344 4345 4346
            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.
            */
4347
            if (report_error != IGNORE_ERRORS)
4348 4349
              my_error(ER_NON_UNIQ_ERROR, MYF(0),
                       find->full_name(), current_thd->where);
4350 4351
            return (Item**) 0;
          }
4352 4353
          found_unaliased= li.ref();
          unaliased_counter= i;
4354 4355
          if (db_name)
            break;                              // Perfect match
4356 4357 4358
        }
      }
      else if (!my_strcasecmp(system_charset_info, item_field->name,
4359
                              field_name))
4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372
      {
        /*
          If table name was not given we should scan through aliases
          (or 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)
4373 4374
            my_error(ER_NON_UNIQ_ERROR, MYF(0),
                     find->full_name(), current_thd->where);
4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399
          return (Item**) 0;
        }
        found= li.ref();
        *counter= i;
      }
      else if (!my_strcasecmp(system_charset_info, item_field->field_name,
                              field_name))
      {
        /*
          We will use un-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;
        }
        else
        {
          found_unaliased= li.ref();
          unaliased_counter= i;
        }
unknown's avatar
unknown committed
4400 4401
      }
    }
unknown's avatar
unknown committed
4402
    else if (!table_name && (find->eq(item,0) ||
4403
			     find->name && item->name &&
4404 4405
			     !my_strcasecmp(system_charset_info, 
					    item->name,find->name)))
unknown's avatar
unknown committed
4406
    {
4407 4408
      found= li.ref();
      *counter= i;
unknown's avatar
unknown committed
4409 4410 4411
      break;
    }
  }
4412 4413 4414 4415 4416
  if (!found)
  {
    if (found_unaliased_non_uniq)
    {
      if (report_error != IGNORE_ERRORS)
4417 4418
        my_error(ER_NON_UNIQ_ERROR, MYF(0),
                 find->full_name(), current_thd->where);
4419 4420 4421 4422 4423 4424
      return (Item **) 0;
    }
    if (found_unaliased)
    {
      found= found_unaliased;
      *counter= unaliased_counter;
4425
      *unaliased= TRUE;
4426 4427
    }
  }
4428 4429
  if (found)
    return found;
4430
  if (report_error != REPORT_EXCEPT_NOT_FOUND)
4431 4432
  {
    if (report_error == REPORT_ALL_ERRORS)
4433 4434
      my_error(ER_BAD_FIELD_ERROR, MYF(0),
               find->full_name(), current_thd->where);
4435 4436 4437 4438
    return (Item **) 0;
  }
  else
    return (Item **) not_found_item;
unknown's avatar
unknown committed
4439 4440
}

unknown's avatar
unknown committed
4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468

/*
  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;
4469
    if (!my_strcasecmp(system_charset_info, find, curr_str->ptr()))
unknown's avatar
unknown committed
4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490
      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
4491 4492
    FALSE  if all OK
    TRUE   otherwise
unknown's avatar
unknown committed
4493 4494 4495 4496 4497 4498
*/

static bool
set_new_item_local_context(THD *thd, Item_ident *item, TABLE_LIST *table_ref)
{
  Name_resolution_context *context;
4499
  if (!(context= new (thd->mem_root) Name_resolution_context))
unknown's avatar
unknown committed
4500 4501
    return TRUE;
  context->init();
4502 4503
  context->first_name_resolution_table=
    context->last_name_resolution_table= table_ref;
unknown's avatar
unknown committed
4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535
  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
4536 4537
    TRUE   error when some common column is non-unique, or out of memory
    FALSE  OK
unknown's avatar
unknown committed
4538 4539 4540 4541 4542 4543 4544 4545 4546 4547
*/

static bool
mark_common_columns(THD *thd, TABLE_LIST *table_ref_1, TABLE_LIST *table_ref_2,
                    List<String> *using_fields, uint *found_using_fields)
{
  Field_iterator_table_ref it_1, it_2;
  Natural_join_column *nj_col_1, *nj_col_2;
  Query_arena *arena, backup;
  bool result= TRUE;
unknown's avatar
unknown committed
4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558
  bool first_outer_loop= TRUE;
  /*
    Leaf table references to which new natural join columns are added
    if the leaves are != NULL.
  */
  TABLE_LIST *leaf_1= (table_ref_1->nested_join &&
                       !table_ref_1->is_natural_join) ?
                      NULL : table_ref_1;
  TABLE_LIST *leaf_2= (table_ref_2->nested_join &&
                       !table_ref_2->is_natural_join) ?
                      NULL : table_ref_2;
unknown's avatar
unknown committed
4559 4560

  DBUG_ENTER("mark_common_columns");
4561
  DBUG_PRINT("info", ("operand_1: %s  operand_2: %s",
unknown's avatar
unknown committed
4562 4563
                      table_ref_1->alias, table_ref_2->alias));

4564
  *found_using_fields= 0;
unknown's avatar
unknown committed
4565
  arena= thd->activate_stmt_arena_if_needed(&backup);
unknown's avatar
unknown committed
4566 4567 4568

  for (it_1.set(table_ref_1); !it_1.end_of_fields(); it_1.next())
  {
4569
    bool found= FALSE;
unknown's avatar
unknown committed
4570
    const char *field_name_1;
unknown's avatar
unknown committed
4571
    if (!(nj_col_1= it_1.get_or_create_column_ref(leaf_1)))
unknown's avatar
unknown committed
4572 4573 4574
      goto err;
    field_name_1= nj_col_1->name();

4575 4576 4577 4578 4579 4580 4581
    /*
      Find a field with the same name in table_ref_2.

      Note that for the second loop, it_2.set() will iterate over
      table_ref_2->join_columns and not generate any new elements or
      lists.
    */
unknown's avatar
unknown committed
4582 4583 4584 4585
    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;
4586
      const char *cur_field_name_2;
unknown's avatar
unknown committed
4587
      if (!(cur_nj_col_2= it_2.get_or_create_column_ref(leaf_2)))
unknown's avatar
unknown committed
4588
        goto err;
4589
      cur_field_name_2= cur_nj_col_2->name();
unknown's avatar
unknown committed
4590

unknown's avatar
unknown committed
4591 4592 4593 4594 4595 4596 4597
      /*
        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).
      */
unknown's avatar
unknown committed
4598 4599
      if (!my_strcasecmp(system_charset_info, field_name_1, cur_field_name_2))
      {
unknown's avatar
unknown committed
4600
        if (found || cur_nj_col_2->is_common)
unknown's avatar
unknown committed
4601 4602 4603 4604 4605 4606 4607 4608
        {
          my_error(ER_NON_UNIQ_ERROR, MYF(0), field_name_1, thd->where);
          goto err;
        }
        nj_col_2= cur_nj_col_2;
        found= TRUE;
      }
    }
unknown's avatar
unknown committed
4609 4610 4611 4612 4613 4614 4615 4616 4617
    if (first_outer_loop && leaf_2)
    {
      /*
        Make sure that the next inner loop "knows" that all columns
        are materialized already.
      */
      leaf_2->is_join_columns_complete= TRUE;
      first_outer_loop= FALSE;
    }
unknown's avatar
unknown committed
4618
    if (!found)
4619
      continue;                                 // No matching field
unknown's avatar
unknown committed
4620 4621 4622 4623 4624 4625 4626 4627

    /*
      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.
    */
    if (nj_col_2 &&
        (!using_fields ||
4628
          test_if_string_in_list(field_name_1, using_fields)))
unknown's avatar
unknown committed
4629 4630 4631 4632 4633 4634
    {
      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;
4635 4636 4637 4638 4639
      Item_func_eq *eq_cond;

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

unknown's avatar
unknown committed
4640
      /*
4641
        The following assert checks that the two created items are of
unknown's avatar
unknown committed
4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665
        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.
      */
4666 4667
      if (set_new_item_local_context(thd, item_ident_1, nj_col_1->table_ref) ||
          set_new_item_local_context(thd, item_ident_2, nj_col_2->table_ref))
unknown's avatar
unknown committed
4668 4669
        goto err;

4670 4671
      if (!(eq_cond= new Item_func_eq(item_ident_1, item_ident_2)))
        goto err;                               /* Out of memory. */
unknown's avatar
unknown committed
4672 4673 4674 4675 4676 4677

      /*
        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.
       */
4678 4679 4680
      add_join_on((table_ref_1->outer_join & JOIN_TYPE_RIGHT ?
                   table_ref_1 : table_ref_2),
                  eq_cond);
unknown's avatar
unknown committed
4681 4682 4683 4684 4685

      nj_col_1->is_common= nj_col_2->is_common= TRUE;

      if (field_1)
      {
unknown's avatar
unknown committed
4686
        TABLE *table_1= nj_col_1->table_ref->table;
unknown's avatar
unknown committed
4687 4688
        /* Mark field_1 used for table cache. */
        field_1->query_id= thd->query_id;
4689 4690
        table_1->file->ha_set_bit_in_read_set(field_1->fieldnr);
        table_1->used_keys.intersect(field_1->part_of_key);
unknown's avatar
unknown committed
4691 4692 4693
      }
      if (field_2)
      {
unknown's avatar
unknown committed
4694
        TABLE *table_2= nj_col_2->table_ref->table;
unknown's avatar
unknown committed
4695 4696
        /* Mark field_2 used for table cache. */
        field_2->query_id= thd->query_id;
unknown's avatar
unknown committed
4697
        table_2->file->ha_set_bit_in_read_set(field_2->fieldnr);
4698
        table_2->used_keys.intersect(field_2->part_of_key);
unknown's avatar
unknown committed
4699 4700 4701 4702 4703 4704
      }

      if (using_fields != NULL)
        ++(*found_using_fields);
    }
  }
unknown's avatar
unknown committed
4705 4706
  if (leaf_1)
    leaf_1->is_join_columns_complete= TRUE;
unknown's avatar
unknown committed
4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718

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

err:
  if (arena)
unknown's avatar
unknown committed
4719
    thd->restore_active_arena(arena, &backup);
unknown's avatar
unknown committed
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
  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
4756 4757
    TRUE    error: Some common column is ambiguous
    FALSE   OK
unknown's avatar
unknown committed
4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770
*/

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;
4771
  List<Natural_join_column> *non_join_columns;
unknown's avatar
unknown committed
4772 4773
  DBUG_ENTER("store_natural_using_join_columns");

4774 4775
  DBUG_ASSERT(!natural_using_join->join_columns);

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

4778 4779
  if (!(non_join_columns= new List<Natural_join_column>) ||
      !(natural_using_join->join_columns= new List<Natural_join_column>))
unknown's avatar
unknown committed
4780 4781 4782 4783 4784
    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())
  {
4785
    nj_col_1= it_1.get_natural_column_ref();
unknown's avatar
unknown committed
4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806
    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++))
    {
4807
      const char *using_field_name_ptr= using_field_name->c_ptr();
unknown's avatar
unknown committed
4808 4809 4810
      List_iterator_fast<Natural_join_column>
        it(*(natural_using_join->join_columns));
      Natural_join_column *common_field;
4811 4812

      for (;;)
unknown's avatar
unknown committed
4813
      {
4814 4815 4816 4817 4818 4819 4820
        /* If reached the end of fields, and none was found, report error. */
        if (!(common_field= it++))
        {
          my_error(ER_BAD_FIELD_ERROR, MYF(0), using_field_name_ptr,
                   current_thd->where);
          goto err;
        }
unknown's avatar
unknown committed
4821 4822
        if (!my_strcasecmp(system_charset_info,
                           common_field->name(), using_field_name_ptr))
4823
          break;                                // Found match
unknown's avatar
unknown committed
4824 4825 4826 4827 4828 4829 4830
      }
    }
  }

  /* 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())
  {
4831
    nj_col_2= it_2.get_natural_column_ref();
unknown's avatar
unknown committed
4832 4833 4834
    if (!nj_col_2->is_common)
      non_join_columns->push_back(nj_col_2);
    else
4835
    {
unknown's avatar
unknown committed
4836 4837
      /* Reset the common columns for the next call to mark_common_columns. */
      nj_col_2->is_common= FALSE;
4838
    }
unknown's avatar
unknown committed
4839 4840 4841 4842 4843 4844 4845 4846 4847 4848
  }

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

  result= FALSE;

err:
  if (arena)
unknown's avatar
unknown committed
4849
    thd->restore_active_arena(arena, &backup);
unknown's avatar
unknown committed
4850 4851 4852
  DBUG_RETURN(result);
}

4853

unknown's avatar
unknown committed
4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879
/*
  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
4880 4881
    TRUE   Error
    FALSE  OK
unknown's avatar
unknown committed
4882 4883 4884 4885 4886 4887 4888
*/

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

unknown's avatar
unknown committed
4892
  DBUG_ENTER("store_top_level_join_columns");
4893

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

unknown's avatar
unknown committed
4896 4897 4898 4899 4900 4901
  /* 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);
    TABLE_LIST *cur_left_neighbor= nested_it++;
    TABLE_LIST *cur_right_neighbor= NULL;
4902

unknown's avatar
unknown committed
4903 4904
    while (cur_left_neighbor)
    {
4905
      TABLE_LIST *cur_table_ref= cur_left_neighbor;
unknown's avatar
unknown committed
4906
      cur_left_neighbor= nested_it++;
4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927
      /*
        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
        join operands. Notice that this happens only in the first loop, and
        not in the second one, as in the second loop cur_left_neighbor == NULL.
        This is the correct behavior, because the second loop
        sets cur_table_ref reference correctly after the join operands are
        swapped in the first loop.
      */
      if (cur_left_neighbor &&
          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);
        swap_variables(TABLE_LIST*, cur_left_neighbor, cur_table_ref);
      }

      if (cur_table_ref->nested_join &&
          store_top_level_join_columns(thd, cur_table_ref,
                                       cur_left_neighbor, cur_right_neighbor))
unknown's avatar
unknown committed
4928
        goto err;
4929
      cur_right_neighbor= cur_table_ref;
unknown's avatar
unknown committed
4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959
    }
  }

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

    /*
      The two join operands were interchanged in the parser, change the order
      back for 'mark_common_columns'.
    */
    if (table_ref_2->outer_join & JOIN_TYPE_RIGHT)
      swap_variables(TABLE_LIST*, table_ref_1, table_ref_2);
    if (mark_common_columns(thd, table_ref_1, table_ref_2,
                            using_fields, &found_using_fields))
unknown's avatar
unknown committed
4960
      goto err;
unknown's avatar
unknown committed
4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971

    /*
      Swap the join operands back, so that we pick the columns of the second
      one as the coalesced columns. In this way the coalesced columns are the
      same as of an equivalent LEFT JOIN.
    */
    if (table_ref_1->outer_join & JOIN_TYPE_RIGHT)
      swap_variables(TABLE_LIST*, table_ref_1, table_ref_2);
    if (store_natural_using_join_columns(thd, table_ref, table_ref_1,
                                         table_ref_2, using_fields,
                                         found_using_fields))
unknown's avatar
unknown committed
4972
      goto err;
unknown's avatar
unknown committed
4973 4974 4975 4976 4977 4978 4979 4980 4981

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

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

unknown's avatar
unknown committed
4987 4988 4989
    /* Change this table reference to become a leaf for name resolution. */
    if (left_neighbor)
    {
4990
      TABLE_LIST *last_leaf_on_the_left;
unknown's avatar
unknown committed
4991 4992 4993 4994 4995
      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)
    {
4996
      TABLE_LIST *first_leaf_on_the_right;
unknown's avatar
unknown committed
4997 4998 4999 5000 5001 5002
      first_leaf_on_the_right= right_neighbor->first_leaf_for_name_resolution();
      table_ref->next_name_resolution_table= first_leaf_on_the_right;
    }
    else
      table_ref->next_name_resolution_table= NULL;
  }
unknown's avatar
unknown committed
5003 5004 5005 5006
  result= FALSE; /* All is OK. */

err:
  if (arena)
unknown's avatar
unknown committed
5007
    thd->restore_active_arena(arena, &backup);
unknown's avatar
unknown committed
5008
  DBUG_RETURN(result);
unknown's avatar
unknown committed
5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031 5032
}


/*
  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
5033 5034
    TRUE   Error
    FALSE  OK
unknown's avatar
unknown committed
5035
*/
5036 5037
static bool setup_natural_join_row_types(THD *thd,
                                         List<TABLE_LIST> *from_clause,
unknown's avatar
unknown committed
5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050
                                         Name_resolution_context *context)
{
  thd->where= "from clause";
  if (from_clause->elements == 0)
    return FALSE; /* We come here in the case of UNIONs. */

  /* For stored procedures do not redo work if already done. */
  if (!context->select_lex->first_execution)
    return FALSE;

  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. */
5051
  TABLE_LIST *left_neighbor;
unknown's avatar
unknown committed
5052 5053 5054
  /* Table reference to the right of the current. */
  TABLE_LIST *right_neighbor= NULL;

5055 5056
  /* Note that tables in the list are in reversed order */
  for (left_neighbor= table_ref_it++; left_neighbor ; )
unknown's avatar
unknown committed
5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074
  {
    table_ref= left_neighbor;
    left_neighbor= table_ref_it++;
    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;
    }
    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
5075
    right_neighbor points to the left-most top-level table reference in the
unknown's avatar
unknown committed
5076 5077 5078 5079 5080 5081 5082 5083 5084 5085
    FROM clause.
  */
  DBUG_ASSERT(right_neighbor);
  context->first_name_resolution_table=
    right_neighbor->first_leaf_for_name_resolution();

  return FALSE;
}


unknown's avatar
unknown committed
5086
/****************************************************************************
5087
** Expand all '*' in given fields
unknown's avatar
unknown committed
5088 5089
****************************************************************************/

5090 5091 5092
int setup_wild(THD *thd, TABLE_LIST *tables, List<Item> &fields,
	       List<Item> *sum_func_list,
	       uint wild_num)
unknown's avatar
unknown committed
5093
{
5094
  if (!wild_num)
5095
    return(0);
5096

5097
  Item *item;
unknown's avatar
unknown committed
5098
  List_iterator<Item> it(fields);
unknown's avatar
unknown committed
5099
  Query_arena *arena, backup;
5100
  DBUG_ENTER("setup_wild");
unknown's avatar
unknown committed
5101 5102

  /*
5103 5104
    Don't use arena if we are not in prepared statements or stored procedures
    For PS/SP we have to use arena to remember the changes
unknown's avatar
unknown committed
5105
  */
unknown's avatar
unknown committed
5106
  arena= thd->activate_stmt_arena_if_needed(&backup);
5107

unknown's avatar
unknown committed
5108
  while (wild_num && (item= it++))
unknown's avatar
VIEW  
unknown committed
5109
  {
5110 5111
    if (item->type() == Item::FIELD_ITEM &&
        ((Item_field*) item)->field_name &&
5112 5113
	((Item_field*) item)->field_name[0] == '*' &&
	!((Item_field*) item)->field)
5114
    {
5115
      uint elem= fields.elements;
unknown's avatar
VIEW  
unknown committed
5116
      bool any_privileges= ((Item_field *) item)->any_privileges;
unknown's avatar
unknown committed
5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127
      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.
        */
        it.replace(new Item_int("Not_used", (longlong) 1, 21));
      }
5128 5129
      else if (insert_fields(thd, ((Item_field*) item)->context,
                             ((Item_field*) item)->db_name,
unknown's avatar
unknown committed
5130
                             ((Item_field*) item)->table_name, &it,
5131
                             any_privileges))
unknown's avatar
unknown committed
5132 5133
      {
	if (arena)
unknown's avatar
unknown committed
5134
	  thd->restore_active_arena(arena, &backup);
5135
	DBUG_RETURN(-1);
unknown's avatar
unknown committed
5136
      }
5137
      if (sum_func_list)
5138 5139 5140 5141 5142 5143 5144 5145
      {
	/*
	  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;
      }
5146
      wild_num--;
5147 5148
    }
  }
unknown's avatar
unknown committed
5149 5150 5151 5152 5153 5154 5155
  if (arena)
  {
    /* make * substituting permanent */
    SELECT_LEX *select_lex= thd->lex->current_select;
    select_lex->with_wild= 0;
    select_lex->item_list= fields;

unknown's avatar
unknown committed
5156
    thd->restore_active_arena(arena, &backup);
unknown's avatar
unknown committed
5157
  }
5158
  DBUG_RETURN(0);
5159 5160
}

5161 5162 5163 5164
/****************************************************************************
** Check that all given fields exists and fill struct with current data
****************************************************************************/

5165
bool setup_fields(THD *thd, Item **ref_pointer_array,
5166
                  List<Item> &fields, ulong set_query_id,
unknown's avatar
unknown committed
5167
                  List<Item> *sum_func_list, bool allow_sum_func)
5168 5169
{
  reg2 Item *item;
5170
  ulong save_set_query_id= thd->set_query_id;
unknown's avatar
unknown committed
5171
  nesting_map save_allow_sum_func= thd->lex->allow_sum_func;
5172 5173 5174 5175
  List_iterator<Item> it(fields);
  DBUG_ENTER("setup_fields");

  thd->set_query_id=set_query_id;
5176
  DBUG_PRINT("info", ("thd->set_query_id: %d", thd->set_query_id));
unknown's avatar
unknown committed
5177 5178
  if (allow_sum_func)
    thd->lex->allow_sum_func|= 1 << thd->lex->current_select->nest_level;
5179
  thd->where= THD::DEFAULT_WHERE;
5180

5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194
  /*
    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);

unknown's avatar
unknown committed
5195 5196
  Item **ref= ref_pointer_array;
  while ((item= it++))
5197
  {
5198
    if (!item->fixed && item->fix_fields(thd, it.ref()) ||
unknown's avatar
unknown committed
5199
	(item= *(it.ref()))->check_cols(1))
unknown's avatar
unknown committed
5200
    {
unknown's avatar
unknown committed
5201
      thd->lex->allow_sum_func= save_allow_sum_func;
unknown's avatar
unknown committed
5202
      thd->set_query_id= save_set_query_id;
5203
      DBUG_PRINT("info", ("thd->set_query_id: %d", thd->set_query_id));
unknown's avatar
unknown committed
5204
      DBUG_RETURN(TRUE); /* purecov: inspected */
unknown's avatar
unknown committed
5205
    }
unknown's avatar
unknown committed
5206 5207
    if (ref)
      *(ref++)= item;
5208 5209
    if (item->with_sum_func && item->type() != Item::SUM_FUNC_ITEM &&
	sum_func_list)
5210
      item->split_sum_func(thd, ref_pointer_array, *sum_func_list);
unknown's avatar
unknown committed
5211
    thd->used_tables|= item->used_tables();
5212
  }
unknown's avatar
unknown committed
5213
  thd->lex->allow_sum_func= save_allow_sum_func;
unknown's avatar
unknown committed
5214
  thd->set_query_id= save_set_query_id;
5215
  DBUG_PRINT("info", ("thd->set_query_id: %d", thd->set_query_id));
5216
  DBUG_RETURN(test(thd->net.report_error));
5217
}
5218

5219

5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234
/*
  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)
  {
5235 5236 5237 5238 5239 5240
    if (table->merge_underlying_list)
    {
      DBUG_ASSERT(table->view &&
                  table->effective_algorithm == VIEW_ALGORITHM_MERGE);
      list= make_leaves_list(list, table->merge_underlying_list);
    }
5241 5242 5243 5244 5245 5246 5247 5248 5249
    else
    {
      *list= table;
      list= &table->next_leaf;
    }
  }
  return list;
}

5250
/*
unknown's avatar
unknown committed
5251 5252 5253 5254
  prepare tables

  SYNOPSIS
    setup_tables()
unknown's avatar
unknown committed
5255
    thd		  Thread handler
5256
    context       name resolution contest to setup table list there
unknown's avatar
unknown committed
5257 5258
    from_clause   Top-level list of table references in the FROM clause
    tables	  Table list (select_lex->table_list)
unknown's avatar
unknown committed
5259
    conds	  Condition of current SELECT (can be changed by VIEW)
unknown's avatar
unknown committed
5260
    leaves        List of join table leaves list (select_lex->leaf_tables)
unknown's avatar
unknown committed
5261 5262
    refresh       It is onle refresh for subquery
    select_insert It is SELECT ... INSERT command
unknown's avatar
unknown committed
5263

unknown's avatar
unknown committed
5264 5265
  NOTE
    Check also that the 'used keys' and 'ignored keys' exists and set up the
unknown's avatar
unknown committed
5266 5267 5268 5269
    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.
5270

unknown's avatar
unknown committed
5271 5272
    This has to be called for all tables that are used by items, as otherwise
    table->map is not set and all Item_field will be regarded as const items.
unknown's avatar
VIEW  
unknown committed
5273

unknown's avatar
unknown committed
5274
  RETURN
unknown's avatar
unknown committed
5275
    FALSE ok;  In this case *map will includes the chosen index
unknown's avatar
unknown committed
5276
    TRUE  error
5277 5278
*/

5279
bool setup_tables(THD *thd, Name_resolution_context *context,
unknown's avatar
unknown committed
5280 5281
                  List<TABLE_LIST> *from_clause, TABLE_LIST *tables,
                  Item **conds, TABLE_LIST **leaves, bool select_insert)
5282
{
unknown's avatar
unknown committed
5283
  uint tablenr= 0;
5284
  DBUG_ENTER("setup_tables");
5285

unknown's avatar
unknown committed
5286
  context->table_list= context->first_name_resolution_table= tables;
5287

unknown's avatar
unknown committed
5288 5289
  /*
    this is used for INSERT ... SELECT.
5290
    For select we setup tables except first (and its underlying tables)
unknown's avatar
unknown committed
5291 5292 5293 5294
  */
  TABLE_LIST *first_select_table= (select_insert ?
                                   tables->next_local:
                                   0);
5295 5296 5297
  if (!(*leaves))
    make_leaves_list(leaves, tables);

unknown's avatar
unknown committed
5298 5299
  TABLE_LIST *table_list;
  for (table_list= *leaves;
unknown's avatar
VIEW  
unknown committed
5300
       table_list;
5301
       table_list= table_list->next_leaf, tablenr++)
unknown's avatar
unknown committed
5302
  {
unknown's avatar
unknown committed
5303
    TABLE *table= table_list->table;
unknown's avatar
unknown committed
5304
    if (first_select_table &&
5305
        table_list->top_table() == first_select_table)
unknown's avatar
unknown committed
5306 5307 5308 5309 5310
    {
      /* new counting for SELECT of INSERT ... SELECT command */
      first_select_table= 0;
      tablenr= 0;
    }
unknown's avatar
unknown committed
5311
    setup_table_map(table, table_list, tablenr);
5312
    table->used_keys= table->s->keys_for_keyread;
unknown's avatar
unknown committed
5313
    if (table_list->use_index)
unknown's avatar
unknown committed
5314
    {
5315 5316 5317
      key_map map;
      get_key_map_from_key_list(&map, table, table_list->use_index);
      if (map.is_set_all())
5318
	DBUG_RETURN(1);
unknown's avatar
unknown committed
5319
      table->keys_in_use_for_query=map;
unknown's avatar
unknown committed
5320
    }
unknown's avatar
unknown committed
5321
    if (table_list->ignore_index)
unknown's avatar
unknown committed
5322
    {
5323 5324 5325
      key_map map;
      get_key_map_from_key_list(&map, table, table_list->ignore_index);
      if (map.is_set_all())
5326
	DBUG_RETURN(1);
5327
      table->keys_in_use_for_query.subtract(map);
unknown's avatar
unknown committed
5328
    }
5329
    table->used_keys.intersect(table->keys_in_use_for_query);
unknown's avatar
unknown committed
5330 5331 5332 5333
  }
  if (tablenr > MAX_TABLES)
  {
    my_error(ER_TOO_MANY_TABLES,MYF(0),MAX_TABLES);
5334
    DBUG_RETURN(1);
unknown's avatar
unknown committed
5335
  }
unknown's avatar
unknown committed
5336
  for (table_list= tables;
5337 5338
       table_list;
       table_list= table_list->next_local)
5339
  {
5340
    if (table_list->merge_underlying_list)
5341
    {
5342 5343
      DBUG_ASSERT(table_list->view &&
                  table_list->effective_algorithm == VIEW_ALGORITHM_MERGE);
unknown's avatar
unknown committed
5344
      Query_arena *arena= thd->stmt_arena, backup;
5345 5346 5347 5348
      bool res;
      if (arena->is_conventional())
        arena= 0;                                   // For easier test
      else
unknown's avatar
unknown committed
5349
        thd->set_n_backup_active_arena(arena, &backup);
5350
      res= table_list->setup_underlying(thd);
5351
      if (arena)
unknown's avatar
unknown committed
5352
        thd->restore_active_arena(arena, &backup);
5353 5354 5355
      if (res)
        DBUG_RETURN(1);
    }
5356
  }
unknown's avatar
unknown committed
5357 5358 5359 5360 5361

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

5362
  DBUG_RETURN(0);
unknown's avatar
unknown committed
5363
}
5364

unknown's avatar
unknown committed
5365

5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380
/*
   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,
5381
                               List<String> *index_list)
unknown's avatar
unknown committed
5382
{
unknown's avatar
unknown committed
5383
  List_iterator_fast<String> it(*index_list);
unknown's avatar
unknown committed
5384 5385
  String *name;
  uint pos;
5386 5387

  map->clear_all();
unknown's avatar
unknown committed
5388 5389
  while ((name=it++))
  {
5390 5391 5392
    if (table->s->keynames.type_names == 0 ||
        (pos= find_type(&table->s->keynames, name->ptr(),
                        name->length(), 1)) <=
5393
        0)
unknown's avatar
unknown committed
5394
    {
unknown's avatar
unknown committed
5395
      my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), name->c_ptr(),
unknown's avatar
unknown committed
5396
	       table->s->table_name.str);
5397
      map->set_all();
5398
      return 1;
unknown's avatar
unknown committed
5399
    }
5400
    map->set_bit(pos-1);
unknown's avatar
unknown committed
5401
  }
5402
  return 0;
unknown's avatar
unknown committed
5403 5404
}

5405

5406 5407 5408 5409 5410 5411
/*
  Drops in all fields instead of current '*' field

  SYNOPSIS
    insert_fields()
    thd			Thread handler
5412
    context             Context for name resolution
5413 5414 5415 5416 5417 5418 5419
    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
5420
    0	ok     'it' is updated to point at last inserted
unknown's avatar
unknown committed
5421
    1	error.  Error message is generated but not sent to client
5422
*/
unknown's avatar
unknown committed
5423

unknown's avatar
unknown committed
5424
bool
5425
insert_fields(THD *thd, Name_resolution_context *context, const char *db_name,
unknown's avatar
VIEW  
unknown committed
5426
	      const char *table_name, List_iterator<Item> *it,
5427
              bool any_privileges)
unknown's avatar
unknown committed
5428
{
unknown's avatar
unknown committed
5429 5430
  Field_iterator_table_ref field_iterator;
  bool found;
unknown's avatar
unknown committed
5431
  char name_buff[NAME_LEN+1];
unknown's avatar
unknown committed
5432
  DBUG_ENTER("insert_fields");
unknown's avatar
unknown committed
5433
  DBUG_PRINT("arena", ("stmt arena: 0x%lx", (ulong)thd->stmt_arena));
unknown's avatar
unknown committed
5434

5435 5436
  if (db_name && lower_case_table_names)
  {
unknown's avatar
unknown committed
5437 5438 5439 5440 5441
    /*
      convert database to lower case for comparison
      We can't do this in Item_field as this would change the
      'name' of the item which may be used in the select list
    */
unknown's avatar
unknown committed
5442
    strmake(name_buff, db_name, sizeof(name_buff)-1);
unknown's avatar
unknown committed
5443
    my_casedn_str(files_charset_info, name_buff);
unknown's avatar
unknown committed
5444
    db_name= name_buff;
5445 5446
  }

unknown's avatar
unknown committed
5447
  found= FALSE;
5448 5449 5450 5451 5452 5453 5454 5455

  /*
    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);
5456
       tables;
5457 5458 5459
       tables= (table_name ? tables->next_local :
                tables->next_name_resolution_table)
       )
unknown's avatar
unknown committed
5460
  {
5461 5462 5463
    Field *field;
    TABLE *table= tables->table;

unknown's avatar
unknown committed
5464 5465
    DBUG_ASSERT(tables->is_leaf_for_name_resolution());

5466 5467 5468 5469
    if (table_name && my_strcasecmp(table_alias_charset, table_name,
                                    tables->alias) ||
        (db_name && strcmp(tables->db,db_name)))
      continue;
unknown's avatar
unknown committed
5470

unknown's avatar
unknown committed
5471
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
5472 5473 5474 5475 5476 5477 5478
    /* 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);
      if (check_grant_all_columns(thd, SELECT_ACL, field_iterator.grant(),
5479 5480
                                  field_iterator.db_name(),
                                  field_iterator.table_name(),
unknown's avatar
unknown committed
5481 5482 5483
                                  &field_iterator))
        DBUG_RETURN(TRUE);
    }
unknown's avatar
unknown committed
5484
#endif
unknown's avatar
VIEW  
unknown committed
5485 5486


unknown's avatar
unknown committed
5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509
    /*
      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)
5510
      {
unknown's avatar
unknown committed
5511
        found= TRUE;
5512
        it->replace(item); /* Replace '*' with the first found item. */
5513
      }
unknown's avatar
VIEW  
unknown committed
5514
      else
unknown's avatar
unknown committed
5515 5516 5517 5518 5519 5520 5521
        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,
5522 5523 5524
        therefore if 'tables' is itself a view, it is represented by a
        temporary table. Thus in this case we can be sure that 'item' is an
        Item_field.
unknown's avatar
unknown committed
5525 5526
      */
      if (any_privileges)
5527
      {
unknown's avatar
unknown committed
5528 5529 5530 5531
        DBUG_ASSERT(tables->field_translation == NULL && table ||
                    tables->is_natural_join);
        DBUG_ASSERT(item->type() == Item::FIELD_ITEM);
        Item_field *fld= (Item_field*) item;
5532
        const char *field_table_name= field_iterator.table_name();
5533

unknown's avatar
unknown committed
5534 5535 5536 5537
        if (!tables->schema_table && 
            !(fld->have_privileges=
              (get_column_grant(thd, field_iterator.grant(),
                                field_iterator.db_name(),
5538
                                field_table_name, fld->field_name) &
unknown's avatar
unknown committed
5539 5540 5541
               VIEW_ANY_ACL)))
        {
          my_error(ER_COLUMNACCESS_DENIED_ERROR, MYF(0), "ANY",
5542 5543
                   thd->security_ctx->priv_user,
                   thd->security_ctx->host_or_ip,
5544
                   fld->field_name, field_table_name);
unknown's avatar
unknown committed
5545 5546
          DBUG_RETURN(TRUE);
        }
5547
      }
unknown's avatar
unknown committed
5548
#endif
5549

unknown's avatar
unknown committed
5550
      if ((field= field_iterator.field()))
unknown's avatar
unknown committed
5551
      {
unknown's avatar
unknown committed
5552 5553 5554 5555 5556 5557 5558
        /*
          Mark if field used before in this select.
          Used by 'insert' to verify if a field name is used twice.
        */
        if (field->query_id == thd->query_id)
          thd->dupp_field= field;
        field->query_id= thd->query_id;
unknown's avatar
unknown committed
5559
        field->table->file->ha_set_bit_in_read_set(field->fieldnr);
unknown's avatar
unknown committed
5560 5561 5562 5563 5564

        if (table)
          table->used_keys.intersect(field->part_of_key);

        if (tables->is_natural_join)
unknown's avatar
unknown committed
5565
        {
unknown's avatar
unknown committed
5566 5567
          TABLE *field_table;
          /*
5568
            In this case we are sure that the column ref will not be created
unknown's avatar
unknown committed
5569
            because it was already created and stored with the natural join.
5570
          */
unknown's avatar
unknown committed
5571
          Natural_join_column *nj_col;
unknown's avatar
unknown committed
5572
          if (!(nj_col= field_iterator.get_natural_column_ref()))
unknown's avatar
unknown committed
5573
            DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
5574
          DBUG_ASSERT(nj_col->table_field);
unknown's avatar
unknown committed
5575 5576
          field_table= nj_col->table_ref->table;
          if (field_table)
unknown's avatar
VIEW  
unknown committed
5577
          {
unknown's avatar
unknown committed
5578 5579 5580
            thd->used_tables|= field_table->map;
            field_table->used_keys.intersect(field->part_of_key);
            field_table->used_fields++;
unknown's avatar
VIEW  
unknown committed
5581
          }
unknown's avatar
unknown committed
5582
        }
unknown's avatar
unknown committed
5583
      }
unknown's avatar
unknown committed
5584 5585 5586 5587 5588 5589
      else
      {
        thd->used_tables|= item->used_tables();
        item->walk(&Item::reset_query_id_processor,
                   (byte *)(&thd->query_id));
      }
unknown's avatar
unknown committed
5590
    }
unknown's avatar
unknown committed
5591 5592 5593 5594 5595 5596 5597
    /*
      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)
5598
    {
unknown's avatar
unknown committed
5599
      table->used_fields= table->s->fields;
5600 5601
      table->file->ha_set_all_bits_in_read_set();
    }
unknown's avatar
unknown committed
5602
  }
5603
  if (found)
unknown's avatar
unknown committed
5604
    DBUG_RETURN(FALSE);
5605

unknown's avatar
unknown committed
5606
  /*
5607 5608 5609
    TODO: in the case when we skipped all columns because there was a
    qualified '*', and all columns were coalesced, we have to give a more
    meaningful message than ER_BAD_TABLE_ERROR.
unknown's avatar
unknown committed
5610
  */
5611
  if (!table_name)
unknown's avatar
unknown committed
5612
    my_message(ER_NO_TABLES_USED, ER(ER_NO_TABLES_USED), MYF(0));
5613 5614
  else
    my_error(ER_BAD_TABLE_ERROR, MYF(0), table_name);
unknown's avatar
unknown committed
5615 5616

  DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
5617 5618 5619 5620
}


/*
unknown's avatar
unknown committed
5621
  Fix all conditions and outer join expressions.
5622 5623 5624 5625

  SYNOPSIS
    setup_conds()
    thd     thread handler
unknown's avatar
unknown committed
5626 5627 5628 5629 5630 5631 5632 5633 5634 5635
    tables  list of tables for name resolving (select_lex->table_list)
    leaves  list of leaves of join table tree (select_lex->leaf_tables)
    conds   WHERE clause

  DESCRIPTION
    TODO

  RETURN
    TRUE  if some error occured (e.g. out of memory)
    FALSE if all is OK
unknown's avatar
unknown committed
5636 5637
*/

5638 5639
int setup_conds(THD *thd, TABLE_LIST *tables, TABLE_LIST *leaves,
                COND **conds)
unknown's avatar
unknown committed
5640
{
unknown's avatar
unknown committed
5641
  SELECT_LEX *select_lex= thd->lex->current_select;
unknown's avatar
unknown committed
5642
  Query_arena *arena= thd->stmt_arena, backup;
unknown's avatar
unknown committed
5643
  TABLE_LIST *table= NULL;	// For HP compilers
5644 5645 5646 5647 5648 5649 5650 5651 5652 5653
  /*
    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();
unknown's avatar
unknown committed
5654
  DBUG_ENTER("setup_conds");
unknown's avatar
unknown committed
5655

unknown's avatar
unknown committed
5656
  if (select_lex->conds_processed_with_permanent_arena ||
unknown's avatar
unknown committed
5657
      arena->is_conventional())
unknown's avatar
unknown committed
5658 5659
    arena= 0;                                   // For easier test

unknown's avatar
unknown committed
5660
  thd->set_query_id=1;
5661
  DBUG_PRINT("info", ("thd->set_query_id: %d", thd->set_query_id));
unknown's avatar
unknown committed
5662
  select_lex->cond_count= 0;
unknown's avatar
VIEW  
unknown committed
5663

5664 5665 5666 5667 5668 5669
  for (table= tables; table; table= table->next_local)
  {
    if (table->prepare_where(thd, conds, FALSE))
      goto err_no_arena;
  }

unknown's avatar
unknown committed
5670 5671 5672
  if (*conds)
  {
    thd->where="where clause";
5673
    if (!(*conds)->fixed && (*conds)->fix_fields(thd, conds) ||
unknown's avatar
unknown committed
5674
	(*conds)->check_cols(1))
5675
      goto err_no_arena;
unknown's avatar
unknown committed
5676 5677
  }

unknown's avatar
unknown committed
5678 5679 5680 5681
  /*
    Apply fix_fields() to all ON clauses at all levels of nesting,
    including the ones inside view definitions.
  */
unknown's avatar
merge  
unknown committed
5682
  for (table= leaves; table; table= table->next_leaf)
unknown's avatar
unknown committed
5683
  {
unknown's avatar
unknown committed
5684 5685
    TABLE_LIST *embedded; /* The table at the current level of nesting. */
    TABLE_LIST *embedding= table; /* The parent nested table reference. */
5686
    do
unknown's avatar
VIEW  
unknown committed
5687
    {
5688 5689
      embedded= embedding;
      if (embedded->on_expr)
5690
      {
5691 5692
        /* Make a join an a expression */
        thd->where="on clause";
unknown's avatar
VIEW  
unknown committed
5693
        if (!embedded->on_expr->fixed &&
5694
            embedded->on_expr->fix_fields(thd, &embedded->on_expr) ||
5695
	    embedded->on_expr->check_cols(1))
5696
	  goto err_no_arena;
unknown's avatar
unknown committed
5697
        select_lex->cond_count++;
5698
      }
5699
      embedding= embedded->embedding;
unknown's avatar
unknown committed
5700
    }
5701 5702
    while (embedding &&
           embedding->nested_join->join_list.head() == embedded);
5703 5704 5705 5706

    /* process CHECK OPTION */
    if (it_is_update)
    {
unknown's avatar
unknown committed
5707
      TABLE_LIST *view= table->top_table();
5708 5709 5710 5711 5712 5713 5714
      if (view->effective_with_check)
      {
        if (view->prepare_check_option(thd))
          goto err_no_arena;
        thd->change_item_tree(&table->check_option, view->check_option);
      }
    }
unknown's avatar
unknown committed
5715
  }
unknown's avatar
unknown committed
5716

unknown's avatar
unknown committed
5717
  if (!thd->stmt_arena->is_conventional())
unknown's avatar
unknown committed
5718 5719 5720 5721 5722 5723 5724 5725 5726 5727
  {
    /*
      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;
  }
5728
  DBUG_RETURN(test(thd->net.report_error));
unknown's avatar
unknown committed
5729

5730
err_no_arena:
unknown's avatar
unknown committed
5731
  DBUG_RETURN(1);
unknown's avatar
unknown committed
5732 5733 5734 5735 5736 5737 5738 5739
}


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

unknown's avatar
unknown committed
5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755

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

  RETURN
    FALSE   OK
    TRUE    error occured
*/

unknown's avatar
unknown committed
5756
static bool
unknown's avatar
unknown committed
5757 5758
fill_record(THD * thd, List<Item> &fields, List<Item> &values,
            bool ignore_errors)
unknown's avatar
unknown committed
5759
{
unknown's avatar
unknown committed
5760
  List_iterator_fast<Item> f(fields),v(values);
unknown's avatar
unknown committed
5761 5762 5763 5764 5765 5766 5767
  Item *value;
  Item_field *field;
  DBUG_ENTER("fill_record");

  while ((field=(Item_field*) f++))
  {
    value=v++;
5768 5769
    Field *rfield= field->field;
    TABLE *table= rfield->table;
unknown's avatar
unknown committed
5770
    if (rfield == table->next_number_field)
unknown's avatar
unknown committed
5771
      table->auto_increment_field_not_null= TRUE;
unknown's avatar
unknown committed
5772
    if ((value->save_in_field(rfield, 0) < 0) && !ignore_errors)
unknown's avatar
unknown committed
5773 5774 5775 5776
    {
      my_message(ER_UNKNOWN_ERROR, ER(ER_UNKNOWN_ERROR), MYF(0));
      DBUG_RETURN(TRUE);
    }
unknown's avatar
unknown committed
5777
  }
unknown's avatar
unknown committed
5778
  DBUG_RETURN(thd->net.report_error);
unknown's avatar
unknown committed
5779 5780 5781
}


unknown's avatar
unknown committed
5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816
/*
  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));
}


unknown's avatar
unknown committed
5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833
/*
  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

  RETURN
    FALSE   OK
    TRUE    error occured
*/

bool
fill_record(THD *thd, Field **ptr, List<Item> &values, bool ignore_errors)
unknown's avatar
unknown committed
5834
{
unknown's avatar
unknown committed
5835
  List_iterator_fast<Item> v(values);
unknown's avatar
unknown committed
5836 5837 5838 5839 5840 5841 5842
  Item *value;
  DBUG_ENTER("fill_record");

  Field *field;
  while ((field = *ptr++))
  {
    value=v++;
5843
    TABLE *table= field->table;
unknown's avatar
unknown committed
5844
    if (field == table->next_number_field)
unknown's avatar
unknown committed
5845
      table->auto_increment_field_not_null= TRUE;
5846
    if (value->save_in_field(field, 0) == -1)
unknown's avatar
unknown committed
5847
      DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
5848
  }
unknown's avatar
unknown committed
5849
  DBUG_RETURN(thd->net.report_error);
unknown's avatar
unknown committed
5850 5851 5852
}


unknown's avatar
unknown committed
5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887
/*
  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));
}


unknown's avatar
unknown committed
5888 5889
static void mysql_rm_tmp_tables(void)
{
unknown's avatar
unknown committed
5890 5891
  uint i, idx;
  char	filePath[FN_REFLEN], *tmpdir;
unknown's avatar
unknown committed
5892 5893 5894 5895
  MY_DIR *dirp;
  FILEINFO *file;
  DBUG_ENTER("mysql_rm_tmp_tables");

unknown's avatar
unknown committed
5896 5897 5898
  for (i=0; i<=mysql_tmpdir_list.max; i++)
  {
    tmpdir=mysql_tmpdir_list.list[i];
unknown's avatar
unknown committed
5899
    /* See if the directory exists */
unknown's avatar
unknown committed
5900 5901
    if (!(dirp = my_dir(tmpdir,MYF(MY_WME | MY_DONT_SORT))))
      continue;
unknown's avatar
unknown committed
5902

unknown's avatar
unknown committed
5903
    /* Remove all SQLxxx tables from directory */
unknown's avatar
unknown committed
5904

unknown's avatar
unknown committed
5905 5906 5907
    for (idx=0 ; idx < (uint) dirp->number_off_files ; idx++)
    {
      file=dirp->dir_entry+idx;
unknown's avatar
unknown committed
5908

unknown's avatar
unknown committed
5909 5910 5911 5912
      /* skiping . and .. */
      if (file->name[0] == '.' && (!file->name[1] ||
                                   (file->name[1] == '.' &&  !file->name[2])))
        continue;
unknown's avatar
unknown committed
5913

unknown's avatar
unknown committed
5914 5915
      if (!bcmp(file->name,tmp_file_prefix,tmp_file_prefix_length))
      {
unknown's avatar
unknown committed
5916 5917
        sprintf(filePath,"%s%s",tmpdir,file->name);
        VOID(my_delete(filePath,MYF(MY_WME)));
unknown's avatar
unknown committed
5918
      }
unknown's avatar
unknown committed
5919
    }
unknown's avatar
unknown committed
5920
    my_dirend(dirp);
unknown's avatar
unknown committed
5921
  }
unknown's avatar
unknown committed
5922 5923 5924 5925 5926 5927 5928 5929 5930 5931
  DBUG_VOID_RETURN;
}



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

/*
5932 5933 5934 5935 5936 5937 5938 5939 5940 5941
  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.
unknown's avatar
unknown committed
5942 5943
*/

5944
void remove_db_from_cache(const char *db)
unknown's avatar
unknown committed
5945 5946 5947 5948
{
  for (uint idx=0 ; idx < open_cache.records ; idx++)
  {
    TABLE *table=(TABLE*) hash_element(&open_cache,idx);
unknown's avatar
unknown committed
5949
    if (!strcmp(table->s->db.str, db))
unknown's avatar
unknown committed
5950
    {
5951
      table->s->version= 0L;			/* Free when thread is ready */
unknown's avatar
unknown committed
5952 5953 5954 5955
      if (!table->in_use)
	relink_unused(table);
    }
  }
5956
  while (unused_tables && !unused_tables->s->version)
unknown's avatar
unknown committed
5957 5958 5959 5960 5961
    VOID(hash_delete(&open_cache,(byte*) unused_tables));
}


/*
unknown's avatar
unknown committed
5962 5963 5964 5965 5966
  free all unused tables

  NOTE
    This is called by 'handle_manager' when one wants to periodicly flush
    all not used tables.
unknown's avatar
unknown committed
5967 5968 5969 5970 5971 5972 5973 5974 5975 5976 5977 5978
*/

void flush_tables()
{
  (void) pthread_mutex_lock(&LOCK_open);
  while (unused_tables)
    hash_delete(&open_cache,(byte*) unused_tables);
  (void) pthread_mutex_unlock(&LOCK_open);
}


/*
unknown's avatar
unknown committed
5979 5980 5981 5982 5983
  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.

unknown's avatar
unknown committed
5984 5985 5986
  PREREQUISITES
    Lock on LOCK_open()

unknown's avatar
unknown committed
5987 5988 5989 5990
  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
unknown's avatar
unknown committed
5991 5992
*/

5993
bool remove_table_from_cache(THD *thd, const char *db, const char *table_name,
unknown's avatar
unknown committed
5994
                             uint flags)
unknown's avatar
unknown committed
5995 5996 5997 5998
{
  char key[MAX_DBKEY_LENGTH];
  uint key_length;
  TABLE *table;
unknown's avatar
unknown committed
5999 6000
  TABLE_SHARE *share;
  bool result= 0, signalled= 0;
unknown's avatar
unknown committed
6001 6002 6003
  DBUG_ENTER("remove_table_from_cache");

  key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
unknown's avatar
unknown committed
6004
  for (;;)
unknown's avatar
unknown committed
6005
  {
6006
    HASH_SEARCH_STATE state;
unknown's avatar
unknown committed
6007 6008
    result= signalled= 0;

6009 6010
    for (table= (TABLE*) hash_first(&open_cache, (byte*) key, key_length,
                                    &state);
unknown's avatar
unknown committed
6011
         table;
6012 6013
         table= (TABLE*) hash_next(&open_cache, (byte*) key, key_length,
                                   &state))
unknown's avatar
unknown committed
6014
    {
unknown's avatar
unknown committed
6015
      THD *in_use;
6016

6017
      table->s->version=0L;		/* Free when thread is ready */
unknown's avatar
unknown committed
6018
      if (!(in_use=table->in_use))
unknown's avatar
unknown committed
6019
      {
unknown's avatar
unknown committed
6020 6021
        DBUG_PRINT("info",("Table was not in use"));
        relink_unused(table);
unknown's avatar
unknown committed
6022
      }
unknown's avatar
unknown committed
6023
      else if (in_use != thd)
6024
      {
unknown's avatar
unknown committed
6025
        DBUG_PRINT("info", ("Table was in use by other thread"));
unknown's avatar
unknown committed
6026 6027 6028 6029 6030 6031 6032
        in_use->some_tables_deleted=1;
        if (table->db_stat)
  	  result=1;
        /* Kill delayed insert threads */
        if ((in_use->system_thread & SYSTEM_THREAD_DELAYED_INSERT) &&
            ! in_use->killed)
        {
6033
	  in_use->killed= THD::KILL_CONNECTION;
unknown's avatar
unknown committed
6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052
	  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
	  as the thread may be waiting to get a lock for another table
        */
        for (TABLE *thd_table= in_use->open_tables;
	     thd_table ;
	     thd_table= thd_table->next)
        {
	  if (thd_table->db_stat)		// If table is open
unknown's avatar
unknown committed
6053
	    signalled|= mysql_lock_abort_for_thread(thd, thd_table);
unknown's avatar
unknown committed
6054
        }
6055
      }
unknown's avatar
unknown committed
6056
      else
unknown's avatar
unknown committed
6057 6058 6059
      {
        DBUG_PRINT("info", ("Table was in use by current thread. db_stat: %u",
                            table->db_stat));
unknown's avatar
unknown committed
6060
        result= result || (flags & RTFC_OWNED_BY_THD_FLAG);
unknown's avatar
unknown committed
6061
      }
unknown's avatar
unknown committed
6062
    }
unknown's avatar
unknown committed
6063
    while (unused_tables && !unused_tables->s->version)
unknown's avatar
unknown committed
6064
      VOID(hash_delete(&open_cache,(byte*) unused_tables));
unknown's avatar
unknown committed
6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080

    DBUG_PRINT("info", ("Removing table from table_def_cache"));
    /* Remove table from table definition cache if it's not in use */
    if ((share= (TABLE_SHARE*) hash_search(&table_def_cache,(byte*) key,
                                           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);
        VOID(hash_delete(&table_def_cache, (byte*) share));
      }
    }

unknown's avatar
unknown committed
6081
    if (result && (flags & RTFC_WAIT_OTHER_THREAD_FLAG))
unknown's avatar
unknown committed
6082
    {
unknown's avatar
unknown committed
6083
      if (!(flags & RTFC_CHECK_KILLED_FLAG) || !thd->killed)
6084
      {
unknown's avatar
unknown committed
6085
        dropping_tables++;
unknown's avatar
unknown committed
6086 6087 6088 6089
        if (likely(signalled))
          (void) pthread_cond_wait(&COND_refresh, &LOCK_open);
        else
        {
unknown's avatar
unknown committed
6090
          struct timespec abstime;
unknown's avatar
unknown committed
6091 6092 6093 6094 6095 6096 6097 6098 6099 6100
          /*
            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.
          */
unknown's avatar
unknown committed
6101 6102
          set_timespec(abstime, 10);
          pthread_cond_timedwait(&COND_refresh, &LOCK_open, &abstime);
unknown's avatar
unknown committed
6103
        }
unknown's avatar
unknown committed
6104 6105
        dropping_tables--;
        continue;
6106
      }
unknown's avatar
unknown committed
6107
    }
unknown's avatar
unknown committed
6108
    break;
unknown's avatar
unknown committed
6109 6110 6111 6112
  }
  DBUG_RETURN(result);
}

unknown's avatar
unknown committed
6113

6114
int setup_ftfuncs(SELECT_LEX *select_lex)
unknown's avatar
unknown committed
6115
{
6116 6117
  List_iterator<Item_func_match> li(*(select_lex->ftfunc_list)),
                                 lj(*(select_lex->ftfunc_list));
6118
  Item_func_match *ftf, *ftf2;
unknown's avatar
unknown committed
6119 6120

  while ((ftf=li++))
6121
  {
unknown's avatar
unknown committed
6122 6123
    if (ftf->fix_index())
      return 1;
6124 6125
    lj.rewind();
    while ((ftf2=lj++) != ftf)
6126
    {
6127
      if (ftf->eq(ftf2,1) && !ftf2->master)
6128 6129 6130
        ftf2->master=ftf;
    }
  }
unknown's avatar
unknown committed
6131 6132 6133

  return 0;
}
6134

6135

6136
int init_ftfuncs(THD *thd, SELECT_LEX *select_lex, bool no_order)
6137
{
6138
  if (select_lex->ftfunc_list->elements)
6139
  {
6140
    List_iterator<Item_func_match> li(*(select_lex->ftfunc_list));
unknown's avatar
unknown committed
6141 6142 6143
    Item_func_match *ifm;
    DBUG_PRINT("info",("Performing FULLTEXT search"));
    thd->proc_info="FULLTEXT initialization";
6144

unknown's avatar
unknown committed
6145 6146 6147
    while ((ifm=li++))
      ifm->init_search(no_order);
  }
6148 6149
  return 0;
}
unknown's avatar
VIEW  
unknown committed
6150 6151 6152 6153 6154 6155 6156


/*
  open new .frm format table

  SYNOPSIS
    open_new_frm()
6157
    THD		  thread handler
unknown's avatar
unknown committed
6158
    path	  path to .frm file (without extension)
unknown's avatar
VIEW  
unknown committed
6159
    alias	  alias for table
6160 6161
    db            database
    table_name    name of table
unknown's avatar
VIEW  
unknown committed
6162 6163 6164 6165 6166 6167 6168 6169
    db_stat	  open flags (for example HA_OPEN_KEYFILE|HA_OPEN_RNDFILE..)
		  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
*/
6170

6171
static bool
unknown's avatar
unknown committed
6172
open_new_frm(THD *thd, TABLE_SHARE *share, const char *alias,
6173
             uint db_stat, uint prgflag,
unknown's avatar
VIEW  
unknown committed
6174 6175 6176 6177
	     uint ha_open_flags, TABLE *outparam, TABLE_LIST *table_desc,
	     MEM_ROOT *mem_root)
{
  LEX_STRING pathstr;
6178
  File_parser *parser;
unknown's avatar
unknown committed
6179
  char path[FN_REFLEN];
6180 6181
  DBUG_ENTER("open_new_frm");

unknown's avatar
unknown committed
6182 6183 6184 6185
  /* Create path with extension */
  pathstr.length= (uint) (strxmov(path, share->normalized_path.str, reg_ext,
                                  NullS)- path);
  pathstr.str=    path;
6186

6187
  if ((parser= sql_parse_prepare(&pathstr, mem_root, 1)))
unknown's avatar
VIEW  
unknown committed
6188
  {
6189
    if (is_equal(&view_type, parser->type()))
unknown's avatar
VIEW  
unknown committed
6190
    {
6191
      if (table_desc == 0 || table_desc->required_type == FRMTYPE_TABLE)
unknown's avatar
VIEW  
unknown committed
6192
      {
unknown's avatar
unknown committed
6193 6194
        my_error(ER_WRONG_OBJECT, MYF(0), share->db.str, share->table_name.str,
                 "BASE TABLE");
6195
        goto err;
unknown's avatar
VIEW  
unknown committed
6196
      }
6197
      if (mysql_make_view(thd, parser, table_desc))
6198
        goto err;
unknown's avatar
VIEW  
unknown committed
6199 6200 6201 6202
    }
    else
    {
      /* only VIEWs are supported now */
unknown's avatar
unknown committed
6203
      my_error(ER_FRM_UNKNOWN_TYPE, MYF(0), share->path,  parser->type()->str);
6204
      goto err;
unknown's avatar
VIEW  
unknown committed
6205
    }
6206
    DBUG_RETURN(0);
unknown's avatar
VIEW  
unknown committed
6207
  }
unknown's avatar
unknown committed
6208
 
6209 6210 6211
err:
  bzero(outparam, sizeof(TABLE));	// do not run repair
  DBUG_RETURN(1);
unknown's avatar
VIEW  
unknown committed
6212
}
6213 6214 6215 6216 6217 6218


bool is_equal(const LEX_STRING *a, const LEX_STRING *b)
{
  return a->length == b->length && !strncmp(a->str, b->str, a->length);
}
unknown's avatar
unknown committed
6219 6220 6221 6222 6223 6224 6225


/*
  SYNOPSIS
    abort_and_upgrade_lock()
    lpt                           Parameter passing struct
    All parameters passed through the ALTER_PARTITION_PARAM_TYPE object
6226 6227
  RETURN VALUE
    0
unknown's avatar
unknown committed
6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240
  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
*/

6241
int abort_and_upgrade_lock(ALTER_PARTITION_PARAM_TYPE *lpt)
unknown's avatar
unknown committed
6242 6243 6244 6245 6246 6247 6248 6249 6250
{
  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));
  mysql_lock_abort(lpt->thd, lpt->table, TRUE);
  VOID(remove_table_from_cache(lpt->thd, lpt->db, lpt->table_name, flags));
  VOID(pthread_mutex_unlock(&LOCK_open));
6251
  DBUG_RETURN(0);
unknown's avatar
unknown committed
6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274 6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287 6288 6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338 6339 6340 6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361 6362 6363
}


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

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));
  mysql_lock_downgrade_write(lpt->thd, lpt->table, lpt->old_lock_type);
}


/*
  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;
  for (table= (TABLE*) hash_first(&open_cache,(byte*) key,key_length,
                                  &state) ;
       table;
       table= (TABLE*) hash_next(&open_cache,(byte*) key,key_length,
                                 &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
        as the thread may be waiting to get a lock for another table
      */
      for (TABLE *thd_table= in_use->open_tables;
           thd_table ;
           thd_table= thd_table->next)
      {
        if (thd_table->db_stat)		// If table is open
          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.
  */
  mysql_lock_abort(lpt->thd, my_table, FALSE);
  VOID(pthread_mutex_unlock(&LOCK_open));
  DBUG_VOID_RETURN;
}