sql_base.cc 188 KB
Newer Older
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
2

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

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

bk@work.mysql.com's avatar
bk@work.mysql.com 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 */
bk@work.mysql.com's avatar
bk@work.mysql.com 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"
bk@work.mysql.com's avatar
bk@work.mysql.com 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 */
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,
42
			     MEM_ROOT *mem_root);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
43 44
static void free_cache_entry(TABLE *entry);
static void mysql_rm_tmp_tables(void);
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);
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);

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

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

62

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
63
bool table_cache_init(void)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
64 65
{
  mysql_rm_tmp_tables();
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com 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;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
69 70 71 72 73
}

void table_cache_free(void)
{
  DBUG_ENTER("table_cache_free");
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);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
80 81 82
  DBUG_VOID_RETURN;
}

83
uint cached_open_tables(void)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
84 85 86 87
{
  return open_cache.records;
}

88

bk@work.mysql.com's avatar
bk@work.mysql.com committed
89 90 91
#ifdef EXTRA_DEBUG
static void check_unused(void)
{
92
  uint count= 0, open_files= 0, idx= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com 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--;
116 117
    if (entry->file)
      open_files++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
118 119 120
  }
  if (count != 0)
  {
121
    DBUG_PRINT("error",("Unused_links doesn't match open_cache: diff: %d", /* purecov: inspected */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
122 123
			count)); /* purecov: inspected */
  }
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
bk@work.mysql.com's avatar
bk@work.mysql.com committed
143 144 145 146 147
}
#else
#define check_unused()
#endif

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,
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,
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 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
                             uint key_length, uint db_flags, int *error)
{
  TABLE_SHARE *share;
  DBUG_ENTER("get_table_share");

  *error= 0;

  /* Read table definition from cache */
  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);
  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;
342
    (void) hash_delete(&table_def_cache, (byte*) share);
343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413
    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,
414
                             char *key, uint key_length,
415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 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
                             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)
{
589
  char key[NAME_LEN*2+2];
590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 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
  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;
}



monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671
/*
  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.
*/

672
OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *db, const char *wild)
673 674
{
  int result = 0;
675
  OPEN_TABLE_LIST **start_list, *open_list;
676 677
  TABLE_LIST table_list;
  DBUG_ENTER("list_open_tables");
678

679 680
  VOID(pthread_mutex_lock(&LOCK_open));
  bzero((char*) &table_list,sizeof(table_list));
681 682
  start_list= &open_list;
  open_list=0;
683

684
  for (uint idx=0 ; result == 0 && idx < open_cache.records; idx++)
685
  {
686
    OPEN_TABLE_LIST *table;
687
    TABLE *entry=(TABLE*) hash_element(&open_cache,idx);
688
    TABLE_SHARE *share= entry->s;
689

690
    if (db && my_strcasecmp(system_charset_info, db, share->db.str))
691
      continue;
692
    if (wild && wild_compare(share->table_name.str, wild, 0))
693
      continue;
694

695
    /* Check if user has SELECT privilege for any column in the table */
696 697
    table_list.db=         share->db.str;
    table_list.table_name= share->table_name.str;
698
    table_list.grant.privilege=0;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
699

700
    if (check_table_access(thd,SELECT_ACL | EXTRA_ACL,&table_list,1))
701 702 703
      continue;
    /* need to check if we haven't already listed it */
    for (table= open_list  ; table ; table=table->next)
704
    {
705 706
      if (!strcmp(table->table, share->table_name.str) &&
	  !strcmp(table->db,    share->db.str))
707 708 709 710 711 712 713
      {
	if (entry->in_use)
	  table->in_use++;
	if (entry->locked_by_name)
	  table->locked++;
	break;
      }
714
    }
715
    if (table)
716
      continue;
717
    if (!(*start_list = (OPEN_TABLE_LIST *)
718
	  sql_alloc(sizeof(**start_list)+share->table_cache_key.length)))
719
    {
720
      open_list=0;				// Out of memory
721
      break;
722
    }
723 724
    strmov((*start_list)->table=
	   strmov(((*start_list)->db= (char*) ((*start_list)+1)),
725 726
		  share->db.str)+1,
	   share->table_name.str);
727 728 729
    (*start_list)->in_use= entry->in_use ? 1 : 0;
    (*start_list)->locked= entry->locked_by_name ? 1 : 0;
    start_list= &(*start_list)->next;
730
    *start_list=0;
731 732
  }
  VOID(pthread_mutex_unlock(&LOCK_open));
733
  DBUG_RETURN(open_list);
734
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
735 736 737 738 739 740 741 742

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


void intern_close_table(TABLE *table)
{						// Free all structures
743 744
  DBUG_ENTER("intern_close_table");

bk@work.mysql.com's avatar
bk@work.mysql.com committed
745
  free_io_cache(table);
746
  delete table->triggers;
747 748 749
  if (table->file)                              // Not true if name lock
    VOID(closefrm(table, 1));			// close file
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
750 751
}

752 753 754 755 756 757 758 759 760 761
/*
  Remove table from the open table cache

  SYNOPSIS
    free_cache_entry()
    table		Table to remove

  NOTE
    We need to have a lock on LOCK_open when calling this
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783

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

784
/* Free resources allocated by filesort() and read_record() */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
785 786 787

void free_io_cache(TABLE *table)
{
788
  DBUG_ENTER("free_io_cache");
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
789
  if (table->sort.io_cache)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
790
  {
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
791 792 793
    close_cached_file(table->sort.io_cache);
    my_free((gptr) table->sort.io_cache,MYF(0));
    table->sort.io_cache=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
794
  }
795
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
796 797
}

798 799 800 801 802 803
/*
  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.
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
804

805
bool close_cached_tables(THD *thd, bool if_wait_for_refresh,
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
806
			 TABLE_LIST *tables, bool have_lock)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
807 808 809
{
  bool result=0;
  DBUG_ENTER("close_cached_tables");
810
  DBUG_ASSERT(thd || (!if_wait_for_refresh && !tables));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
811

tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
812 813
  if (!have_lock)
    VOID(pthread_mutex_lock(&LOCK_open));
814
  if (!tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
815
  {
816
    refresh_version++;				// Force close of open tables
817 818
    while (unused_tables)
    {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
819
#ifdef EXTRA_DEBUG
820 821
      if (hash_delete(&open_cache,(byte*) unused_tables))
	printf("Warning: Couldn't delete open table from hash\n");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
822
#else
823
      VOID(hash_delete(&open_cache,(byte*) unused_tables));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
824
#endif
825
    }
826 827 828 829 830 831
    /* 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));
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
832
  }
833
  else
bk@work.mysql.com's avatar
bk@work.mysql.com committed
834
  {
835
    bool found=0;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
836
    for (TABLE_LIST *table= tables; table; table= table->next_local)
837
    {
838
      if (remove_table_from_cache(thd, table->db, table->table_name,
839
                                  RTFC_OWNED_BY_THD_FLAG))
840 841 842 843
	found=1;
    }
    if (!found)
      if_wait_for_refresh=0;			// Nothing to wait for
bk@work.mysql.com's avatar
bk@work.mysql.com committed
844
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
845
#ifndef EMBEDDED_LIBRARY
846 847
  if (!tables)
    kill_delayed_threads();
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
848
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
849 850 851 852 853 854 855 856 857 858
  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";

859
    close_old_data_files(thd,thd->open_tables,1,1);
860 861
    mysql_ha_flush(thd, tables, MYSQL_HA_REOPEN_ON_USAGE | MYSQL_HA_FLUSH_ALL,
                   TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
862 863
    bool found=1;
    /* Wait until all threads has closed all the tables we had locked */
864 865
    DBUG_PRINT("info",
	       ("Waiting for others threads to close their open tables"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
866 867 868 869 870 871
    while (found && ! thd->killed)
    {
      found=0;
      for (uint idx=0 ; idx < open_cache.records ; idx++)
      {
	TABLE *table=(TABLE*) hash_element(&open_cache,idx);
872
	if ((table->s->version) < refresh_version && table->db_stat)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
873 874 875 876 877 878 879 880 881 882 883 884 885 886 887
	{
	  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;
888
    /* Set version for table */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
889
    for (TABLE *table=thd->open_tables; table ; table= table->next)
890
      table->s->version= refresh_version;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
891
  }
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
892 893
  if (!have_lock)
    VOID(pthread_mutex_unlock(&LOCK_open));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
894 895 896 897 898 899 900 901 902 903 904 905
  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);
}


906
/*
907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930
  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.
*/

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

932 933 934 935 936 937 938
  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.
939 940
    stopper             When closing tables from thd->open_tables(->next)*, 
                        don't close/remove tables starting from stopper.
941 942 943 944

  IMPLEMENTATION
    Unlocks tables and frees derived tables.
    Put all normal tables used by thread in free list.
945 946 947 948 949

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

952
void close_thread_tables(THD *thd, bool lock_in_use, bool skip_derived)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
953
{
954
  bool found_old_table;
955
  prelocked_mode_type prelocked_mode= thd->prelocked_mode;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
956 957
  DBUG_ENTER("close_thread_tables");

958 959 960 961 962 963 964 965 966 967 968
  /*
    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.
  */
969 970 971 972
  if (thd->derived_tables && !skip_derived)
  {
    TABLE *table, *next;
    /*
973 974
      Close all derived tables generated in queries like
      SELECT * FROM (SELECT * FROM t1)
975 976 977 978 979 980 981 982
    */
    for (table= thd->derived_tables ; table ; table= next)
    {
      next= table->next;
      free_tmp_table(thd, table);
    }
    thd->derived_tables= 0;
  }
983 984

  if (prelocked_mode)
985
  {
986 987 988 989 990 991 992 993 994
    /*
      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)
  {
    /*
995 996 997 998 999 1000
      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.
1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
    */
    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.
    */
1023
    DBUG_PRINT("info",("thd->prelocked_mode= NON_PRELOCKED"));
1024 1025 1026 1027 1028 1029 1030 1031
    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 */
1032
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1033

1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046
  /*
    For RBR: before calling close_thread_tables(), storage engines
    should autocommit. Hence if there is a a pending event, it belongs
    to a non-transactional engine, which writes directly to the table,
    and should therefore be flushed before unlocking and closing the
    tables.  The test above for locked tables will not be triggered
    since RBR locks and unlocks tables on a per-event basis.

    TODO (WL#3023): Change the semantics so that RBR does not lock and
    unlock tables on a per-event basis.
  */
  thd->binlog_flush_pending_rows_event(true);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1047 1048
  if (thd->lock)
  {
1049 1050
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1051
  }
1052 1053 1054 1055 1056 1057 1058 1059 1060 1061
  /*
    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()
  */
  bzero(&thd->transaction.stmt, sizeof(thd->transaction.stmt));
  if (!thd->active_transaction())
1062
    thd->transaction.xid_state.xid.null();
1063

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1064
  /* VOID(pthread_sigmask(SIG_SETMASK,&thd->block_signals,NULL)); */
1065
  if (!lock_in_use)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1066 1067
    VOID(pthread_mutex_lock(&LOCK_open));

monty@mysql.com's avatar
monty@mysql.com committed
1068
  DBUG_PRINT("info", ("thd->open_tables: %p", thd->open_tables));
1069

1070
  found_old_table= 0;
1071
  while (thd->open_tables)
1072
    found_old_table|=close_thread_table(thd, &thd->open_tables);
1073
  thd->some_tables_deleted=0;
1074

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1075
  /* Free tables to hold down open files */
1076
  while (open_cache.records > table_cache_size && unused_tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1077 1078 1079 1080 1081 1082 1083
    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));
  }
1084
  if (!lock_in_use)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1085 1086
    VOID(pthread_mutex_unlock(&LOCK_open));
  /*  VOID(pthread_sigmask(SIG_SETMASK,&thd->signals,NULL)); */
1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1098 1099 1100
  DBUG_VOID_RETURN;
}

1101 1102 1103 1104
/* move one table to free list */

bool close_thread_table(THD *thd, TABLE **table_ptr)
{
1105 1106
  bool found_old_table= 0;
  TABLE *table= *table_ptr;
1107
  DBUG_ENTER("close_thread_table");
1108
  DBUG_ASSERT(table->key_read == 0);
monty@mysql.com's avatar
monty@mysql.com committed
1109
  DBUG_ASSERT(table->file->inited == handler::NONE);
1110 1111

  *table_ptr=table->next;
1112
  if (table->s->version != refresh_version ||
1113 1114 1115 1116 1117 1118 1119
      thd->version != refresh_version || !table->db_stat)
  {
    VOID(hash_delete(&open_cache,(byte*) table));
    found_old_table=1;
  }
  else
  {
1120
    if (table->s->flush_version != flush_version)
1121
    {
1122
      table->s->flush_version= flush_version;
1123 1124 1125 1126 1127
      table->file->extra(HA_EXTRA_FLUSH);
    }
    else
    {
      // Free memory and reset for next loop
1128
      table->file->ha_reset();
1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143
    }
    table->in_use=0;
    if (unused_tables)
    {
      table->next=unused_tables;		/* Link in last */
      table->prev=unused_tables->prev;
      unused_tables->prev=table;
      table->prev->next=table;
    }
    else
      unused_tables=table->next=table->prev=table;
  }
  DBUG_RETURN(found_old_table);
}

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

1145 1146 1147
/*
  Close all temporary tables created by 'CREATE TEMPORARY TABLE' for thread
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1148 1149 1150 1151

void close_temporary_tables(THD *thd)
{
  TABLE *table,*next;
1152 1153 1154
  char *query, *end;
  uint query_buf_size; 
  bool found_user_tables = 0;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1155

1156 1157 1158
  if (!thd->temporary_tables)
    return;
  
1159
  LINT_INIT(end);
1160
  query_buf_size= 50;   // Enough for DROP ... TABLE IF EXISTS
1161

1162
  for (table=thd->temporary_tables ; table ; table=table->next)
1163
  {
1164 1165
    /*
      We are going to add 4 ` around the db/table names, so 1 does not look
1166 1167
      enough; indeed it is enough, because table->table_cache_key.length is
      greater (by 8, because of server_id and thread_id) than db||table.
1168
    */
1169 1170
    query_buf_size+= table->s->table_cache_key.length+1;
  }
1171

1172
  if ((query = alloc_root(thd->mem_root, query_buf_size)))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1173
    // Better add "if exists", in case a RESET MASTER has been done
1174
    end=strmov(query, "DROP /*!40005 TEMPORARY */ TABLE IF EXISTS ");
1175

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1176 1177
  for (table=thd->temporary_tables ; table ; table=next)
  {
1178
    if (query) // we might be out of memory, but this is not fatal
1179
    {
1180
      // skip temporary tables not created directly by the user
1181
      if (table->s->table_name.str[0] != '#')
1182
	found_user_tables = 1;
1183 1184
      end= strxmov(end, "`",table->s->db.str, "`.`",
                   table->s->table_name.str, "`,", NullS);
1185
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1186
    next=table->next;
1187
    close_temporary(table, 1, 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1188
  }
1189 1190
  if (query && found_user_tables && mysql_bin_log.is_open() &&
      !binlog_row_based) // CREATE TEMP TABLE not binlogged if row-based
1191 1192 1193 1194 1195 1196
  {
    /* The -1 is to remove last ',' */
    thd->clear_error();
    Query_log_event qinfo(thd, query, (ulong)(end-query)-1, 0, FALSE);
    /*
      Imagine the thread had created a temp table, then was doing a SELECT, and
1197 1198
      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
1199 1200 1201 1202 1203 1204 1205 1206
      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);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1207 1208 1209 1210
  thd->temporary_tables=0;
}


1211
/*
1212
  Find table in list.
1213 1214

  SYNOPSIS
1215
    find_table_in_list()
1216
    table		Pointer to table list
1217
    offset		Offset to which list in table structure to use
1218 1219
    db_name		Data base name
    table_name		Table name
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1220

1221 1222 1223
  NOTES:
    This is called by find_table_in_local_list() and
    find_table_in_global_list().
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1224 1225 1226 1227 1228 1229

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

1230 1231 1232 1233
TABLE_LIST *find_table_in_list(TABLE_LIST *table,
                               uint offset,
                               const char *db_name,
                               const char *table_name)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1234
{
1235
  for (; table; table= *(TABLE_LIST **) ((char*) table + offset))
1236
  {
1237 1238 1239 1240
    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;
1241
  }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1242 1243 1244 1245
  return table;
}


1246
/*
1247
  Test that table is unique (It's only exists once in the table list)
1248 1249 1250

  SYNOPSIS
    unique_table()
1251
    thd                   thread handle
1252
    table                 table which should be checked
1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270
    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
1271 1272

  RETURN
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1273 1274
    found duplicate
    0 if table is unique
1275 1276
*/

1277
TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list)
1278
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1279
  TABLE_LIST *res;
1280
  const char *d_name, *t_name;
serg@serg.mylan's avatar
serg@serg.mylan committed
1281 1282
  DBUG_ENTER("unique_table");
  DBUG_PRINT("enter", ("table alias: %s", table->alias));
1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294

  /*
    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)
1295
  {
1296 1297 1298 1299 1300 1301 1302 1303 1304
    /* 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);
1305
  }
1306 1307
  d_name= table->db;
  t_name= table->table_name;
1308 1309

  DBUG_PRINT("info", ("real table: %s.%s", d_name, t_name));
1310
  for (;;)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1311
  {
1312 1313 1314 1315
    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))
1316
      break;
1317 1318 1319 1320 1321
    /*
      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).
    */
1322
    table_list= res->next_global;
1323 1324
    DBUG_PRINT("info",
               ("found same copy of table or table which we should skip"));
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1325
  }
1326
  DBUG_RETURN(res);
1327 1328 1329
}


1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383
/*
  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);
}


1384
TABLE *find_temporary_table(THD *thd, const char *db, const char *table_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1385 1386
{
  char	key[MAX_DBKEY_LENGTH];
1387 1388 1389
  uint	key_length;
  TABLE_LIST table_list;
  TABLE *table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1390

1391 1392 1393 1394
  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
  return find_temporary_table(thd, &table_list);
}
1395

1396 1397 1398 1399 1400 1401 1402 1403 1404

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)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1405
  {
1406 1407 1408
    if (table->s->table_cache_key.length == key_length &&
	!memcmp(table->s->table_cache_key.str, key, key_length))
      return table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1409 1410 1411 1412
  }
  return 0;					// Not a temporary table
}

1413 1414 1415 1416 1417 1418

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

bool close_temporary_table(THD *thd, TABLE_LIST *table_list)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1419
{
1420
  TABLE *table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1421

1422
  if (!(table= find_temporary_table(thd, table_list)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1423
    return 1;
1424
  close_temporary_table(thd, table, 1, 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1425 1426 1427
  return 0;
}

1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453
/*
  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)
{
1454
  handlerton *table_type= table->s->db_type;
1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469
  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;
}


guilhem@mysql.com's avatar
guilhem@mysql.com committed
1470 1471 1472 1473 1474 1475 1476
/*
  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'.
*/
1477

1478
bool rename_temporary_table(THD* thd, TABLE *table, const char *db,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1479 1480 1481
			    const char *table_name)
{
  char *key;
1482
  TABLE_SHARE *share= table->s;
1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504
  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);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533
}


	/* 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];
1534
  uint key_length= find->s->table_cache_key.length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1535 1536
  TABLE *start=list,**prev,*next;
  prev= &start;
1537

1538
  memcpy(key, find->s->table_cache_key.str, key_length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1539 1540 1541
  for (; list ; list=next)
  {
    next=list->next;
1542 1543
    if (list->s->table_cache_key.length == key_length &&
	!memcmp(list->s->table_cache_key.str, key, key_length))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561
    {
      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;
}


1562
/*
1563 1564 1565 1566 1567 1568 1569 1570
   Wait for condition but allow the user to send a kill to mysqld

   SYNOPSIS
     wait_for_condition()
     thd	Thread handler
     mutex	mutex that is currently hold that is associated with condition
	        Will be unlocked on return     
     cond	Condition to wait for
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1571 1572
*/

1573
void wait_for_condition(THD *thd, pthread_mutex_t *mutex, pthread_cond_t *cond)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1574 1575 1576
{
  /* Wait until the current table is up to date */
  const char *proc_info;
1577 1578
  thd->mysys_var->current_mutex= mutex;
  thd->mysys_var->current_cond= cond;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1579 1580
  proc_info=thd->proc_info;
  thd->proc_info="Waiting for table";
1581
  if (!thd->killed)
1582
    (void) pthread_cond_wait(cond, mutex);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1583

1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595
  /*
    We must unlock mutex first to avoid deadlock becasue conditions are
    sent to this thread by doing locks in the following order:
    lock(mysys_var->mutex)
    lock(mysys_var->current_mutex)

    One by effect of this that one can only use wait_for_condition with
    condition variables that are guranteed to not disapper (freed) even if this
    mutex is unlocked
  */
    
  pthread_mutex_unlock(mutex);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1596 1597 1598 1599 1600 1601 1602
  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);
}

1603

1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622
/*
  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)
1623
{
1624
  TABLE *table= table_list->table;
1625
  TABLE_SHARE *share;
1626 1627 1628 1629 1630 1631
  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");
1632

1633 1634 1635 1636 1637 1638
  safe_mutex_assert_owner(&LOCK_open);

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

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

1641 1642 1643
  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))
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1644
  {
1645 1646 1647 1648 1649 1650 1651 1652 1653
    intern_close_table(table);
    /*
      If there was an error during opening of table (for example if it
      does not exist) '*table' object can be wiped out. To be able
      properly release name-lock in this case we should restore this
      object to its original state.
    */
    *table= orig_table;
    DBUG_RETURN(TRUE);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1654
  }
1655

1656 1657 1658
  share= table->s;
  share->version=0;
  share->flush_version=0;
1659 1660
  table->in_use = thd;
  check_unused();
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
1661 1662
  table->next = thd->open_tables;
  thd->open_tables = table;
1663 1664 1665
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
1666
  table->null_row= table->maybe_null= table->force_index= 0;
1667
  table->status=STATUS_NO_RECORD;
1668 1669
  table->keys_in_use_for_query= share->keys_in_use;
  table->used_keys= share->keys_for_keyread;
1670
  DBUG_RETURN(FALSE);
1671 1672
}

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

1674 1675 1676 1677 1678
/*
  Open a table.

  SYNOPSIS
    open_table()
1679 1680 1681 1682 1683 1684 1685 1686 1687 1688
    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.
1689 1690 1691 1692 1693 1694

  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
1695
          all other tables and retry the open.
1696 1697
    #     Success. Pointer to TABLE object for open table.
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1698 1699


bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1700
TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
1701
		  bool *refresh, uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1702 1703 1704 1705
{
  reg1	TABLE *table;
  char	key[MAX_DBKEY_LENGTH];
  uint	key_length;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1706
  char	*alias= table_list->alias;
1707
  HASH_SEARCH_STATE state;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1708 1709 1710 1711 1712
  DBUG_ENTER("open_table");

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

  /* an open table operation needs a lot of the stack space */
1715
  if (check_stack_overrun(thd, STACK_MIN_SIZE_FOR_OPEN, (char *)&alias))
1716 1717
    return 0;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1718 1719
  if (thd->killed)
    DBUG_RETURN(0);
1720 1721 1722

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

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1724
  if (!table_list->skip_temporary)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1725
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1726
    for (table= thd->temporary_tables; table ; table=table->next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1727
    {
1728 1729 1730
      if (table->s->table_cache_key.length == key_length +
          TMP_TABLE_KEY_EXTRA &&
	  !memcmp(table->s->table_cache_key.str, key,
monty@mysql.com's avatar
monty@mysql.com committed
1731
		  key_length + TMP_TABLE_KEY_EXTRA))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1732
      {
1733 1734
	if (table->query_id == thd->query_id ||
            thd->prelocked_mode && table->query_id)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1735
	{
1736
	  my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1737 1738 1739 1740 1741
	  DBUG_RETURN(0);
	}
	table->query_id= thd->query_id;
	table->clear_query_id= 1;
	thd->tmp_table_used= 1;
monty@mysql.com's avatar
monty@mysql.com committed
1742 1743
        DBUG_PRINT("info",("Using temporary table"));
        goto reset;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1744 1745 1746 1747
      }
    }
  }

1748
  if (thd->locked_tables || thd->prelocked_mode)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1749
  {						// Using table locks
1750
    TABLE *best_table= 0;
1751
    int best_distance= INT_MIN;
1752 1753 1754
    bool check_if_used= thd->prelocked_mode &&
                        ((int) table_list->lock_type >=
                         (int) TL_WRITE_ALLOW_WRITE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1755 1756
    for (table=thd->open_tables; table ; table=table->next)
    {
1757 1758
      if (table->s->table_cache_key.length == key_length &&
	  !memcmp(table->s->table_cache_key.str, key, key_length))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1759
      {
1760 1761
        if (check_if_used && table->query_id &&
            table->query_id != thd->query_id)
1762
        {
1763 1764 1765 1766 1767 1768 1769
          /*
            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),
1770
                   table->s->table_name.str);
1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806
          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;
            }
          }
1807
        }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1808
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1809
    }
1810 1811 1812 1813 1814 1815 1816
    if (best_table)
    {
      table= best_table;
      table->query_id= thd->query_id;
      DBUG_PRINT("info",("Using locked table"));
      goto reset;
    }
1817 1818 1819 1820 1821 1822 1823
    /*
      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];
1824
      enum legacy_db_type not_used;
1825 1826
      build_table_filename(path, sizeof(path) - 1,
                           table_list->db, table_list->table_name, reg_ext);
1827
      if (mysql_frm_type(thd, path, &not_used) == FRMTYPE_VIEW)
1828
      {
1829 1830 1831 1832 1833
        /*
          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;
1834
        table= &tab;
1835
        VOID(pthread_mutex_lock(&LOCK_open));
1836 1837
        if (!open_unireg_entry(thd, table, table_list, alias,
                              key, key_length, mem_root))
1838
        {
1839
          DBUG_ASSERT(table_list->view != 0);
1840 1841 1842 1843 1844 1845
          VOID(pthread_mutex_unlock(&LOCK_open));
          DBUG_RETURN(0); // VIEW
        }
        VOID(pthread_mutex_unlock(&LOCK_open));
      }
    }
1846
    my_error(ER_TABLE_NOT_LOCKED, MYF(0), alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1847 1848
    DBUG_RETURN(0);
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1849

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1850 1851 1852 1853
  VOID(pthread_mutex_lock(&LOCK_open));

  if (!thd->open_tables)
    thd->version=refresh_version;
1854 1855
  else if ((thd->version != refresh_version) &&
           ! (flags & MYSQL_LOCK_IGNORE_FLUSH))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1856 1857
  {
    /* Someone did a refresh while thread was opening tables */
1858 1859
    if (refresh)
      *refresh=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1860 1861 1862 1863
    VOID(pthread_mutex_unlock(&LOCK_open));
    DBUG_RETURN(0);
  }

1864
  /* close handler tables which are marked for flush */
monty@mysql.com's avatar
monty@mysql.com committed
1865
  if (thd->handler_tables)
1866
    mysql_ha_flush(thd, (TABLE_LIST*) NULL, MYSQL_HA_REOPEN_ON_USAGE, TRUE);
1867

1868 1869
  for (table= (TABLE*) hash_first(&open_cache, (byte*) key, key_length,
                                  &state);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1870
       table && table->in_use ;
1871 1872
       table= (TABLE*) hash_next(&open_cache, (byte*) key, key_length,
                                 &state))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1873
  {
1874
    if (table->s->version != refresh_version)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1875
    {
1876 1877 1878 1879 1880 1881 1882
      if (flags & MYSQL_LOCK_IGNORE_FLUSH)
      {
        /* Force close at once after usage */
        thd->version= table->s->version;
        continue;
      }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1883
      /*
1884 1885
        There is a refresh in progress for this table
        Wait until the table is freed or the thread is killed.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1886
      */
1887
      close_old_data_files(thd,thd->open_tables,0,0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1888
      if (table->in_use != thd)
1889
        wait_for_condition(thd, &LOCK_open, &COND_refresh);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1890
      else
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1891
      {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1892
	VOID(pthread_mutex_unlock(&LOCK_open));
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1893
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908
      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;
1909
    table->in_use= thd;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1910 1911 1912
  }
  else
  {
1913
    TABLE_SHARE *share;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1914
    /* Free cache if too big */
1915
    while (open_cache.records > table_cache_size && unused_tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1916 1917 1918 1919
      VOID(hash_delete(&open_cache,(byte*) unused_tables)); /* purecov: tested */

    /* make a new table */
    if (!(table=(TABLE*) my_malloc(sizeof(*table),MYF(MY_WME))))
1920 1921
    {
      VOID(pthread_mutex_unlock(&LOCK_open));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1922
      DBUG_RETURN(NULL);
1923
    }
1924 1925 1926

    if (open_unireg_entry(thd, table, table_list, alias, key, key_length,
                          mem_root))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1927
    {
1928
      my_free((gptr)table, MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1929 1930 1931
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(NULL);
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1932 1933 1934 1935 1936 1937
    if (table_list->view)
    {
      my_free((gptr)table, MYF(0));
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(0); // VIEW
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1938
    DBUG_PRINT("info", ("inserting table %p into the cache", table));
hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
1939
    VOID(my_hash_insert(&open_cache,(byte*) table));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1940 1941
  }

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1944 1945 1946 1947 1948 1949 1950 1951 1952
  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:
1953 1954
  DBUG_ASSERT(table->s->ref_count > 0 || table->s->tmp_table != NO_TMP_TABLE);

1955 1956
  if (thd->lex->need_correct_ident())
    table->alias_name_used= my_strcasecmp(table_alias_charset,
1957
                                          table->s->table_name.str, alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1958
  /* Fix alias if table name changes */
1959
  if (strcmp(table->alias, alias))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1960
  {
1961
    uint length=(uint) strlen(alias)+1;
1962 1963 1964
    table->alias= (char*) my_realloc((char*) table->alias, length,
                                     MYF(MY_WME));
    memcpy((char*) table->alias, alias, length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1965 1966 1967 1968 1969
  }
  /* These variables are also set in reopen_table() */
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
1970
  table->null_row= table->maybe_null= table->force_index= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1971
  table->status=STATUS_NO_RECORD;
1972
  table->keys_in_use_for_query= table->s->keys_in_use;
1973
  table->insert_values= 0;
1974
  table->used_keys= table->s->keys_for_keyread;
1975 1976
  table->fulltext_searched= 0;
  table->file->ft_handler= 0;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1977
  if (table->timestamp_field)
1978
    table->timestamp_field_type= table->timestamp_field->get_auto_set_type();
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1979
  table_list->updatable= 1; // It is not derived table nor non-updatable VIEW
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
1980
  DBUG_ASSERT(table->key_read == 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991
  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)
  {
1992 1993
    if (table->s->table_cache_key.length == key_length &&
	!memcmp(table->s->table_cache_key.str, key, key_length))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1994 1995 1996 1997 1998 1999
      return table;
  }
  return(0);
}


2000 2001
/*
  Reopen an table because the definition has changed.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2002

2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016
  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)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2017 2018
{
  TABLE tmp;
2019
  bool error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2020 2021
  Field **field;
  uint key,part;
2022 2023
  TABLE_LIST table_list;
  THD *thd= table->in_use;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2024 2025
  DBUG_ENTER("reopen_table");

2026 2027 2028
  DBUG_ASSERT(table->s->ref_count == 0);
  DBUG_ASSERT(!table->sort.io_cache);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2029 2030 2031
#ifdef EXTRA_DEBUG
  if (table->db_stat)
    sql_print_error("Table %s had a open data handler in reopen_table",
2032
		    table->alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2033 2034
#endif

2035 2036 2037 2038 2039
  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;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2040

2041 2042 2043 2044 2045 2046 2047 2048
  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))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2049 2050
    goto end;

2051
  /* This list copies variables set by open_table */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2052 2053 2054 2055
  tmp.tablenr=		table->tablenr;
  tmp.used_fields=	table->used_fields;
  tmp.const_table=	table->const_table;
  tmp.null_row=		table->null_row;
2056
  tmp.maybe_null=	table->maybe_null;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2057
  tmp.status=		table->status;
2058 2059
  tmp.keys_in_use_for_query= tmp.s->keys_in_use;
  tmp.used_keys= 	tmp.s->keys_for_keyread;
2060

2061 2062
  tmp.s->table_map_id=  table->s->table_map_id;

2063
  /* Get state */
2064
  tmp.in_use=    	thd;
2065
  tmp.reginfo.lock_type=table->reginfo.lock_type;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2066 2067
  tmp.grant=		table->grant;

2068
  /* Replace table in open list */
2069 2070
  tmp.next=		table->next;
  tmp.prev=		table->prev;
2071

2072
  delete table->triggers;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2073
  if (table->file)
2074
    VOID(closefrm(table, 1));		// close file, free everything
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2075

2076
  *table= tmp;
2077
  table->file->change_table_ptr(table, table->s);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2078

2079
  DBUG_ASSERT(table->alias != 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2080 2081
  for (field=table->field ; *field ; field++)
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2082
    (*field)->table= (*field)->orig_table= table;
2083
    (*field)->table_name= &table->alias;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2084
  }
2085
  for (key=0 ; key < table->s->keys ; key++)
2086
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2087
    for (part=0 ; part < table->key_info[key].usable_key_parts ; part++)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2088
      table->key_info[key].key_part[part].field->table= table;
2089
  }
2090 2091 2092
  if (table->triggers)
    table->triggers->set_table(table);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104
  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
2105
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2106 2107 2108 2109

bool close_data_tables(THD *thd,const char *db, const char *table_name)
{
  TABLE *table;
2110 2111
  DBUG_ENTER("close_data_tables");

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2112 2113
  for (table=thd->open_tables; table ; table=table->next)
  {
2114 2115
    if (!strcmp(table->s->table_name.str, table_name) &&
	!strcmp(table->s->db.str, db))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2116 2117
    {
      mysql_lock_remove(thd, thd->locked_tables,table);
2118
      close_handle_and_leave_table_as_lock(table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2119 2120
    }
  }
2121
  DBUG_RETURN(0);                               // For the future
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2122 2123 2124 2125 2126 2127 2128 2129 2130 2131
}


/*
  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)
{
2132 2133 2134
  TABLE *table,*next,**prev;
  TABLE **tables,**tables_ptr;			// For locks
  bool error=0, not_used;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2135
  DBUG_ENTER("reopen_tables");
2136

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2137 2138 2139
  if (!thd->open_tables)
    DBUG_RETURN(0);

2140
  safe_mutex_assert_owner(&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2141 2142 2143 2144
  if (get_locks)
  {
    /* The ptr is checked later */
    uint opens=0;
2145 2146
    for (table= thd->open_tables; table ; table=table->next)
      opens++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157
    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;
2158
    if (!tables || (!db_stat && reopen_table(table)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2159
    {
2160
      my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171
      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)
      {
2172
	table->s->version=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2173 2174 2175 2176 2177 2178 2179 2180 2181
	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;
2182 2183
    if ((lock= mysql_lock_tables(thd, tables, (uint) (tables_ptr - tables),
                                 0, &not_used)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198
    {
      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);
}

2199

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2200 2201 2202 2203 2204 2205
/*
  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.
*/

2206 2207
void close_old_data_files(THD *thd, TABLE *table, bool abort_locks,
			  bool send_refresh)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2208
{
2209
  bool found= send_refresh;
2210
  DBUG_ENTER("close_old_data_files");
2211

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2212 2213
  for (; table ; table=table->next)
  {
2214
    if (table->s->version != refresh_version)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2215 2216 2217 2218 2219 2220
    {
      found=1;
      if (table->db_stat)
      {
	if (abort_locks)
	{
2221
	  mysql_lock_abort(thd,table, TRUE);	// Close waiting threads
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2222 2223 2224
	  mysql_lock_remove(thd, thd->locked_tables,table);
	  table->locked_by_flush=1;		// Will be reopened with locks
	}
2225
        close_handle_and_leave_table_as_lock(table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2226 2227 2228 2229 2230
      }
    }
  }
  if (found)
    VOID(pthread_cond_broadcast(&COND_refresh)); // Signal to refresh
2231
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2232 2233 2234 2235 2236 2237 2238 2239 2240
}


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

2241
bool table_is_used(TABLE *table, bool wait_for_name_lock)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2242
{
2243
  DBUG_ENTER("table_is_used");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2244 2245
  do
  {
2246 2247 2248 2249
    char *key= table->s->table_cache_key.str;
    uint key_length= table->s->table_cache_key.length;

    DBUG_PRINT("loop", ("table_name: %s", table->alias));
konstantin@mysql.com's avatar
konstantin@mysql.com committed
2250 2251
    HASH_SEARCH_STATE state;
    for (TABLE *search= (TABLE*) hash_first(&open_cache, (byte*) key,
2252
                                             key_length, &state);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2253
	 search ;
2254 2255
         search= (TABLE*) hash_next(&open_cache, (byte*) key,
                                    key_length, &state))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2256
    {
2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275
      DBUG_PRINT("info", ("share: 0x%lx  locked_by_flush: %d  "
                          "locked_by_name: %d  db_stat: %u  version: %u",
                          (ulong) search->s,
                          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
          (We must wait until all engines are shut down to use the table)
      */
      if (search->locked_by_name && wait_for_name_lock ||
          search->locked_by_flush ||
          (search->db_stat && search->s->version < refresh_version))
	return 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2276 2277
    }
  } while ((table=table->next));
2278
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290
}


/* 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);
2291
  while (!thd->killed)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2292
  {
2293 2294
    thd->some_tables_deleted=0;
    close_old_data_files(thd,thd->open_tables,0,dropping_tables != 0);
2295
    mysql_ha_flush(thd, (TABLE_LIST*) NULL, MYSQL_HA_REOPEN_ON_USAGE, TRUE);
2296 2297
    if (!table_is_used(thd->open_tables,1))
      break;
2298
    (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2299 2300 2301 2302 2303 2304 2305
  }
  if (thd->killed)
    result= 1;					// aborted
  else
  {
    /* Now we can open all tables without any interference */
    thd->proc_info="Reopen tables";
antony@ltantony.mysql.com's avatar
antony@ltantony.mysql.com committed
2306
    thd->version= refresh_version;
2307
    result=reopen_tables(thd,0,0);
2308
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321
  pthread_mutex_unlock(&LOCK_open);
  thd->proc_info=0;
  DBUG_RETURN(result);
}


/* drop tables from locked list */

bool drop_locked_tables(THD *thd,const char *db, const char *table_name)
{
  TABLE *table,*next,**prev;
  bool found=0;
  prev= &thd->open_tables;
2322
  for (table= thd->open_tables; table ; table=next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2323 2324
  {
    next=table->next;
2325 2326
    if (!strcmp(table->s->table_name.str, table_name) &&
	!strcmp(table->s->db.str, db))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349
    {
      mysql_lock_remove(thd, thd->locked_tables,table);
      VOID(hash_delete(&open_cache,(byte*) table));
      found=1;
    }
    else
    {
      *prev=table;
      prev= &table->next;
    }
  }
  *prev=0;
  if (found)
    VOID(pthread_cond_broadcast(&COND_refresh)); // Signal to refresh
  if (thd->locked_tables && thd->locked_tables->table_count == 0)
  {
    my_free((gptr) thd->locked_tables,MYF(0));
    thd->locked_tables=0;
  }
  return found;
}


2350 2351 2352 2353 2354
/*
  If we have the table open, which only happens when a LOCK TABLE has been
  done on the table, change the lock type to a lock that will abort all
  other threads trying to get the lock.
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2355 2356 2357 2358

void abort_locked_tables(THD *thd,const char *db, const char *table_name)
{
  TABLE *table;
2359
  for (table= thd->open_tables; table ; table= table->next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2360
  {
2361 2362
    if (!strcmp(table->s->table_name.str, table_name) &&
	!strcmp(table->s->db.str, db))
2363
    {
2364
      mysql_lock_abort(thd,table, TRUE);
2365 2366
      break;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2367 2368 2369
  }
}

2370

2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389
/*
  Function to assign a new table map id to a table.

  PARAMETERS

    table - Pointer to table structure

  PRE-CONDITION(S)

    table is non-NULL
    The LOCK_open mutex is locked

  POST-CONDITION(S)

    table->s->table_map_id is given a value that with a high certainty
    is not used by any other table.

    table->s->table_map_id is not ULONG_MAX.
 */
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
2390
void assign_new_table_id(TABLE *table)
2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412
{
  static ulong last_table_id= ULONG_MAX;

  DBUG_ENTER("assign_new_table_id(TABLE*)");

  /* Preconditions */
  DBUG_ASSERT(table != NULL);
  safe_mutex_assert_owner(&LOCK_open);

  ulong tid= ++last_table_id;                   /* get next id */
  /* There is one reserved number that cannot be used. */
  if (unlikely(tid == ULONG_MAX))
    tid= ++last_table_id;
  table->s->table_map_id= tid;
  DBUG_PRINT("info", ("table_id=%lu", tid));

  /* Post conditions */
  DBUG_ASSERT(table->s->table_map_id != ULONG_MAX);

  DBUG_VOID_RETURN;
}

2413 2414 2415 2416 2417 2418 2419
/*
  Load a table definition from file and open unireg table

  SYNOPSIS
    open_unireg_entry()
    thd			Thread handle
    entry		Store open table definition here
2420
    table_list		TABLE_LIST with db, table_name & belong_to_view
2421
    alias		Alias name
2422 2423
    cache_key		Key for share_cache
    cache_key_length	length of cache_key
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2424
    mem_root		temporary mem_root for parsing
2425 2426 2427

  NOTES
   Extra argument for open is taken from thd->open_options
2428
   One must have a lock on LOCK_open when calling this function
2429 2430 2431 2432

  RETURN
    0	ok
    #	Error
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2433
*/
2434 2435 2436

static int open_unireg_entry(THD *thd, TABLE *entry, TABLE_LIST *table_list,
                             const char *alias,
2437
                             char *cache_key, uint cache_key_length,
2438
                             MEM_ROOT *mem_root)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2439
{
2440
  int error;
2441
  TABLE_SHARE *share;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2442
  uint discover_retry_count= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2443 2444
  DBUG_ENTER("open_unireg_entry");

2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467
  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);
  }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2468

2469 2470 2471 2472 2473 2474 2475
  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),
2476
                                       thd->open_options, entry, FALSE)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2477
  {
2478
    if (error == 7)                             // Table def changed
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2479
    {
2480 2481 2482 2483
      share->version= 0;                        // Mark share as old
      if (discover_retry_count++)               // Retry once
        goto err;

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2484
      /*
2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495
        TODO:
        Here we should wait until all threads has released the table.
        For now we do one retry. This may cause a deadlock if there
        is other threads waiting for other tables used by this thread.
        
        Proper fix would be to if the second retry failed:
        - Mark that table def changed
        - Return from open table
        - Close all tables used by this thread
        - Start waiting that the share is released
        - Retry by opening all tables again
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2496
      */
2497 2498
      if (ha_create_table_from_engine(thd, table_list->db,
                                      table_list->table_name))
monty@mysql.com's avatar
monty@mysql.com committed
2499
        goto err;
2500 2501 2502 2503 2504 2505
      /*
        TO BE FIXED
        To avoid deadlock, only wait for release if no one else is
        using the share.
      */
      if (share->ref_count != 1)
monty@mysql.com's avatar
monty@mysql.com committed
2506
        goto err;
2507 2508 2509
      /* Free share and wait until it's released by all threads */
      release_table_share(share, RELEASE_WAIT_FOR_DROP);
      if (!thd->killed)
2510
      {
2511 2512 2513
        mysql_reset_errors(thd, 1);         // Clear warnings
        thd->clear_error();                 // Clear error message
        goto retry;
2514
      }
2515
      DBUG_RETURN(1);
2516
    }
2517
    if (!entry->s || !entry->s->crashed)
2518
      goto err;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2519

2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539
     // 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,
2540
                               entry, FALSE) || ! entry->file ||
2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560
 	(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;
   }
2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575

  /*
    We assign a new table id under the protection of the LOCK_open
    mutex.  We assign a new table id here instead of inside openfrm()
    since that function can be used without acquiring any lock (e.g.,
    inside ha_create_table()).  Insted of creatint a new mutex and
    using it for the sole purpose of serializing accesses to a static
    variable, we assign the table id here.

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

2576 2577 2578 2579
  if (Table_triggers_list::check_n_load(thd, share->db.str,
                                        share->table_name.str, entry, 0))
  {
    closefrm(entry, 0);
2580
    goto err;
2581
  }
2582

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2583 2584 2585 2586 2587 2588 2589 2590 2591 2592
  /*
    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;
2593 2594
      uint query_buf_size= 20 + share->db.length + share->table_name.length +1;
      if ((query= (char*) my_malloc(query_buf_size,MYF(MY_WME))))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2595
      {
2596
        /* this DELETE FROM is needed even with row-based binlogging */
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2597
        end = strxmov(strmov(query, "DELETE FROM `"),
2598
                      share->db.str,"`.`",share->table_name.str,"`", NullS);
2599 2600
        thd->binlog_query(THD::STMT_QUERY_TYPE,
                          query, (ulong)(end-query), FALSE, FALSE);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2601 2602 2603 2604 2605 2606 2607 2608 2609
        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).
        */
2610 2611 2612
        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);
2613
        delete entry->triggers;
2614
        closefrm(entry, 0);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2615 2616 2617
        goto err;
      }
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2618 2619
  }
  DBUG_RETURN(0);
2620

2621
err:
2622
  release_table_share(share, RELEASE_NORMAL);
2623
  DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2624 2625
}

2626

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2627 2628 2629 2630 2631 2632
/*
  Open all tables in list

  SYNOPSIS
    open_tables()
    thd - thread handler
2633
    start - list of tables in/out
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2634
    counter - number of opened tables will be return using this parameter
2635 2636 2637
    flags   - bitmap of flags to modify how the tables will be open:
              MYSQL_LOCK_IGNORE_FLUSH - open table even if someone has
              done a flush or namelock on it.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2638

2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649
  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.

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2650 2651 2652 2653 2654
  RETURN
    0  - OK
    -1 - error
*/

2655
int open_tables(THD *thd, TABLE_LIST **start, uint *counter, uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2656 2657 2658 2659
{
  TABLE_LIST *tables;
  bool refresh;
  int result=0;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2660
  MEM_ROOT new_frm_mem;
2661 2662 2663
  /* Also used for indicating that prelocking is need */
  TABLE_LIST **query_tables_last_own;
  DBUG_ENTER("open_tables");
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2664 2665 2666 2667 2668
  /*
    temporary mem_root for new .frm parsing.
    TODO: variables for size
  */
  init_alloc_root(&new_frm_mem, 8024, 8024);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2669

2670
  thd->current_tablenr= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2671
 restart:
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2672
  *counter= 0;
2673
  query_tables_last_own= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2674
  thd->proc_info="Opening tables";
2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693

  /*
    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 can't delay prelocking until we will met some sub-statement
    which really uses tables, since this will imply that we have to restore
    its table list to be able execute it in some other context.
    And current views implementation assumes that view tables are added to
    global table list only once during PS preparing/first SP execution.
    Also locking at earlier stage is probably faster altough may decrease
    concurrency a bit.

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

2695
    NOTE: The above notes may be out of date. Please wait for psergey to
2696
          document new prelocked behavior.
2697
  */
2698 2699

  if (!thd->prelocked_mode && !thd->lex->requires_prelocking() &&
2700
      thd->lex->sroutines_list.elements)
2701
  {
2702
    bool first_no_prelocking, need_prelocking, tabs_changed;
2703
    TABLE_LIST **save_query_tables_last= thd->lex->query_tables_last;
2704 2705

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

2708 2709
    if (sp_cache_routines_and_add_tables(thd, thd->lex,
                                         first_no_prelocking,
2710
                                         &tabs_changed))
2711
    {
2712 2713 2714 2715 2716 2717
      /*
        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;
2718 2719 2720
      goto err;
    }
    else if ((tabs_changed || *start) && need_prelocking)
2721 2722 2723 2724 2725 2726 2727
    {
      query_tables_last_own= save_query_tables_last;
      *start= thd->lex->query_tables;
    }
  }

  for (tables= *start; tables ;tables= tables->next_global)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2728
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2729 2730 2731
    /*
      Ignore placeholders for derived tables. After derived tables
      processing, link to created temporary table will be put here.
2732 2733
      If this is derived table for view then we still want to process
      routines used by this view.
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2734 2735
     */
    if (tables->derived)
2736 2737 2738
    {
      if (tables->view)
        goto process_view_routines;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2739
      continue;
2740
    }
2741 2742 2743 2744 2745 2746
    if (tables->schema_table)
    {
      if (!mysql_schema_table(thd, thd->lex, tables))
        continue;
      DBUG_RETURN(-1);
    }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2747
    (*counter)++;
2748
    
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2749
    if (!tables->table &&
2750
	!(tables->table= open_table(thd, tables, &new_frm_mem, &refresh, flags)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2751
    {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2752
      free_root(&new_frm_mem, MYF(MY_KEEP_PREALLOC));
2753

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2754 2755
      if (tables->view)
      {
2756
        /* VIEW placeholder */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2757
	(*counter)--;
2758

2759
        /*
2760 2761 2762 2763 2764
          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
2765 2766 2767
          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.
2768
        */
2769
        if (query_tables_last_own == &(tables->next_global) &&
2770 2771
            tables->view->query_tables)
          query_tables_last_own= tables->view->query_tables_last;
2772
        /*
2773 2774
          Let us free memory used by 'sroutines' hash here since we never
          call destructor for this LEX.
2775
        */
2776
        hash_free(&tables->view->sroutines);
2777
	goto process_view_routines;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2778 2779
      }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2780 2781 2782 2783
      if (refresh)				// Refresh in progress
      {
	/* close all 'old' tables used by this thread */
	pthread_mutex_lock(&LOCK_open);
2784 2785
	// if query_id is not reset, we will get an error
	// re-opening a temp table
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2786 2787 2788
	thd->version=refresh_version;
	TABLE **prev_table= &thd->open_tables;
	bool found=0;
2789
	for (TABLE_LIST *tmp= *start; tmp; tmp= tmp->next_global)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2790
	{
2791
	  /* Close normal (not temporary) changed tables */
2792
	  if (tmp->table && ! tmp->table->s->tmp_table != NO_TMP_TABLE)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2793
	  {
2794
	    if (tmp->table->s->version != refresh_version ||
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808
		! tmp->table->db_stat)
	    {
	      VOID(hash_delete(&open_cache,(byte*) tmp->table));
	      tmp->table=0;
	      found=1;
	    }
	    else
	    {
	      *prev_table= tmp->table;		// Relink open list
	      prev_table= &tmp->table->next;
	    }
	  }
	}
	*prev_table=0;
2809
	pthread_mutex_unlock(&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2810 2811
	if (found)
	  VOID(pthread_cond_broadcast(&COND_refresh)); // Signal to refresh
2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823
        /*
          Let us prepare for recalculation of set of prelocked tables.
          First we pretend that we have finished calculation which we
          were doing currently. Then we restore list of tables to be
          opened and set of used routines to the state in which they were
          before first open_tables() call for this statement (i.e. before
          we have calculated current set of tables for prelocking).
        */
        if (query_tables_last_own)
          thd->lex->mark_as_requiring_prelocking(query_tables_last_own);
        thd->lex->chop_off_not_own_tables();
        sp_remove_not_own_routines(thd->lex);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2824 2825 2826 2827 2828
	goto restart;
      }
      result= -1;				// Fatal error
      break;
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2829
    else
2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843
    {
      /*
        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)
2844 2845
          query_tables_last_own= thd->lex->query_tables_last;
        if (sp_cache_routines_and_add_tables_for_triggers(thd, thd->lex,
2846
                                                          tables))
2847
        {
2848 2849 2850 2851 2852 2853
          /*
            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;
2854 2855
          goto err;
        }
2856
      }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2857
      free_root(&new_frm_mem, MYF(MY_KEEP_PREALLOC));
2858
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2859

2860
    if (tables->lock_type != TL_UNLOCK && ! thd->locked_tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2861 2862
      tables->table->reginfo.lock_type=tables->lock_type;
    tables->table->grant= tables->grant;
2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875

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;
2876
      if (sp_cache_routines_and_add_tables_for_view(thd, thd->lex, tables))
2877
      {
2878 2879 2880 2881 2882 2883
        /*
          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;
2884 2885
        goto err;
      }
2886
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2887
  }
2888 2889

 err:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2890
  thd->proc_info=0;
2891
  free_root(&new_frm_mem, MYF(0));              // Free pre-alloced block
2892 2893 2894 2895

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2896 2897 2898 2899
  DBUG_RETURN(result);
}


2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922
/*
  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)
  {
2923
    my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),table->alias);
2924 2925
    DBUG_RETURN(1);
  }
serg@serg.mylan's avatar
serg@serg.mylan committed
2926
  if ((error=table->file->start_stmt(thd, lock_type)))
2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943
  {
    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

2944 2945 2946 2947 2948
  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.

2949 2950 2951 2952 2953 2954 2955 2956 2957
  RETURN VALUES
    table		Opened table
    0			Error
  
    If ok, the following are also set:
      table_list->lock_type 	lock_type
      table_list->table		table
*/

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2958 2959 2960 2961 2962 2963 2964
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";
2965
  thd->current_tablenr= 0;
2966 2967
  /* open_ltable can be used only for BASIC TABLEs */
  table_list->required_type= FRMTYPE_TABLE;
2968
  while (!(table= open_table(thd, table_list, thd->mem_root, &refresh, 0)) &&
2969
         refresh)
2970
    ;
2971

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2972 2973
  if (table)
  {
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2974
#if defined( __WIN__) || defined(OS2)
2975
    /* Win32 can't drop a file that is open */
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2976
    if (lock_type == TL_WRITE_ALLOW_READ)
2977 2978 2979
    {
      lock_type= TL_WRITE;
    }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2980
#endif /* __WIN__ || OS2 */
2981 2982
    table_list->lock_type= lock_type;
    table_list->table=	   table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2983 2984 2985
    table->grant= table_list->grant;
    if (thd->locked_tables)
    {
2986 2987 2988 2989 2990
      if (check_lock_and_start_stmt(thd, table, lock_type))
	table= 0;
    }
    else
    {
2991
      DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
2992
      if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)
2993 2994
	if (! (thd->lock= mysql_lock_tables(thd, &table_list->table, 1, 0,
                                            &refresh)))
2995
	  table= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2996 2997 2998 2999 3000 3001
    }
  }
  thd->proc_info=0;
  DBUG_RETURN(table);
}

3002

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3003
/*
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016
  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
3017
    The lock will automaticaly be freed by close_thread_tables()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3018 3019
*/

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3020
int simple_open_n_lock_tables(THD *thd, TABLE_LIST *tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3021
{
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3022
  uint counter;
3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035
  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);
    close_tables_for_reopen(thd, tables);
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049
  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
3050 3051
    FALSE - ok
    TRUE  - error
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3052 3053

  NOTE
3054
    The lock will automaticaly be freed by close_thread_tables()
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3055 3056
*/

3057
bool open_and_lock_tables(THD *thd, TABLE_LIST *tables)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3058 3059
{
  uint counter;
3060
  bool need_reopen;
monty@mysql.com's avatar
monty@mysql.com committed
3061
  DBUG_ENTER("open_and_lock_tables");
3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073

  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);
    close_tables_for_reopen(thd, tables);
  }
  if (mysql_handle_derived(thd->lex, &mysql_derived_prepare) ||
3074 3075
      (thd->fill_derived_tables() &&
       mysql_handle_derived(thd->lex, &mysql_derived_filling)))
3076
    DBUG_RETURN(TRUE); /* purecov: inspected */
monty@mysql.com's avatar
monty@mysql.com committed
3077
  DBUG_RETURN(0);
monty@mysql.com's avatar
monty@mysql.com committed
3078 3079 3080
}


3081 3082 3083 3084 3085 3086
/*
  Open all tables in list and process derived tables

  SYNOPSIS
    open_normal_and_derived_tables
    thd		- thread handler
3087
    tables	- list of tables for open
3088 3089 3090
    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.
3091 3092 3093 3094 3095 3096 3097 3098 3099 3100

  RETURN
    FALSE - ok
    TRUE  - error

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

3101
bool open_normal_and_derived_tables(THD *thd, TABLE_LIST *tables, uint flags)
3102 3103 3104
{
  uint counter;
  DBUG_ENTER("open_normal_and_derived_tables");
monty@mysql.com's avatar
monty@mysql.com committed
3105
  DBUG_ASSERT(!thd->fill_derived_tables());
3106
  if (open_tables(thd, &tables, &counter, flags) ||
monty@mysql.com's avatar
monty@mysql.com committed
3107 3108 3109
      mysql_handle_derived(thd->lex, &mysql_derived_prepare))
    DBUG_RETURN(TRUE); /* purecov: inspected */
  DBUG_RETURN(0);
3110 3111 3112
}


3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133
/*
  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;
}


3134 3135 3136 3137 3138 3139 3140
/*
  Lock all tables in list

  SYNOPSIS
    lock_tables()
    thd			Thread handler
    tables		Tables to lock
3141 3142 3143 3144 3145 3146
    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).
3147

3148 3149 3150 3151 3152
  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.

3153 3154 3155 3156
    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.

3157 3158 3159 3160 3161
  RETURN VALUES
   0	ok
   -1	Error
*/

3162
int lock_tables(THD *thd, TABLE_LIST *tables, uint count, bool *need_reopen)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3163
{
3164
  TABLE_LIST *table;
3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177

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

3178 3179
  *need_reopen= FALSE;

3180
  if (!tables)
3181
    DBUG_RETURN(0);
3182

3183 3184 3185 3186 3187 3188 3189 3190 3191 3192
  /*
    We need this extra check for thd->prelocked_mode because we want to avoid
    attempts to lock tables in substatements. Checking for thd->locked_tables
    is not enough in some situations. For example for SP containing
    "drop table t3; create temporary t3 ..; insert into t3 ...;"
    thd->locked_tables may be 0 after drop tables, and without this extra
    check insert will try to lock temporary table t3, that will lead
    to memory leak...
  */
  if (!thd->locked_tables && !thd->prelocked_mode)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3193
  {
3194
    DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3195
    TABLE **start,**ptr;
3196

3197
    if (!(ptr=start=(TABLE**) thd->alloc(sizeof(TABLE*)*count)))
3198
      DBUG_RETURN(-1);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3199
    for (table= tables; table; table= table->next_global)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3200
    {
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
3201
      if (!table->placeholder() && !table->schema_table)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3202 3203
	*(ptr++)= table->table;
    }
3204 3205 3206 3207 3208 3209 3210 3211

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

3212 3213 3214
    if (! (thd->lock= mysql_lock_tables(thd, start, (uint) (ptr - start),
                                        MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN,
                                        need_reopen)))
3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260
    {
      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);
3261
      DBUG_PRINT("info",("prelocked_mode= PRELOCKED"));
3262 3263
      thd->prelocked_mode= PRELOCKED;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3264
  }
3265 3266
  else
  {
3267 3268
    TABLE_LIST *first_not_own= thd->lex->first_not_own_table();
    for (table= tables; table != first_not_own; table= table->next_global)
3269
    {
3270
      if (!table->placeholder() && !table->schema_table &&
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3271
	  check_lock_and_start_stmt(thd, table->table, table->lock_type))
3272
      {
3273
	ha_rollback_stmt(thd);
3274
	DBUG_RETURN(-1);
3275 3276
      }
    }
3277 3278 3279 3280 3281 3282 3283 3284
    /*
      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);
3285
      DBUG_PRINT("info", ("thd->prelocked_mode= PRELOCKED_UNDER_LOCK_TABLES"));
3286 3287
      thd->prelocked_mode= PRELOCKED_UNDER_LOCK_TABLES;
    }
3288
  }
3289
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3290 3291
}

3292

3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314
/*
  Prepare statement for reopening of tables and recalculation of set of
  prelocked tables.

  SYNOPSIS
    close_tables_for_reopen()
      thd     Thread context
      tables  List of tables which we were trying to open and lock

*/

void close_tables_for_reopen(THD *thd, TABLE_LIST *tables)
{
  thd->lex->chop_off_not_own_tables();
  sp_remove_not_own_routines(thd->lex);
  for (TABLE_LIST *tmp= tables; tmp; tmp= tmp->next_global)
    if (tmp->table && !tmp->table->s->tmp_table)
      tmp->table= 0;
  close_thread_tables(thd);
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
3315
/*
3316
  Open a single table without table caching and don't set it in open_list
3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332

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

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

 RETURN
   0  Error
   #  TABLE object
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3333 3334 3335 3336 3337 3338
*/

TABLE *open_temporary_table(THD *thd, const char *path, const char *db,
			    const char *table_name, bool link_in_list)
{
  TABLE *tmp_table;
3339
  TABLE_SHARE *share;
3340 3341 3342
  char cache_key[MAX_DBKEY_LENGTH], *saved_cache_key, *tmp_path;
  uint key_length;
  TABLE_LIST table_list;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3343
  DBUG_ENTER("open_temporary_table");
3344

3345 3346 3347 3348 3349 3350 3351 3352
  table_list.db=         (char*) db;
  table_list.table_name= (char*) table_name;
  /* Create the cache_key for temporary tables */
  key_length= create_table_def_key(thd, cache_key, &table_list, 1);

  if (!(tmp_table= (TABLE*) my_malloc(sizeof(*tmp_table) + sizeof(*share) +
                                      strlen(path)+1 + key_length,
                                      MYF(MY_WME))))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3353 3354
    DBUG_RETURN(0);				/* purecov: inspected */

3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368
  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,
3369
                            tmp_table, FALSE))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3370
  {
3371 3372
    /* No need to lock share->mutex as this is not needed for tmp tables */
    free_table_share(share);
3373
    my_free((char*) tmp_table,MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3374 3375 3376
    DBUG_RETURN(0);
  }

3377
  tmp_table->reginfo.lock_type= TL_WRITE;	 // Simulate locked
3378 3379
  share->tmp_table= (tmp_table->file->has_transactions() ? 
                     TRANSACTIONAL_TMP_TABLE : TMP_TABLE);
3380

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3381 3382
  if (link_in_list)
  {
3383 3384 3385 3386
    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;
3387 3388
    if (thd->slave_thread)
      slave_open_temp_tables++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3389 3390 3391 3392 3393
  }
  DBUG_RETURN(tmp_table);
}


3394
bool rm_temporary_table(handlerton *base, char *path)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3395 3396
{
  bool error=0;
3397 3398
  handler *file;
  char *ext;
3399 3400
  DBUG_ENTER("rm_temporary_table");

3401
  strmov(ext= strend(path), reg_ext);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3402 3403
  if (my_delete(path,MYF(0)))
    error=1; /* purecov: inspected */
3404 3405
  *ext= 0;				// remove extension
  file= get_new_handler((TABLE_SHARE*) 0, current_thd->mem_root, base);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3406
  if (file && file->delete_table(path))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3407
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3408
    error=1;
3409
    sql_print_warning("Could not remove temporary table: '%s', error: %d",
serg@serg.mylan's avatar
serg@serg.mylan committed
3410
                      path, my_errno);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3411
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3412
  delete file;
3413
  DBUG_RETURN(error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3414 3415 3416 3417
}


/*****************************************************************************
3418 3419 3420 3421 3422 3423
* The following find_field_in_XXX procedures implement the core of the
* name resolution functionality. The entry point to resolve a column name in a
* list of tables is 'find_field_in_tables'. It calls 'find_field_in_table_ref'
* for each table reference. In turn, depending on the type of table reference,
* 'find_field_in_table_ref' calls one of the 'find_field_in_XXX' procedures
* below specific for the type of table reference.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3424 3425
******************************************************************************/

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

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

3432 3433 3434 3435
static void update_field_dependencies(THD *thd, Field *field, TABLE *table)
{
  if (thd->set_query_id)
  {
3436 3437
    table->file->ha_set_bit_in_rw_set(field->fieldnr,
                                      (bool)(thd->set_query_id-1));
3438 3439
    if (field->query_id != thd->query_id)
    {
3440 3441
      if (table->get_fields_in_item_tree)
        field->flags|= GET_FIXED_FIELDS_FLAG;
3442 3443 3444 3445 3446 3447
      field->query_id= thd->query_id;
      table->used_fields++;
      table->used_keys.intersect(field->part_of_key);
    }
    else
      thd->dupp_field= field;
3448 3449
  } else if (table->get_fields_in_item_tree)
    field->flags|= GET_FIXED_FIELDS_FLAG;
3450 3451
}

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3452 3453

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

  SYNOPSIS
3457
    find_field_in_view()
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3458
    thd				thread handler
3459
    table_list			view to search for 'name'
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3460 3461
    name			name of field
    length			length of name
3462
    item_name                   name of item if it will be created (VIEW)
3463 3464
    ref				expression substituted in VIEW should be passed
                                using this reference (return view_ref_found)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3465
    register_tree_change        TRUE if ref is not stack variable and we
3466
                                need register changes in item tree
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3467 3468 3469 3470

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

3474 3475
static Field *
find_field_in_view(THD *thd, TABLE_LIST *table_list,
3476 3477
                   const char *name, uint length,
                   const char *item_name, Item **ref,
3478
                   bool register_tree_change)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3479
{
3480 3481 3482 3483 3484 3485
  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);
3486 3487
  Query_arena *arena, backup;  
  
3488 3489 3490
  DBUG_ASSERT(table_list->schema_table_reformed ||
              (ref != 0 && table_list->view != 0));
  for (; !field_it.end_of_fields(); field_it.next())
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3491
  {
3492
    if (!my_strcasecmp(system_charset_info, field_it.name(), name))
3493
    {
3494 3495 3496
      // in PS use own arena or data will be freed after prepare
      if (register_tree_change)
        arena= thd->activate_stmt_arena_if_needed(&backup);
3497 3498 3499 3500
      /*
        create_item() may, or may not create a new Item, depending on
        the column reference. See create_view_field() for details.
      */
3501
      Item *item= field_it.create_item(thd);
3502 3503 3504
      if (register_tree_change && arena)
        thd->restore_active_arena(arena, &backup);
      
3505 3506 3507 3508 3509 3510
      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.
3511
       We need to set alias on both ref itself and on ref real item.
3512 3513
      */
      if (*ref && !(*ref)->is_autogenerated_name)
3514
      {
3515 3516
        item->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
3517 3518 3519
        item->real_item()->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
      }
3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547
      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

3548 3549 3550 3551 3552 3553
  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.

3554
  RETURN
3555 3556 3557
    NULL        if the field was not found
    WRONG_GRANT if no access rights to the found field
    #           Pointer to the found Field
3558 3559 3560 3561
*/

static Field *
find_field_in_natural_join(THD *thd, TABLE_LIST *table_ref, const char *name,
3562
                           uint length, Item **ref, bool register_tree_change,
3563
                           TABLE_LIST **actual_table)
3564
{
3565 3566 3567 3568
  List_iterator_fast<Natural_join_column>
    field_it(*(table_ref->join_columns));
  Natural_join_column *nj_col;
  Field *found_field;
3569
  Query_arena *arena, backup;
3570
  DBUG_ENTER("find_field_in_natural_join");
3571
  DBUG_PRINT("enter", ("field name: '%s', ref 0x%lx",
3572 3573
		       name, (ulong) ref));
  DBUG_ASSERT(table_ref->is_natural_join && table_ref->join_columns);
3574
  DBUG_ASSERT(*actual_table == NULL);
3575

3576
  LINT_INIT(found_field);
3577

3578
  for (;;)
3579
  {
3580 3581 3582
    if (!(nj_col= field_it++))
      DBUG_RETURN(NULL);

3583 3584
    if (!my_strcasecmp(system_charset_info, nj_col->name(), name))
      break;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3585
  }
3586 3587 3588

  if (nj_col->view_field)
  {
monty@mysql.com's avatar
monty@mysql.com committed
3589
    Item *item;
3590 3591
    if (register_tree_change)
      arena= thd->activate_stmt_arena_if_needed(&backup);
3592 3593 3594 3595
    /*
      create_item() may, or may not create a new Item, depending on the
      column reference. See create_view_field() for details.
    */
monty@mysql.com's avatar
monty@mysql.com committed
3596
    item= nj_col->create_item(thd);
3597 3598 3599
    if (register_tree_change && arena)
      thd->restore_active_arena(arena, &backup);

3600 3601 3602 3603
    if (!item)
      DBUG_RETURN(NULL);
    DBUG_ASSERT(nj_col->table_field == NULL);
    if (nj_col->table_ref->schema_table_reformed)
3604
    {
3605 3606 3607 3608 3609 3610
      /*
        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);
3611
    }
3612 3613 3614 3615 3616 3617 3618 3619 3620 3621
    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);
3622
    DBUG_ASSERT(nj_col->table_ref->table == nj_col->table_field->table);
3623 3624 3625 3626 3627 3628 3629
    found_field= nj_col->table_field;
    update_field_dependencies(thd, found_field, nj_col->table_ref->table);
  }

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

3632

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3633
/*
3634
  Find field by name in a base table or a view with temp table algorithm.
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3635 3636

  SYNOPSIS
3637
    find_field_in_table()
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3638
    thd				thread handler
3639
    table			table where to search for the field
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3640 3641 3642
    name			name of field
    length			length of name
    allow_rowid			do allow finding of "_rowid" field?
3643 3644
    cached_field_index_ptr	cached position in field list (used to speedup
                                lookup for fields in prepared tables)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3645 3646

  RETURN
3647 3648
    0	field is not found
    #	pointer to field
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3649 3650
*/

3651 3652
Field *
find_field_in_table(THD *thd, TABLE *table, const char *name, uint length,
3653
                    bool allow_rowid, uint *cached_field_index_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3654
{
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3655 3656
  Field **field_ptr, *field;
  uint cached_field_index= *cached_field_index_ptr;
3657 3658
  DBUG_ENTER("find_field_in_table");
  DBUG_PRINT("enter", ("table: '%s', field name: '%s'", table->alias, name));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3659 3660

  /* We assume here that table->field < NO_CACHED_FIELD_INDEX = UINT_MAX */
3661
  if (cached_field_index < table->s->fields &&
3662
      !my_strcasecmp(system_charset_info,
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3663 3664
                     table->field[cached_field_index]->field_name, name))
    field_ptr= table->field + cached_field_index;
3665
  else if (table->s->name_hash.records)
3666
  {
3667 3668
    field_ptr= (Field**) hash_search(&table->s->name_hash, (byte*) name,
                                     length);
3669 3670 3671 3672 3673 3674 3675 3676 3677
    if (field_ptr)
    {
      /*
        field_ptr points to field in TABLE_SHARE. Convert it to the matching
        field in table
      */
      field_ptr= (table->field + (field_ptr - table->s->field));
    }
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3678 3679 3680
  else
  {
    if (!(field_ptr= table->field))
3681
      DBUG_RETURN((Field *)0);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3682 3683 3684 3685 3686 3687
    for (; *field_ptr; ++field_ptr)
      if (!my_strcasecmp(system_charset_info, (*field_ptr)->field_name, name))
        break;
  }

  if (field_ptr && *field_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3688
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3689 3690
    *cached_field_index_ptr= field_ptr - table->field;
    field= *field_ptr;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3691 3692 3693
  }
  else
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3694 3695
    if (!allow_rowid ||
        my_strcasecmp(system_charset_info, name, "_rowid") ||
3696
        table->s->rowid_field_offset == 0)
3697
      DBUG_RETURN((Field*) 0);
3698
    field= table->field[table->s->rowid_field_offset-1];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3699 3700
  }

3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714
  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
3715
    length		   [in]  field length of name
3716 3717
    item_name              [in]  name of item if it will be created (VIEW)
    db_name                [in]  optional database name that qualifies the
3718
    table_name             [in]  optional table name that qualifies the field
3719 3720
    ref		       [in/out] if 'name' is resolved to a view field, ref
                                 is set to point to the found view field
3721
    check_privileges       [in]  check privileges
3722 3723 3724 3725 3726 3727 3728 3729 3730
    allow_rowid		   [in]  do allow finding of "_rowid" field?
    cached_field_index_ptr [in]  cached position in field list (used to
                                 speedup lookup for fields in prepared tables)
    register_tree_change   [in]  TRUE if ref is not stack variable and we
                                 need register changes in item tree
    actual_table           [out] the original table reference where the field
                                 belongs - differs from 'table_list' only for
                                 NATURAL_USING joins.

timour@mysql.com's avatar
timour@mysql.com committed
3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742
  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.

3743 3744 3745 3746 3747 3748 3749 3750
  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,
3751 3752 3753
                        const char *name, uint length,
                        const char *item_name, const char *db_name,
                        const char *table_name, Item **ref,
3754 3755
                        bool check_privileges, bool allow_rowid,
                        uint *cached_field_index_ptr,
3756 3757 3758 3759 3760 3761 3762 3763 3764 3765
                        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
timour@mysql.com's avatar
timour@mysql.com committed
3766 3767
    are the same as the table reference we are going to search for the field.

3768 3769 3770 3771
    Exclude from the test below nested joins because the columns in a
    nested join generally originate from different tables. Nested joins
    also have no table name, except when a nested join is a merge view
    or an information schema table.
timour@mysql.com's avatar
timour@mysql.com committed
3772 3773 3774 3775 3776 3777

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

3778 3779
    TODO: Ensure that table_name, db_name and tables->db always points to
          something !
3780
  */
3781 3782
  if (/* Exclude nested joins. */
      (!table_list->nested_join ||
timour@mysql.com's avatar
timour@mysql.com committed
3783 3784 3785 3786 3787 3788
       /* Include merge views and information schema tables. */
       table_list->field_translation) &&
      /*
        Test if the field qualifiers match the table reference we plan
        to search.
      */
3789 3790
      table_name && table_name[0] &&
      (my_strcasecmp(table_alias_charset, table_list->alias, table_name) ||
3791 3792 3793 3794
       (db_name && db_name[0] && table_list->db && table_list->db[0] &&
        strcmp(db_name, table_list->db))))
    DBUG_RETURN(0);

3795
  *actual_table= NULL;
timour@mysql.com's avatar
timour@mysql.com committed
3796

3797 3798
  if (table_list->field_translation)
  {
timour@mysql.com's avatar
timour@mysql.com committed
3799
    /* 'table_list' is a view or an information schema table. */
3800
    if ((fld= find_field_in_view(thd, table_list, name, length, item_name, ref,
3801
                                 register_tree_change)))
3802 3803
      *actual_table= table_list;
  }
3804
  else if (!table_list->nested_join)
3805
  {
3806 3807
    /* 'table_list' is a stored table. */
    DBUG_ASSERT(table_list->table);
timour@mysql.com's avatar
timour@mysql.com committed
3808
    if ((fld= find_field_in_table(thd, table_list->table, name, length,
3809 3810
                                  allow_rowid,
                                  cached_field_index_ptr)))
timour@mysql.com's avatar
timour@mysql.com committed
3811 3812 3813
      *actual_table= table_list;
  }
  else
3814
  {
timour@mysql.com's avatar
timour@mysql.com committed
3815
    /*
timour@mysql.com's avatar
timour@mysql.com committed
3816 3817 3818 3819 3820
      'table_list' is a NATURAL/USING join, or an operand of such join that
      is a nested join itself.

      If the field name we search for is qualified, then search for the field
      in the table references used by NATURAL/USING the join.
timour@mysql.com's avatar
timour@mysql.com committed
3821
    */
3822 3823 3824 3825 3826 3827
    if (table_name && table_name[0])
    {
      List_iterator<TABLE_LIST> it(table_list->nested_join->join_list);
      TABLE_LIST *table;
      while ((table= it++))
      {
3828 3829
        if ((fld= find_field_in_table_ref(thd, table, name, length, item_name,
                                          db_name, table_name, ref,
3830 3831
                                          check_privileges, allow_rowid,
                                          cached_field_index_ptr,
3832 3833 3834 3835 3836 3837 3838
                                          register_tree_change, actual_table)))
          DBUG_RETURN(fld);
      }
      DBUG_RETURN(0);
    }
    /*
      Non-qualified field, search directly in the result columns of the
timour@mysql.com's avatar
timour@mysql.com committed
3839 3840 3841
      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.
3842 3843
    */
    fld= find_field_in_natural_join(thd, table_list, name, length, ref,
3844
                                    register_tree_change, actual_table);
3845
  }
3846

3847 3848 3849 3850 3851 3852 3853
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  /* Check if there are sufficient access rights to the found field. */
  if (fld && check_privileges &&
      check_column_grant_in_table_ref(thd, *actual_table, name, length))
    fld= WRONG_GRANT;
#endif

3854
  DBUG_RETURN(fld);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3855 3856
}

3857

3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893
/*
  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)
    field_ptr= (Field**)hash_search(&table->s->name_hash,(byte*) name,
                                    strlen(name));
  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;
}


3894 3895 3896 3897 3898
/*
  Find field in table list.

  SYNOPSIS
    find_field_in_tables()
3899 3900 3901 3902 3903 3904
    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
3905
                          point to the found view field
3906
    report_error	  Degree of error reporting:
3907 3908
                          - IGNORE_ERRORS then do not report any error
                          - IGNORE_EXCEPT_NON_UNIQUE report only non-unique
3909
                            fields, suppress all other errors
3910 3911 3912 3913
                          - REPORT_EXCEPT_NON_UNIQUE report all other errors
                            except when non-unique fields were found
                          - REPORT_ALL_ERRORS
    check_privileges      need to check privileges
3914 3915
    register_tree_change  TRUE if ref is not a stack variable and we
                          to need register changes in item tree
3916 3917

  RETURN VALUES
3918 3919 3920
    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.
3921 3922 3923 3924 3925
    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
3926
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3927 3928

Field *
3929 3930
find_field_in_tables(THD *thd, Item_ident *item,
                     TABLE_LIST *first_table, TABLE_LIST *last_table,
3931
		     Item **ref, find_item_error_report_type report_error,
3932
                     bool check_privileges, bool register_tree_change)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3933 3934
{
  Field *found=0;
3935 3936 3937
  const char *db= item->db_name;
  const char *table_name= item->table_name;
  const char *name= item->field_name;
3938
  uint length=(uint) strlen(name);
3939
  char name_buff[NAME_LEN+1];
3940 3941
  TABLE_LIST *cur_table= first_table;
  TABLE_LIST *actual_table;
3942 3943 3944 3945 3946 3947 3948 3949 3950
  bool allow_rowid;

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

  allow_rowid= table_name || (cur_table && !cur_table->next_local);
monty@mysql.com's avatar
monty@mysql.com committed
3951

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3952 3953 3954
  if (item->cached_table)
  {
    /*
3955 3956
      This shortcut is used by prepared statements. We assume that
      TABLE_LIST *first_table is not changed during query execution (which
3957
      is true for all queries except RENAME but luckily RENAME doesn't
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3958
      use fields...) so we can rely on reusing pointer to its member.
timour@mysql.com's avatar
timour@mysql.com committed
3959
      With this optimization we also miss case when addition of one more
3960
      field makes some prepared query ambiguous and so erroneous, but we
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3961 3962
      accept this trade off.
    */
3963 3964 3965 3966 3967 3968 3969 3970
    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,
3971
                                 TRUE, &(item->cached_field_index));
3972
    else
3973
      found= find_field_in_table_ref(thd, table_ref, name, length, item->name,
3974 3975
                                     NULL, NULL, ref, check_privileges,
                                     TRUE, &(item->cached_field_index),
3976 3977
                                     register_tree_change,
                                     &actual_table);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3978 3979 3980
    if (found)
    {
      if (found == WRONG_GRANT)
3981
	return (Field*) 0;
3982 3983
      {
        SELECT_LEX *current_sel= thd->lex->current_select;
3984
        SELECT_LEX *last_select= table_ref->select_lex;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3985 3986
        /*
          If the field was an outer referencee, mark all selects using this
3987
          sub query as dependent on the outer query
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3988
        */
3989
        if (current_sel != last_select)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3990
          mark_select_range_as_dependent(thd, last_select, current_sel,
3991 3992
                                         found, *ref, item);
      }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3993 3994 3995 3996
      return found;
    }
  }

3997 3998 3999
  if (db && lower_case_table_names)
  {
    /*
timour@mysql.com's avatar
timour@mysql.com committed
4000
      convert database to lower case for comparison.
4001 4002 4003 4004
      We can't do this in Item_field as this would change the
      'name' of the item which may be used in the select list
    */
    strmake(name_buff, db, sizeof(name_buff)-1);
monty@mysql.com's avatar
monty@mysql.com committed
4005
    my_casedn_str(files_charset_info, name_buff);
4006 4007
    db= name_buff;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4008

4009 4010 4011 4012 4013
  if (last_table)
    last_table= last_table->next_name_resolution_table;

  for (; cur_table != last_table ;
       cur_table= cur_table->next_name_resolution_table)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4014
  {
4015 4016
    Field *cur_field= find_field_in_table_ref(thd, cur_table, name, length,
                                              item->name, db, table_name, ref,
4017
                                              check_privileges, allow_rowid,
4018 4019 4020 4021
                                              &(item->cached_field_index),
                                              register_tree_change,
                                              &actual_table);
    if (cur_field)
4022
    {
4023
      if (cur_field == WRONG_GRANT)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4024
	return (Field*) 0;
4025 4026 4027 4028 4029 4030 4031 4032

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

4033 4034 4035 4036 4037
      DBUG_ASSERT(thd->where);
      /*
        If we found a fully qualified field we return it directly as it can't
        have duplicates.
       */
4038
      if (db)
4039 4040
        return cur_field;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4041 4042
      if (found)
      {
4043 4044
        if (report_error == REPORT_ALL_ERRORS ||
            report_error == IGNORE_EXCEPT_NON_UNIQUE)
4045
          my_error(ER_NON_UNIQ_ERROR, MYF(0),
4046
                   table_name ? item->full_name() : name, thd->where);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4047 4048
	return (Field*) 0;
      }
4049
      found= cur_field;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4050 4051
    }
  }
4052

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4053 4054
  if (found)
    return found;
4055 4056 4057 4058 4059 4060 4061 4062

  /*
    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.
  */
4063
  if (table_name && (cur_table == first_table) &&
4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074
      (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);
  }
4075
  else
4076
  {
4077 4078 4079 4080 4081
    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;
4082
  }
4083
  return found;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4084 4085
}

4086 4087 4088

/*
  Find Item in list of items (find_field_in_tables analog)
4089 4090 4091 4092

  TODO
    is it better return only counter?

4093 4094
  SYNOPSIS
    find_item_in_list()
4095 4096 4097
    find			Item to find
    items			List of items
    counter			To return number of found item
4098
    report_error
4099 4100 4101 4102 4103
      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
4104 4105 4106 4107
    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.

4108
  RETURN VALUES
4109 4110 4111 4112 4113
    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
4114
                        found field
4115 4116
*/

4117
/* Special Item pointer to serve as a return value from find_item_in_list(). */
4118
Item **not_found_item= (Item**) 0x1;
4119 4120


bk@work.mysql.com's avatar
bk@work.mysql.com committed
4121
Item **
4122
find_item_in_list(Item *find, List<Item> &items, uint *counter,
4123
                  find_item_error_report_type report_error, bool *unaliased)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4124 4125
{
  List_iterator<Item> li(items);
4126
  Item **found=0, **found_unaliased= 0, *item;
4127
  const char *db_name=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4128 4129
  const char *field_name=0;
  const char *table_name=0;
4130 4131
  bool found_unaliased_non_uniq= 0;
  uint unaliased_counter;
4132

4133 4134
  LINT_INIT(unaliased_counter);                 // Dependent on found_unaliased

4135 4136
  *unaliased= FALSE;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4137 4138 4139 4140
  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;
4141
    db_name=    ((Item_ident*) find)->db_name;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4142 4143
  }

4144
  for (uint i= 0; (item=li++); i++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4145
  {
4146
    if (field_name && item->real_item()->type() == Item::FIELD_ITEM)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4147
    {
4148
      Item_ident *item_field= (Item_ident*) item;
4149

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4150 4151 4152 4153 4154 4155
      /*
	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
      */ 
4156 4157 4158 4159
      if (!item_field->name)
        continue;

      if (table_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4160
      {
4161 4162 4163
        /*
          If table name is specified we should find field 'field_name' in
          table 'table_name'. According to SQL-standard we should ignore
4164 4165 4166 4167 4168
          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.
4169

4170
          We use strcmp for table names and database names as these may be
4171 4172
          case sensitive. In cases where they are not case sensitive, they
          are always in lower case.
4173 4174

	  item_field->field_name and item_field->table_name can be 0x0 if
4175
	  item is not fix_field()'ed yet.
4176
        */
4177 4178
        if (item_field->field_name && item_field->table_name &&
	    !my_strcasecmp(system_charset_info, item_field->field_name,
4179 4180 4181 4182 4183
                           field_name) &&
            !strcmp(item_field->table_name, table_name) &&
            (!db_name || (item_field->db_name &&
                          !strcmp(item_field->db_name, db_name))))
        {
4184
          if (found_unaliased)
4185
          {
4186 4187 4188 4189 4190 4191 4192
            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.
            */
4193
            if (report_error != IGNORE_ERRORS)
4194 4195
              my_error(ER_NON_UNIQ_ERROR, MYF(0),
                       find->full_name(), current_thd->where);
4196 4197
            return (Item**) 0;
          }
4198 4199
          found_unaliased= li.ref();
          unaliased_counter= i;
4200 4201
          if (db_name)
            break;                              // Perfect match
4202 4203 4204
        }
      }
      else if (!my_strcasecmp(system_charset_info, item_field->name,
4205
                              field_name))
4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218
      {
        /*
          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)
4219 4220
            my_error(ER_NON_UNIQ_ERROR, MYF(0),
                     find->full_name(), current_thd->where);
4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245
          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;
        }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4246 4247
      }
    }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4248
    else if (!table_name && (find->eq(item,0) ||
4249
			     find->name && item->name &&
4250 4251
			     !my_strcasecmp(system_charset_info, 
					    item->name,find->name)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4252
    {
4253 4254
      found= li.ref();
      *counter= i;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4255 4256 4257
      break;
    }
  }
4258 4259 4260 4261 4262
  if (!found)
  {
    if (found_unaliased_non_uniq)
    {
      if (report_error != IGNORE_ERRORS)
4263 4264
        my_error(ER_NON_UNIQ_ERROR, MYF(0),
                 find->full_name(), current_thd->where);
4265 4266 4267 4268 4269 4270
      return (Item **) 0;
    }
    if (found_unaliased)
    {
      found= found_unaliased;
      *counter= unaliased_counter;
4271
      *unaliased= TRUE;
4272 4273
    }
  }
4274 4275
  if (found)
    return found;
4276
  if (report_error != REPORT_EXCEPT_NOT_FOUND)
4277 4278
  {
    if (report_error == REPORT_ALL_ERRORS)
4279 4280
      my_error(ER_BAD_FIELD_ERROR, MYF(0),
               find->full_name(), current_thd->where);
4281 4282 4283 4284
    return (Item **) 0;
  }
  else
    return (Item **) not_found_item;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4285 4286
}

4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314

/*
  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;
4315
    if (!my_strcasecmp(system_charset_info, find, curr_str->ptr()))
4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336
      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
4337 4338
    FALSE  if all OK
    TRUE   otherwise
4339 4340 4341 4342 4343 4344
*/

static bool
set_new_item_local_context(THD *thd, Item_ident *item, TABLE_LIST *table_ref)
{
  Name_resolution_context *context;
4345
  if (!(context= new (thd->mem_root) Name_resolution_context))
4346 4347
    return TRUE;
  context->init();
4348 4349
  context->first_name_resolution_table=
    context->last_name_resolution_table= table_ref;
4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381
  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
4382 4383
    TRUE   error when some common column is non-unique, or out of memory
    FALSE  OK
4384 4385 4386 4387 4388 4389 4390 4391
*/

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;
4392
  const char *field_name_1;
4393
  Query_arena *arena, backup;
4394
  bool add_columns= TRUE;
4395 4396 4397
  bool result= TRUE;

  DBUG_ENTER("mark_common_columns");
4398
  DBUG_PRINT("info", ("operand_1: %s  operand_2: %s",
4399 4400
                      table_ref_1->alias, table_ref_2->alias));

4401
  *found_using_fields= 0;
konstantin@mysql.com's avatar
konstantin@mysql.com committed
4402
  arena= thd->activate_stmt_arena_if_needed(&backup);
4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423

  /*
    TABLE_LIST::join_columns could be allocated by the previous call to
    store_natural_using_join_columns() for the lower level of nested tables.
  */
  if (!table_ref_1->join_columns)
  {
    if (!(table_ref_1->join_columns= new List<Natural_join_column>))
      goto err;
    table_ref_1->is_join_columns_complete= FALSE;
  }
  if (!table_ref_2->join_columns)
  {
    if (!(table_ref_2->join_columns= new List<Natural_join_column>))
      goto err;
    table_ref_2->is_join_columns_complete= FALSE;
  }

  for (it_1.set(table_ref_1); !it_1.end_of_fields(); it_1.next())
  {
    bool is_created_1;
4424
    bool found= FALSE;
4425
    if (!(nj_col_1= it_1.get_or_create_column_ref(&is_created_1)))
4426 4427 4428 4429 4430 4431 4432
      goto err;
    field_name_1= nj_col_1->name();

    /* If nj_col_1 was just created add it to the list of join columns. */
    if (is_created_1)
      table_ref_1->join_columns->push_back(nj_col_1);

4433 4434 4435 4436 4437 4438 4439
    /*
      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.
    */
4440 4441 4442 4443 4444
    nj_col_2= NULL;
    for (it_2.set(table_ref_2); !it_2.end_of_fields(); it_2.next())
    {
      bool is_created_2;
      Natural_join_column *cur_nj_col_2;
4445
      const char *cur_field_name_2;
4446
      if (!(cur_nj_col_2= it_2.get_or_create_column_ref(&is_created_2)))
4447
        goto err;
4448
      cur_field_name_2= cur_nj_col_2->name();
4449 4450 4451 4452 4453

      /* If nj_col_1 was just created add it to the list of join columns. */
      if (add_columns && is_created_2)
        table_ref_2->join_columns->push_back(cur_nj_col_2);

timour@mysql.com's avatar
timour@mysql.com committed
4454 4455 4456 4457 4458 4459 4460
      /*
        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).
      */
4461 4462
      if (!my_strcasecmp(system_charset_info, field_name_1, cur_field_name_2))
      {
timour@mysql.com's avatar
timour@mysql.com committed
4463
        if (found || cur_nj_col_2->is_common)
4464 4465 4466 4467 4468 4469 4470 4471
        {
          my_error(ER_NON_UNIQ_ERROR, MYF(0), field_name_1, thd->where);
          goto err;
        }
        nj_col_2= cur_nj_col_2;
        found= TRUE;
      }
    }
4472
    /* Force it_2.set() to use table_ref_2->join_columns. */
4473 4474 4475
    table_ref_2->is_join_columns_complete= TRUE;
    add_columns= FALSE;
    if (!found)
4476
      continue;                                 // No matching field
4477 4478 4479 4480 4481 4482 4483 4484

    /*
      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 ||
4485
          test_if_string_in_list(field_name_1, using_fields)))
4486 4487 4488 4489 4490 4491
    {
      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;
4492 4493 4494 4495 4496
      Item_func_eq *eq_cond;

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

4497
      /*
4498
        The following assert checks that the two created items are of
4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522
        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.
      */
4523 4524
      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))
4525 4526
        goto err;

4527 4528
      if (!(eq_cond= new Item_func_eq(item_ident_1, item_ident_2)))
        goto err;                               /* Out of memory. */
4529 4530 4531 4532 4533 4534

      /*
        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.
       */
4535 4536 4537
      add_join_on((table_ref_1->outer_join & JOIN_TYPE_RIGHT ?
                   table_ref_1 : table_ref_2),
                  eq_cond);
4538 4539 4540 4541 4542

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

      if (field_1)
      {
4543
        TABLE *table_1= nj_col_1->table_ref->table;
4544 4545
        /* Mark field_1 used for table cache. */
        field_1->query_id= thd->query_id;
4546 4547
        table_1->file->ha_set_bit_in_read_set(field_1->fieldnr);
        table_1->used_keys.intersect(field_1->part_of_key);
4548 4549 4550
      }
      if (field_2)
      {
4551
        TABLE *table_2= nj_col_2->table_ref->table;
4552 4553
        /* Mark field_2 used for table cache. */
        field_2->query_id= thd->query_id;
4554
        table_2->file->ha_set_bit_in_read_set(field_2->fieldnr);
4555
        table_2->used_keys.intersect(field_2->part_of_key);
4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574
      }

      if (using_fields != NULL)
        ++(*found_using_fields);
    }
  }
  table_ref_1->is_join_columns_complete= TRUE;

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

err:
  if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
4575
    thd->restore_active_arena(arena, &backup);
4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611
  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
4612 4613
    TRUE    error: Some common column is ambiguous
    FALSE   OK
4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627
*/

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;
  bool is_created;
  Query_arena *arena, backup;
  bool result= TRUE;
4628
  List<Natural_join_column> *non_join_columns;
4629 4630
  DBUG_ENTER("store_natural_using_join_columns");

4631 4632
  DBUG_ASSERT(!natural_using_join->join_columns);

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

4635 4636
  if (!(non_join_columns= new List<Natural_join_column>) ||
      !(natural_using_join->join_columns= new List<Natural_join_column>))
4637 4638 4639 4640 4641
    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())
  {
4642
    nj_col_1= it_1.get_natural_column_ref();
4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663
    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++))
    {
4664
      const char *using_field_name_ptr= using_field_name->c_ptr();
4665 4666 4667
      List_iterator_fast<Natural_join_column>
        it(*(natural_using_join->join_columns));
      Natural_join_column *common_field;
4668 4669

      for (;;)
4670
      {
4671 4672 4673 4674 4675 4676 4677
        /* 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;
        }
4678 4679
        if (!my_strcasecmp(system_charset_info,
                           common_field->name(), using_field_name_ptr))
4680
          break;                                // Found match
4681 4682 4683 4684 4685 4686 4687
      }
    }
  }

  /* 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())
  {
4688
    nj_col_2= it_2.get_natural_column_ref();
4689 4690 4691
    if (!nj_col_2->is_common)
      non_join_columns->push_back(nj_col_2);
    else
4692
    {
4693 4694
      /* Reset the common columns for the next call to mark_common_columns. */
      nj_col_2->is_common= FALSE;
4695
    }
4696 4697 4698 4699 4700 4701 4702 4703 4704 4705
  }

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

  result= FALSE;

err:
  if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
4706
    thd->restore_active_arena(arena, &backup);
4707 4708 4709
  DBUG_RETURN(result);
}

4710

4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736
/*
  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
4737 4738
    TRUE   Error
    FALSE  OK
4739 4740 4741 4742 4743 4744 4745
*/

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

4749
  DBUG_ENTER("store_top_level_join_columns");
4750

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

4753 4754 4755 4756 4757 4758
  /* 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;
4759

4760 4761
    while (cur_left_neighbor)
    {
4762
      TABLE_LIST *cur_table_ref= cur_left_neighbor;
4763
      cur_left_neighbor= nested_it++;
4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784
      /*
        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))
timour@mysql.com's avatar
timour@mysql.com committed
4785
        goto err;
4786
      cur_right_neighbor= cur_table_ref;
4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816
    }
  }

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

    /*
      The two join operands were interchanged in the parser, change the order
      back for 'mark_common_columns'.
    */
    if (table_ref_2->outer_join & JOIN_TYPE_RIGHT)
      swap_variables(TABLE_LIST*, table_ref_1, table_ref_2);
    if (mark_common_columns(thd, table_ref_1, table_ref_2,
                            using_fields, &found_using_fields))
timour@mysql.com's avatar
timour@mysql.com committed
4817
      goto err;
4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828

    /*
      Swap the join operands back, so that we pick the columns of the second
      one as the coalesced columns. In this way the coalesced columns are the
      same as of an equivalent LEFT JOIN.
    */
    if (table_ref_1->outer_join & JOIN_TYPE_RIGHT)
      swap_variables(TABLE_LIST*, table_ref_1, table_ref_2);
    if (store_natural_using_join_columns(thd, table_ref, table_ref_1,
                                         table_ref_2, using_fields,
                                         found_using_fields))
timour@mysql.com's avatar
timour@mysql.com committed
4829
      goto err;
4830 4831 4832 4833 4834 4835 4836 4837 4838

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

timour@mysql.com's avatar
timour@mysql.com committed
4839 4840 4841 4842 4843
    /* 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. */

4844 4845 4846
    /* Change this table reference to become a leaf for name resolution. */
    if (left_neighbor)
    {
4847
      TABLE_LIST *last_leaf_on_the_left;
4848 4849 4850 4851 4852
      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)
    {
4853
      TABLE_LIST *first_leaf_on_the_right;
4854 4855 4856 4857 4858 4859
      first_leaf_on_the_right= right_neighbor->first_leaf_for_name_resolution();
      table_ref->next_name_resolution_table= first_leaf_on_the_right;
    }
    else
      table_ref->next_name_resolution_table= NULL;
  }
timour@mysql.com's avatar
timour@mysql.com committed
4860 4861 4862 4863
  result= FALSE; /* All is OK. */

err:
  if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
4864
    thd->restore_active_arena(arena, &backup);
timour@mysql.com's avatar
timour@mysql.com committed
4865
  DBUG_RETURN(result);
4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889
}


/*
  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
4890 4891
    TRUE   Error
    FALSE  OK
4892
*/
4893 4894
static bool setup_natural_join_row_types(THD *thd,
                                         List<TABLE_LIST> *from_clause,
4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907
                                         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. */
4908
  TABLE_LIST *left_neighbor;
4909 4910 4911
  /* Table reference to the right of the current. */
  TABLE_LIST *right_neighbor= NULL;

4912 4913
  /* Note that tables in the list are in reversed order */
  for (left_neighbor= table_ref_it++; left_neighbor ; )
4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931
  {
    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
4932
    right_neighbor points to the left-most top-level table reference in the
4933 4934 4935 4936 4937 4938 4939 4940 4941 4942
    FROM clause.
  */
  DBUG_ASSERT(right_neighbor);
  context->first_name_resolution_table=
    right_neighbor->first_leaf_for_name_resolution();

  return FALSE;
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
4943
/****************************************************************************
4944
** Expand all '*' in given fields
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4945 4946
****************************************************************************/

4947 4948 4949
int setup_wild(THD *thd, TABLE_LIST *tables, List<Item> &fields,
	       List<Item> *sum_func_list,
	       uint wild_num)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4950
{
4951
  if (!wild_num)
4952
    return(0);
4953

4954
  Item *item;
4955
  List_iterator<Item> it(fields);
serg@serg.mylan's avatar
serg@serg.mylan committed
4956
  Query_arena *arena, backup;
4957
  DBUG_ENTER("setup_wild");
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4958 4959

  /*
4960 4961
    Don't use arena if we are not in prepared statements or stored procedures
    For PS/SP we have to use arena to remember the changes
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4962
  */
konstantin@mysql.com's avatar
konstantin@mysql.com committed
4963
  arena= thd->activate_stmt_arena_if_needed(&backup);
4964

monty@mysql.com's avatar
monty@mysql.com committed
4965
  while (wild_num && (item= it++))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4966
  {
4967 4968
    if (item->type() == Item::FIELD_ITEM &&
        ((Item_field*) item)->field_name &&
4969 4970
	((Item_field*) item)->field_name[0] == '*' &&
	!((Item_field*) item)->field)
4971
    {
4972
      uint elem= fields.elements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4973
      bool any_privileges= ((Item_field *) item)->any_privileges;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984
      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));
      }
4985 4986
      else if (insert_fields(thd, ((Item_field*) item)->context,
                             ((Item_field*) item)->db_name,
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4987
                             ((Item_field*) item)->table_name, &it,
4988
                             any_privileges))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4989 4990
      {
	if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
4991
	  thd->restore_active_arena(arena, &backup);
4992
	DBUG_RETURN(-1);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4993
      }
4994
      if (sum_func_list)
4995 4996 4997 4998 4999 5000 5001 5002
      {
	/*
	  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;
      }
5003
      wild_num--;
5004 5005
    }
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5006 5007 5008 5009 5010 5011 5012
  if (arena)
  {
    /* make * substituting permanent */
    SELECT_LEX *select_lex= thd->lex->current_select;
    select_lex->with_wild= 0;
    select_lex->item_list= fields;

konstantin@mysql.com's avatar
konstantin@mysql.com committed
5013
    thd->restore_active_arena(arena, &backup);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5014
  }
5015
  DBUG_RETURN(0);
5016 5017
}

5018 5019 5020 5021
/****************************************************************************
** Check that all given fields exists and fill struct with current data
****************************************************************************/

5022
bool setup_fields(THD *thd, Item **ref_pointer_array,
5023
                  List<Item> &fields, ulong set_query_id,
5024
                  List<Item> *sum_func_list, bool allow_sum_func)
5025 5026
{
  reg2 Item *item;
5027
  ulong save_set_query_id= thd->set_query_id;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5028
  nesting_map save_allow_sum_func= thd->lex->allow_sum_func;
5029 5030 5031 5032
  List_iterator<Item> it(fields);
  DBUG_ENTER("setup_fields");

  thd->set_query_id=set_query_id;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5033 5034
  if (allow_sum_func)
    thd->lex->allow_sum_func|= 1 << thd->lex->current_select->nest_level;
5035
  thd->where= THD::DEFAULT_WHERE;
5036

5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050
  /*
    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);

5051 5052
  Item **ref= ref_pointer_array;
  while ((item= it++))
5053
  {
5054
    if (!item->fixed && item->fix_fields(thd, it.ref()) ||
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5055
	(item= *(it.ref()))->check_cols(1))
5056
    {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5057
      thd->lex->allow_sum_func= save_allow_sum_func;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5058
      thd->set_query_id= save_set_query_id;
5059
      DBUG_RETURN(TRUE); /* purecov: inspected */
5060
    }
5061 5062
    if (ref)
      *(ref++)= item;
5063 5064
    if (item->with_sum_func && item->type() != Item::SUM_FUNC_ITEM &&
	sum_func_list)
5065
      item->split_sum_func(thd, ref_pointer_array, *sum_func_list);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5066
    thd->used_tables|= item->used_tables();
5067
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5068
  thd->lex->allow_sum_func= save_allow_sum_func;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5069
  thd->set_query_id= save_set_query_id;
5070
  DBUG_RETURN(test(thd->net.report_error));
5071
}
5072

5073

5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088
/*
  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)
  {
5089 5090 5091 5092 5093 5094
    if (table->merge_underlying_list)
    {
      DBUG_ASSERT(table->view &&
                  table->effective_algorithm == VIEW_ALGORITHM_MERGE);
      list= make_leaves_list(list, table->merge_underlying_list);
    }
5095 5096 5097 5098 5099 5100 5101 5102 5103
    else
    {
      *list= table;
      list= &table->next_leaf;
    }
  }
  return list;
}

5104
/*
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5105 5106 5107 5108
  prepare tables

  SYNOPSIS
    setup_tables()
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5109
    thd		  Thread handler
5110
    context       name resolution contest to setup table list there
5111 5112
    from_clause   Top-level list of table references in the FROM clause
    tables	  Table list (select_lex->table_list)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5113
    conds	  Condition of current SELECT (can be changed by VIEW)
5114
    leaves        List of join table leaves list (select_lex->leaf_tables)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5115 5116
    refresh       It is onle refresh for subquery
    select_insert It is SELECT ... INSERT command
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5117

monty@mysql.com's avatar
monty@mysql.com committed
5118 5119
  NOTE
    Check also that the 'used keys' and 'ignored keys' exists and set up the
5120 5121 5122 5123
    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.
5124

monty@mysql.com's avatar
monty@mysql.com committed
5125 5126
    This has to be called for all tables that are used by items, as otherwise
    table->map is not set and all Item_field will be regarded as const items.
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5127

monty@mysql.com's avatar
monty@mysql.com committed
5128
  RETURN
5129
    FALSE ok;  In this case *map will includes the chosen index
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5130
    TRUE  error
5131 5132
*/

5133
bool setup_tables(THD *thd, Name_resolution_context *context,
5134 5135
                  List<TABLE_LIST> *from_clause, TABLE_LIST *tables,
                  Item **conds, TABLE_LIST **leaves, bool select_insert)
5136
{
monty@mysql.com's avatar
monty@mysql.com committed
5137
  uint tablenr= 0;
5138
  DBUG_ENTER("setup_tables");
5139

5140
  context->table_list= context->first_name_resolution_table= tables;
5141

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5142 5143
  /*
    this is used for INSERT ... SELECT.
5144
    For select we setup tables except first (and its underlying tables)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5145 5146 5147 5148
  */
  TABLE_LIST *first_select_table= (select_insert ?
                                   tables->next_local:
                                   0);
5149 5150 5151
  if (!(*leaves))
    make_leaves_list(leaves, tables);

5152 5153
  TABLE_LIST *table_list;
  for (table_list= *leaves;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5154
       table_list;
5155
       table_list= table_list->next_leaf, tablenr++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5156
  {
5157
    TABLE *table= table_list->table;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5158
    if (first_select_table &&
5159
        table_list->top_table() == first_select_table)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5160 5161 5162 5163 5164
    {
      /* new counting for SELECT of INSERT ... SELECT command */
      first_select_table= 0;
      tablenr= 0;
    }
5165
    setup_table_map(table, table_list, tablenr);
5166
    table->used_keys= table->s->keys_for_keyread;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5167
    if (table_list->use_index)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5168
    {
5169 5170 5171
      key_map map;
      get_key_map_from_key_list(&map, table, table_list->use_index);
      if (map.is_set_all())
5172
	DBUG_RETURN(1);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5173
      table->keys_in_use_for_query=map;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5174
    }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5175
    if (table_list->ignore_index)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5176
    {
5177 5178 5179
      key_map map;
      get_key_map_from_key_list(&map, table, table_list->ignore_index);
      if (map.is_set_all())
5180
	DBUG_RETURN(1);
5181
      table->keys_in_use_for_query.subtract(map);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5182
    }
5183
    table->used_keys.intersect(table->keys_in_use_for_query);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5184 5185 5186 5187
  }
  if (tablenr > MAX_TABLES)
  {
    my_error(ER_TOO_MANY_TABLES,MYF(0),MAX_TABLES);
5188
    DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5189
  }
5190
  for (table_list= tables;
5191 5192
       table_list;
       table_list= table_list->next_local)
5193
  {
5194
    if (table_list->merge_underlying_list)
5195
    {
5196 5197
      DBUG_ASSERT(table_list->view &&
                  table_list->effective_algorithm == VIEW_ALGORITHM_MERGE);
konstantin@mysql.com's avatar
konstantin@mysql.com committed
5198
      Query_arena *arena= thd->stmt_arena, backup;
5199 5200 5201 5202
      bool res;
      if (arena->is_conventional())
        arena= 0;                                   // For easier test
      else
konstantin@mysql.com's avatar
konstantin@mysql.com committed
5203
        thd->set_n_backup_active_arena(arena, &backup);
5204
      res= table_list->setup_underlying(thd);
5205
      if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
5206
        thd->restore_active_arena(arena, &backup);
5207 5208 5209
      if (res)
        DBUG_RETURN(1);
    }
5210
  }
5211 5212 5213 5214 5215

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

5216
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5217
}
5218

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

5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234
/*
   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,
5235
                               List<String> *index_list)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5236
{
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
5237
  List_iterator_fast<String> it(*index_list);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5238 5239
  String *name;
  uint pos;
5240 5241

  map->clear_all();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5242 5243
  while ((name=it++))
  {
5244 5245 5246
    if (table->s->keynames.type_names == 0 ||
        (pos= find_type(&table->s->keynames, name->ptr(),
                        name->length(), 1)) <=
5247
        0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5248
    {
monty@mysql.com's avatar
monty@mysql.com committed
5249
      my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), name->c_ptr(),
5250
	       table->s->table_name.str);
5251
      map->set_all();
5252
      return 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5253
    }
5254
    map->set_bit(pos-1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5255
  }
5256
  return 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5257 5258
}

5259

5260 5261 5262 5263 5264 5265
/*
  Drops in all fields instead of current '*' field

  SYNOPSIS
    insert_fields()
    thd			Thread handler
5266
    context             Context for name resolution
5267 5268 5269 5270 5271 5272 5273
    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
5274
    0	ok     'it' is updated to point at last inserted
monty@mysql.com's avatar
monty@mysql.com committed
5275
    1	error.  Error message is generated but not sent to client
5276
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5277

sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
5278
bool
5279
insert_fields(THD *thd, Name_resolution_context *context, const char *db_name,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5280
	      const char *table_name, List_iterator<Item> *it,
5281
              bool any_privileges)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5282
{
5283 5284
  Field_iterator_table_ref field_iterator;
  bool found;
monty@mysql.com's avatar
monty@mysql.com committed
5285
  char name_buff[NAME_LEN+1];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5286
  DBUG_ENTER("insert_fields");
konstantin@mysql.com's avatar
konstantin@mysql.com committed
5287
  DBUG_PRINT("arena", ("stmt arena: 0x%lx", (ulong)thd->stmt_arena));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5288

5289 5290
  if (db_name && lower_case_table_names)
  {
monty@mysql.com's avatar
monty@mysql.com committed
5291 5292 5293 5294 5295
    /*
      convert database to lower case for comparison
      We can't do this in Item_field as this would change the
      'name' of the item which may be used in the select list
    */
serg@serg.mylan's avatar
serg@serg.mylan committed
5296
    strmake(name_buff, db_name, sizeof(name_buff)-1);
monty@mysql.com's avatar
monty@mysql.com committed
5297
    my_casedn_str(files_charset_info, name_buff);
monty@mysql.com's avatar
monty@mysql.com committed
5298
    db_name= name_buff;
5299 5300
  }

5301
  found= FALSE;
5302 5303 5304 5305 5306 5307 5308 5309

  /*
    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);
5310
       tables;
5311 5312 5313
       tables= (table_name ? tables->next_local :
                tables->next_name_resolution_table)
       )
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5314
  {
5315 5316 5317
    Field *field;
    TABLE *table= tables->table;

5318 5319
    DBUG_ASSERT(tables->is_leaf_for_name_resolution());

5320 5321 5322 5323
    if (table_name && my_strcasecmp(table_alias_charset, table_name,
                                    tables->alias) ||
        (db_name && strcmp(tables->db,db_name)))
      continue;
5324

hf@deer.(none)'s avatar
hf@deer.(none) committed
5325
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5326 5327 5328 5329 5330 5331 5332
    /* 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(),
5333 5334
                                  field_iterator.db_name(),
                                  field_iterator.table_name(),
5335 5336 5337
                                  &field_iterator))
        DBUG_RETURN(TRUE);
    }
hf@deer.(none)'s avatar
hf@deer.(none) committed
5338
#endif
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5339 5340


5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363
    /*
      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)
5364
      {
5365
        found= TRUE;
5366
        it->replace(item); /* Replace '*' with the first found item. */
5367
      }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5368
      else
5369 5370 5371 5372 5373 5374 5375
        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,
5376 5377 5378
        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.
5379 5380
      */
      if (any_privileges)
5381
      {
5382 5383 5384 5385
        DBUG_ASSERT(tables->field_translation == NULL && table ||
                    tables->is_natural_join);
        DBUG_ASSERT(item->type() == Item::FIELD_ITEM);
        Item_field *fld= (Item_field*) item;
5386
        const char *field_table_name= field_iterator.table_name();
5387

5388 5389 5390 5391
        if (!tables->schema_table && 
            !(fld->have_privileges=
              (get_column_grant(thd, field_iterator.grant(),
                                field_iterator.db_name(),
5392
                                field_table_name, fld->field_name) &
5393 5394 5395
               VIEW_ANY_ACL)))
        {
          my_error(ER_COLUMNACCESS_DENIED_ERROR, MYF(0), "ANY",
5396 5397
                   thd->security_ctx->priv_user,
                   thd->security_ctx->host_or_ip,
5398
                   fld->field_name, field_table_name);
5399 5400
          DBUG_RETURN(TRUE);
        }
5401
      }
5402
#endif
5403

5404
      if ((field= field_iterator.field()))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5405
      {
5406 5407 5408 5409 5410 5411 5412
        /*
          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;
5413
        field->table->file->ha_set_bit_in_read_set(field->fieldnr);
5414 5415 5416 5417 5418

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

        if (tables->is_natural_join)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5419
        {
5420 5421 5422
          bool is_created;
          TABLE *field_table;
          /*
5423
            In this case we are sure that the column ref will not be created
5424
            because it was already created and stored with the natural join.
5425
          */
5426
          Natural_join_column *nj_col;
5427
          if (!(nj_col= field_iterator.get_or_create_column_ref(&is_created)))
5428 5429 5430 5431
            DBUG_RETURN(TRUE);
          DBUG_ASSERT(nj_col->table_field && !is_created);
          field_table= nj_col->table_ref->table;
          if (field_table)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5432
          {
5433 5434 5435
            thd->used_tables|= field_table->map;
            field_table->used_keys.intersect(field->part_of_key);
            field_table->used_fields++;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5436
          }
5437
        }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5438
      }
5439 5440 5441 5442 5443 5444
      else
      {
        thd->used_tables|= item->used_tables();
        item->walk(&Item::reset_query_id_processor,
                   (byte *)(&thd->query_id));
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5445
    }
5446 5447 5448 5449 5450 5451 5452
    /*
      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)
5453
    {
5454
      table->used_fields= table->s->fields;
5455 5456
      table->file->ha_set_all_bits_in_read_set();
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5457
  }
5458
  if (found)
5459
    DBUG_RETURN(FALSE);
5460

5461
  /*
5462 5463 5464
    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.
5465
  */
5466
  if (!table_name)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5467
    my_message(ER_NO_TABLES_USED, ER(ER_NO_TABLES_USED), MYF(0));
5468 5469
  else
    my_error(ER_BAD_TABLE_ERROR, MYF(0), table_name);
5470 5471

  DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5472 5473 5474 5475
}


/*
5476
  Fix all conditions and outer join expressions.
5477 5478 5479 5480

  SYNOPSIS
    setup_conds()
    thd     thread handler
5481 5482 5483 5484 5485 5486 5487 5488 5489 5490
    tables  list of tables for name resolving (select_lex->table_list)
    leaves  list of leaves of join table tree (select_lex->leaf_tables)
    conds   WHERE clause

  DESCRIPTION
    TODO

  RETURN
    TRUE  if some error occured (e.g. out of memory)
    FALSE if all is OK
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5491 5492
*/

5493 5494
int setup_conds(THD *thd, TABLE_LIST *tables, TABLE_LIST *leaves,
                COND **conds)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5495
{
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5496
  SELECT_LEX *select_lex= thd->lex->current_select;
konstantin@mysql.com's avatar
konstantin@mysql.com committed
5497
  Query_arena *arena= thd->stmt_arena, backup;
pem@mysql.comhem.se's avatar
pem@mysql.comhem.se committed
5498
  TABLE_LIST *table= NULL;	// For HP compilers
5499 5500 5501 5502 5503 5504 5505 5506 5507 5508
  /*
    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();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5509
  DBUG_ENTER("setup_conds");
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5510

monty@mysql.com's avatar
monty@mysql.com committed
5511
  if (select_lex->conds_processed_with_permanent_arena ||
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5512
      arena->is_conventional())
monty@mysql.com's avatar
monty@mysql.com committed
5513 5514
    arena= 0;                                   // For easier test

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5515
  thd->set_query_id=1;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5516
  select_lex->cond_count= 0;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5517

5518 5519 5520 5521 5522 5523
  for (table= tables; table; table= table->next_local)
  {
    if (table->prepare_where(thd, conds, FALSE))
      goto err_no_arena;
  }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5524 5525 5526
  if (*conds)
  {
    thd->where="where clause";
5527
    if (!(*conds)->fixed && (*conds)->fix_fields(thd, conds) ||
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5528
	(*conds)->check_cols(1))
5529
      goto err_no_arena;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5530 5531
  }

5532 5533 5534 5535
  /*
    Apply fix_fields() to all ON clauses at all levels of nesting,
    including the ones inside view definitions.
  */
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
5536
  for (table= leaves; table; table= table->next_leaf)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5537
  {
5538 5539
    TABLE_LIST *embedded; /* The table at the current level of nesting. */
    TABLE_LIST *embedding= table; /* The parent nested table reference. */
5540
    do
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5541
    {
5542 5543
      embedded= embedding;
      if (embedded->on_expr)
5544
      {
5545 5546
        /* Make a join an a expression */
        thd->where="on clause";
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5547
        if (!embedded->on_expr->fixed &&
5548
            embedded->on_expr->fix_fields(thd, &embedded->on_expr) ||
5549
	    embedded->on_expr->check_cols(1))
5550
	  goto err_no_arena;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5551
        select_lex->cond_count++;
5552
      }
5553
      embedding= embedded->embedding;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5554
    }
5555 5556
    while (embedding &&
           embedding->nested_join->join_list.head() == embedded);
5557 5558 5559 5560

    /* process CHECK OPTION */
    if (it_is_update)
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5561
      TABLE_LIST *view= table->top_table();
5562 5563 5564 5565 5566 5567 5568
      if (view->effective_with_check)
      {
        if (view->prepare_check_option(thd))
          goto err_no_arena;
        thd->change_item_tree(&table->check_option, view->check_option);
      }
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5569
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5570

konstantin@mysql.com's avatar
konstantin@mysql.com committed
5571
  if (!thd->stmt_arena->is_conventional())
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5572 5573 5574 5575 5576 5577 5578 5579 5580 5581
  {
    /*
      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;
  }
5582
  DBUG_RETURN(test(thd->net.report_error));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5583

5584
err_no_arena:
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5585
  DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5586 5587 5588 5589 5590 5591 5592 5593
}


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

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609

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

5610
static bool
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5611 5612
fill_record(THD * thd, List<Item> &fields, List<Item> &values,
            bool ignore_errors)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5613
{
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
5614
  List_iterator_fast<Item> f(fields),v(values);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5615 5616 5617 5618 5619 5620 5621
  Item *value;
  Item_field *field;
  DBUG_ENTER("fill_record");

  while ((field=(Item_field*) f++))
  {
    value=v++;
5622 5623
    Field *rfield= field->field;
    TABLE *table= rfield->table;
5624
    if (rfield == table->next_number_field)
5625
      table->auto_increment_field_not_null= TRUE;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5626
    if ((value->save_in_field(rfield, 0) < 0) && !ignore_errors)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5627 5628 5629 5630
    {
      my_message(ER_UNKNOWN_ERROR, ER(ER_UNKNOWN_ERROR), MYF(0));
      DBUG_RETURN(TRUE);
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5631
  }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5632
  DBUG_RETURN(thd->net.report_error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5633 5634 5635
}


5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670
/*
  Fill fields in list with values from the list of items and invoke
  before triggers.

  SYNOPSIS
    fill_record_n_invoke_before_triggers()
      thd           thread context
      fields        Item_fields list to be filled
      values        values to fill with
      ignore_errors TRUE if we should ignore errors
      triggers      object holding list of triggers to be invoked
      event         event type for triggers to be invoked

  NOTE
    This function assumes that fields which values will be set and triggers
    to be invoked belong to the same table, and that TABLE::record[0] and
    record[1] buffers correspond to new and old versions of row respectively.

  RETURN
    FALSE   OK
    TRUE    error occured
*/

bool
fill_record_n_invoke_before_triggers(THD *thd, List<Item> &fields,
                                     List<Item> &values, bool ignore_errors,
                                     Table_triggers_list *triggers,
                                     enum trg_event_type event)
{
  return (fill_record(thd, fields, values, ignore_errors) ||
          triggers && triggers->process_triggers(thd, event,
                                                 TRG_ACTION_BEFORE, TRUE));
}


bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687
/*
  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)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5688
{
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
5689
  List_iterator_fast<Item> v(values);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5690 5691 5692 5693 5694 5695 5696
  Item *value;
  DBUG_ENTER("fill_record");

  Field *field;
  while ((field = *ptr++))
  {
    value=v++;
5697
    TABLE *table= field->table;
5698
    if (field == table->next_number_field)
5699
      table->auto_increment_field_not_null= TRUE;
5700
    if (value->save_in_field(field, 0) == -1)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5701
      DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5702
  }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5703
  DBUG_RETURN(thd->net.report_error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5704 5705 5706
}


5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741
/*
  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));
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
5742 5743
static void mysql_rm_tmp_tables(void)
{
5744 5745
  uint i, idx;
  char	filePath[FN_REFLEN], *tmpdir;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5746 5747 5748 5749
  MY_DIR *dirp;
  FILEINFO *file;
  DBUG_ENTER("mysql_rm_tmp_tables");

5750 5751 5752
  for (i=0; i<=mysql_tmpdir_list.max; i++)
  {
    tmpdir=mysql_tmpdir_list.list[i];
5753
    /* See if the directory exists */
5754 5755
    if (!(dirp = my_dir(tmpdir,MYF(MY_WME | MY_DONT_SORT))))
      continue;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5756

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

5759 5760 5761
    for (idx=0 ; idx < (uint) dirp->number_off_files ; idx++)
    {
      file=dirp->dir_entry+idx;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5762

5763 5764 5765 5766
      /* skiping . and .. */
      if (file->name[0] == '.' && (!file->name[1] ||
                                   (file->name[1] == '.' &&  !file->name[2])))
        continue;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5767

5768 5769
      if (!bcmp(file->name,tmp_file_prefix,tmp_file_prefix_length))
      {
5770 5771
        sprintf(filePath,"%s%s",tmpdir,file->name);
        VOID(my_delete(filePath,MYF(MY_WME)));
5772
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5773
    }
5774
    my_dirend(dirp);
5775
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5776 5777 5778 5779 5780 5781 5782 5783 5784 5785
  DBUG_VOID_RETURN;
}



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

/*
5786 5787 5788 5789 5790 5791 5792 5793 5794 5795
  Invalidate any cache entries that are for some DB

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

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

5798
void remove_db_from_cache(const char *db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5799 5800 5801 5802
{
  for (uint idx=0 ; idx < open_cache.records ; idx++)
  {
    TABLE *table=(TABLE*) hash_element(&open_cache,idx);
5803
    if (!strcmp(table->s->db.str, db))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5804
    {
5805
      table->s->version= 0L;			/* Free when thread is ready */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5806 5807 5808 5809
      if (!table->in_use)
	relink_unused(table);
    }
  }
5810
  while (unused_tables && !unused_tables->s->version)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5811 5812 5813 5814 5815
    VOID(hash_delete(&open_cache,(byte*) unused_tables));
}


/*
5816 5817 5818 5819 5820
  free all unused tables

  NOTE
    This is called by 'handle_manager' when one wants to periodicly flush
    all not used tables.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832
*/

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


/*
5833 5834 5835 5836 5837
  Mark all entries with the table as deleted to force an reopen of the table

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

monty@mysql.com's avatar
monty@mysql.com committed
5838 5839 5840
  PREREQUISITES
    Lock on LOCK_open()

5841 5842 5843 5844
  RETURN
    0  This thread now have exclusive access to this table and no other thread
       can access the table until close_thread_tables() is called.
    1  Table is in use by another thread
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5845 5846
*/

5847
bool remove_table_from_cache(THD *thd, const char *db, const char *table_name,
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5848
                             uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5849 5850 5851 5852
{
  char key[MAX_DBKEY_LENGTH];
  uint key_length;
  TABLE *table;
5853 5854
  TABLE_SHARE *share;
  bool result= 0, signalled= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5855 5856 5857
  DBUG_ENTER("remove_table_from_cache");

  key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
5858
  for (;;)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5859
  {
5860
    HASH_SEARCH_STATE state;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5861 5862
    result= signalled= 0;

5863 5864
    for (table= (TABLE*) hash_first(&open_cache, (byte*) key, key_length,
                                    &state);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5865
         table;
5866 5867
         table= (TABLE*) hash_next(&open_cache, (byte*) key, key_length,
                                   &state))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5868
    {
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5869
      THD *in_use;
5870
      table->s->version=0L;		/* Free when thread is ready */
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5871
      if (!(in_use=table->in_use))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5872
      {
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5873 5874
        DBUG_PRINT("info",("Table was not in use"));
        relink_unused(table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5875
      }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5876
      else if (in_use != thd)
5877
      {
5878
        DBUG_PRINT("info", ("Table was in use by other thread"));
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5879 5880 5881 5882 5883 5884 5885
        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)
        {
5886
	  in_use->killed= THD::KILL_CONNECTION;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905
	  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
5906
	    signalled|= mysql_lock_abort_for_thread(thd, thd_table);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5907
        }
5908
      }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5909
      else
5910 5911 5912
      {
        DBUG_PRINT("info", ("Table was in use by current thread. db_stat: %u",
                            table->db_stat));
5913
        result= result || (flags & RTFC_OWNED_BY_THD_FLAG);
5914
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5915
    }
5916
    while (unused_tables && !unused_tables->s->version)
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5917
      VOID(hash_delete(&open_cache,(byte*) unused_tables));
5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933

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

5934
    if (result && (flags & RTFC_WAIT_OTHER_THREAD_FLAG))
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5935
    {
5936
      if (!(flags & RTFC_CHECK_KILLED_FLAG) || !thd->killed)
5937
      {
monty@mysql.com's avatar
monty@mysql.com committed
5938
        dropping_tables++;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5939 5940 5941 5942
        if (likely(signalled))
          (void) pthread_cond_wait(&COND_refresh, &LOCK_open);
        else
        {
monty@mysql.com's avatar
monty@mysql.com committed
5943
          struct timespec abstime;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5944 5945 5946 5947 5948 5949 5950 5951 5952 5953
          /*
            It can happen that another thread has opened the
            table but has not yet locked any table at all. Since
            it can be locked waiting for a table that our thread
            has done LOCK TABLE x WRITE on previously, we need to
            ensure that the thread actually hears our signal
            before we go to sleep. Thus we wait for a short time
            and then we retry another loop in the
            remove_table_from_cache routine.
          */
monty@mysql.com's avatar
monty@mysql.com committed
5954 5955
          set_timespec(abstime, 10);
          pthread_cond_timedwait(&COND_refresh, &LOCK_open, &abstime);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5956
        }
monty@mysql.com's avatar
monty@mysql.com committed
5957 5958
        dropping_tables--;
        continue;
5959
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5960
    }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5961
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5962 5963 5964 5965
  }
  DBUG_RETURN(result);
}

5966

5967
int setup_ftfuncs(SELECT_LEX *select_lex)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5968
{
5969 5970
  List_iterator<Item_func_match> li(*(select_lex->ftfunc_list)),
                                 lj(*(select_lex->ftfunc_list));
5971
  Item_func_match *ftf, *ftf2;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5972 5973

  while ((ftf=li++))
5974
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5975 5976
    if (ftf->fix_index())
      return 1;
5977 5978
    lj.rewind();
    while ((ftf2=lj++) != ftf)
5979
    {
5980
      if (ftf->eq(ftf2,1) && !ftf2->master)
5981 5982 5983
        ftf2->master=ftf;
    }
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5984 5985 5986

  return 0;
}
5987

5988

5989
int init_ftfuncs(THD *thd, SELECT_LEX *select_lex, bool no_order)
5990
{
5991
  if (select_lex->ftfunc_list->elements)
5992
  {
5993
    List_iterator<Item_func_match> li(*(select_lex->ftfunc_list));
5994 5995 5996
    Item_func_match *ifm;
    DBUG_PRINT("info",("Performing FULLTEXT search"));
    thd->proc_info="FULLTEXT initialization";
5997

5998 5999 6000
    while ((ifm=li++))
      ifm->init_search(no_order);
  }
6001 6002
  return 0;
}
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6003 6004 6005 6006 6007 6008 6009


/*
  open new .frm format table

  SYNOPSIS
    open_new_frm()
6010
    THD		  thread handler
6011
    path	  path to .frm file (without extension)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6012
    alias	  alias for table
6013 6014
    db            database
    table_name    name of table
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6015 6016 6017 6018 6019 6020 6021 6022
    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
*/
6023

6024
static bool
6025
open_new_frm(THD *thd, TABLE_SHARE *share, const char *alias,
6026
             uint db_stat, uint prgflag,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6027 6028 6029 6030
	     uint ha_open_flags, TABLE *outparam, TABLE_LIST *table_desc,
	     MEM_ROOT *mem_root)
{
  LEX_STRING pathstr;
6031
  File_parser *parser;
6032
  char path[FN_REFLEN];
6033 6034
  DBUG_ENTER("open_new_frm");

6035 6036 6037 6038
  /* Create path with extension */
  pathstr.length= (uint) (strxmov(path, share->normalized_path.str, reg_ext,
                                  NullS)- path);
  pathstr.str=    path;
6039

6040
  if ((parser= sql_parse_prepare(&pathstr, mem_root, 1)))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6041
  {
6042
    if (is_equal(&view_type, parser->type()))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6043
    {
6044
      if (table_desc == 0 || table_desc->required_type == FRMTYPE_TABLE)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6045
      {
6046 6047
        my_error(ER_WRONG_OBJECT, MYF(0), share->db.str, share->table_name.str,
                 "BASE TABLE");
6048
        goto err;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6049
      }
6050
      if (mysql_make_view(thd, parser, table_desc))
6051
        goto err;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6052 6053 6054 6055
    }
    else
    {
      /* only VIEWs are supported now */
6056
      my_error(ER_FRM_UNKNOWN_TYPE, MYF(0), share->path,  parser->type()->str);
6057
      goto err;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6058
    }
6059
    DBUG_RETURN(0);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6060
  }
monty@mysql.com's avatar
monty@mysql.com committed
6061
 
6062 6063 6064
err:
  bzero(outparam, sizeof(TABLE));	// do not run repair
  DBUG_RETURN(1);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6065
}
6066 6067 6068 6069 6070 6071


bool is_equal(const LEX_STRING *a, const LEX_STRING *b)
{
  return a->length == b->length && !strncmp(a->str, b->str, a->length);
}
6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082 6083 6084 6085 6086 6087 6088 6089 6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111 6112 6113 6114 6115 6116 6117 6118 6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216 6217 6218 6219 6220 6221 6222 6223


/*
  SYNOPSIS
    abort_and_upgrade_lock()
    lpt                           Parameter passing struct
    All parameters passed through the ALTER_PARTITION_PARAM_TYPE object
  RETURN VALUES
    TRUE                          Failure
    FALSE                         Success
  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
*/

bool abort_and_upgrade_lock(ALTER_PARTITION_PARAM_TYPE *lpt)
{
  uint flags= RTFC_WAIT_OTHER_THREAD_FLAG | RTFC_CHECK_KILLED_FLAG;
  int error= FALSE;
  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));
  if (lpt->thd->killed)
  {
    lpt->thd->no_warnings_for_error= 0;
    error= TRUE;
  }
  VOID(pthread_mutex_unlock(&LOCK_open));
  DBUG_RETURN(error);
}


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