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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3 4
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
5
   the Free Software Foundation; version 2 of the License.
6

bk@work.mysql.com's avatar
bk@work.mysql.com committed
7 8 9 10
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
11

bk@work.mysql.com's avatar
bk@work.mysql.com committed
12 13 14 15 16
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


17
/* Basic functions needed by many modules */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
18 19

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

31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
/**
  This internal handler is used to trap internally
  errors that can occur when executing open table
  during the prelocking phase.
*/
class Prelock_error_handler : public Internal_error_handler
{
public:
  Prelock_error_handler()
    : m_handled_errors(0), m_unhandled_errors(0)
  {}

  virtual ~Prelock_error_handler() {}

  virtual bool handle_error(uint sql_errno,
                            MYSQL_ERROR::enum_warning_level level,
                            THD *thd);

  bool safely_trapped_errors();

private:
  int m_handled_errors;
  int m_unhandled_errors;
};


bool
Prelock_error_handler::handle_error(uint sql_errno,
                                    MYSQL_ERROR::enum_warning_level /* level */,
                                    THD * /* thd */)
{
  if (sql_errno == ER_NO_SUCH_TABLE)
  {
    m_handled_errors++;
    return TRUE;                                // 'TRUE', as per coding style
  }

  m_unhandled_errors++;
  return FALSE;                                 // 'FALSE', as per coding style
}


bool Prelock_error_handler::safely_trapped_errors()
{
  /*
    If m_unhandled_errors != 0, something else, unanticipated, happened,
    so the error is not trapped but returned to the caller.
    Multiple ER_NO_SUCH_TABLE can be raised in case of views.
  */
  return ((m_handled_errors > 0) && (m_unhandled_errors == 0));
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
84 85
TABLE *unused_tables;				/* Used by mysql_test */
HASH open_cache;				/* Used by mysql_test */
86 87 88 89 90 91 92
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,
93
                             char *cache_key, uint cache_key_length,
94
			     MEM_ROOT *mem_root, uint flags);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
95
static void free_cache_entry(TABLE *entry);
96
static bool open_new_frm(THD *thd, TABLE_SHARE *share, const char *alias,
97 98 99
                         uint db_stat, uint prgflag,
                         uint ha_open_flags, TABLE *outparam,
                         TABLE_LIST *table_desc, MEM_ROOT *mem_root);
100 101 102
static void close_old_data_files(THD *thd, TABLE *table, bool abort_locks,
                                 bool send_refresh);
static bool reopen_table(TABLE *table);
103 104
static bool
has_two_write_locked_tables_with_auto_increment(TABLE_LIST *tables);
105

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

107 108
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
109 110
{
  TABLE *entry=(TABLE*) record;
111 112
  *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
113 114
}

115

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
116
bool table_cache_init(void)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
117
{
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
118 119 120
  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
121 122 123 124 125
}

void table_cache_free(void)
{
  DBUG_ENTER("table_cache_free");
126 127 128 129 130 131
  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
132 133 134
  DBUG_VOID_RETURN;
}

135
uint cached_open_tables(void)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
136 137 138 139
{
  return open_cache.records;
}

140

bk@work.mysql.com's avatar
bk@work.mysql.com committed
141 142 143
#ifdef EXTRA_DEBUG
static void check_unused(void)
{
144
  uint count= 0, open_files= 0, idx= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167
  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--;
168 169
    if (entry->file)
      open_files++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
170 171 172
  }
  if (count != 0)
  {
173
    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
174 175
			count)); /* purecov: inspected */
  }
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194

#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
195 196 197 198 199
}
#else
#define check_unused()
#endif

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

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

226
uint create_table_def_key(THD *thd, char *key, TABLE_LIST *table_list,
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 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
                          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()
307
  thd			Thread handle
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327
  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
*/

328
TABLE_SHARE *get_table_share(THD *thd, TABLE_LIST *table_list, char *key,
329 330 331 332 333 334 335 336 337 338 339 340 341 342
                             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)))
  {
343
#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
344 345 346 347 348
    pthread_mutex_unlock(&LOCK_open);
#endif
    DBUG_RETURN(0);
  }

349
#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
  // 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);
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383

  /*
    We assign a new table id under the protection of the LOCK_open and
    the share's own mutex.  We do this insted of creating a new mutex
    and using it for the sole purpose of serializing accesses to a
    static variable, we assign the table id here.  We assign it to the
    share before inserting it into the table_def_cache to be really
    sure that it cannot be read from the cache without having a table
    id assigned.

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

384 385
  if (my_hash_insert(&table_def_cache, (byte*) share))
  {
386
#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
387 388 389 390 391 392
    pthread_mutex_unlock(&LOCK_open);    
    (void) pthread_mutex_unlock(&share->mutex);
#endif
    free_table_share(share);
    DBUG_RETURN(0);				// return error
  }
393
#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
394 395 396 397
  pthread_mutex_unlock(&LOCK_open);
#endif
  if (open_table_def(thd, share, db_flags))
  {
398
#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
399 400 401 402 403 404 405 406 407 408 409
    /*
      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;
410
    (void) hash_delete(&table_def_cache, (byte*) share);
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426
    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);
427
#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
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
  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,
482
                             char *key, uint key_length,
483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594
                             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;


595
#ifdef WAITING_FOR_TABLE_DEF_CACHE_STAGE_3
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 654 655 656
  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)
{
657
  char key[NAME_LEN*2+2];
658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686
  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;
687
  char *key_buff;
688 689 690 691 692 693 694 695
  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
  */
696 697 698 699
  if (multi_alloc_root(mem_root,
                       &share, sizeof(*share),
                       &key_buff, old_share->table_cache_key.length,
                       NULL))
700 701
  {
    bzero((char*) share, sizeof(*share));
702 703
    share->set_table_cache_key(key_buff, old_share->table_cache_key.str,
                               old_share->table_cache_key.length);
704 705 706 707 708 709 710 711 712 713 714 715 716
    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
717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734
/*
  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.
*/

735
OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *db, const char *wild)
736 737
{
  int result = 0;
738
  OPEN_TABLE_LIST **start_list, *open_list;
739 740
  TABLE_LIST table_list;
  DBUG_ENTER("list_open_tables");
741

742 743
  VOID(pthread_mutex_lock(&LOCK_open));
  bzero((char*) &table_list,sizeof(table_list));
744 745
  start_list= &open_list;
  open_list=0;
746

747
  for (uint idx=0 ; result == 0 && idx < open_cache.records; idx++)
748
  {
749
    OPEN_TABLE_LIST *table;
750
    TABLE *entry=(TABLE*) hash_element(&open_cache,idx);
751
    TABLE_SHARE *share= entry->s;
752

753
    if (db && my_strcasecmp(system_charset_info, db, share->db.str))
754
      continue;
755
    if (wild && wild_compare(share->table_name.str, wild, 0))
756
      continue;
757

758
    /* Check if user has SELECT privilege for any column in the table */
759 760
    table_list.db=         share->db.str;
    table_list.table_name= share->table_name.str;
761
    table_list.grant.privilege=0;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
762

763
    if (check_table_access(thd,SELECT_ACL | EXTRA_ACL,&table_list,1))
764 765 766
      continue;
    /* need to check if we haven't already listed it */
    for (table= open_list  ; table ; table=table->next)
767
    {
768 769
      if (!strcmp(table->table, share->table_name.str) &&
	  !strcmp(table->db,    share->db.str))
770 771 772 773 774 775 776
      {
	if (entry->in_use)
	  table->in_use++;
	if (entry->locked_by_name)
	  table->locked++;
	break;
      }
777
    }
778
    if (table)
779
      continue;
780
    if (!(*start_list = (OPEN_TABLE_LIST *)
781
	  sql_alloc(sizeof(**start_list)+share->table_cache_key.length)))
782
    {
783
      open_list=0;				// Out of memory
784
      break;
785
    }
786 787
    strmov((*start_list)->table=
	   strmov(((*start_list)->db= (char*) ((*start_list)+1)),
788 789
		  share->db.str)+1,
	   share->table_name.str);
790 791 792
    (*start_list)->in_use= entry->in_use ? 1 : 0;
    (*start_list)->locked= entry->locked_by_name ? 1 : 0;
    start_list= &(*start_list)->next;
793
    *start_list=0;
794 795
  }
  VOID(pthread_mutex_unlock(&LOCK_open));
796
  DBUG_RETURN(open_list);
797
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
798 799 800 801 802 803 804 805

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


void intern_close_table(TABLE *table)
{						// Free all structures
806 807
  DBUG_ENTER("intern_close_table");

bk@work.mysql.com's avatar
bk@work.mysql.com committed
808
  free_io_cache(table);
809
  delete table->triggers;
810 811 812
  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
813 814
}

815 816 817 818 819 820 821 822 823 824
/*
  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
825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846

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

847
/* Free resources allocated by filesort() and read_record() */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
848 849 850

void free_io_cache(TABLE *table)
{
851
  DBUG_ENTER("free_io_cache");
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
852
  if (table->sort.io_cache)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
853
  {
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
854 855 856
    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
857
  }
858
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
859 860
}

861 862 863 864 865 866
/*
  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
867

868
bool close_cached_tables(THD *thd, bool if_wait_for_refresh,
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
869
			 TABLE_LIST *tables, bool have_lock)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
870 871 872
{
  bool result=0;
  DBUG_ENTER("close_cached_tables");
873
  DBUG_ASSERT(thd || (!if_wait_for_refresh && !tables));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
874

tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
875 876
  if (!have_lock)
    VOID(pthread_mutex_lock(&LOCK_open));
877
  if (!tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
878
  {
879
    refresh_version++;				// Force close of open tables
880 881
    while (unused_tables)
    {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
882
#ifdef EXTRA_DEBUG
883 884
      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
885
#else
886
      VOID(hash_delete(&open_cache,(byte*) unused_tables));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
887
#endif
888
    }
889 890 891 892 893 894
    /* 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
895
  }
896
  else
bk@work.mysql.com's avatar
bk@work.mysql.com committed
897
  {
898
    bool found=0;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
899
    for (TABLE_LIST *table= tables; table; table= table->next_local)
900
    {
901 902
      if ((!table->table || !table->table->s->log_table) &&
          remove_table_from_cache(thd, table->db, table->table_name,
903
                                  RTFC_OWNED_BY_THD_FLAG))
904 905 906 907
	found=1;
    }
    if (!found)
      if_wait_for_refresh=0;			// Nothing to wait for
bk@work.mysql.com's avatar
bk@work.mysql.com committed
908
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
909
#ifndef EMBEDDED_LIBRARY
910 911
  if (!tables)
    kill_delayed_threads();
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
912
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
913 914 915 916 917 918 919 920 921 922
  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";

923
    close_old_data_files(thd,thd->open_tables,1,1);
924 925
    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
926 927
    bool found=1;
    /* Wait until all threads has closed all the tables we had locked */
928
    DBUG_PRINT("info",
monty@mysql.com's avatar
monty@mysql.com committed
929
	       ("Waiting for other threads to close their open tables"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
930 931 932 933 934 935
    while (found && ! thd->killed)
    {
      found=0;
      for (uint idx=0 ; idx < open_cache.records ; idx++)
      {
	TABLE *table=(TABLE*) hash_element(&open_cache,idx);
936 937
	if (!table->s->log_table &&
            ((table->s->version) < refresh_version && table->db_stat))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
938 939
	{
	  found=1;
monty@mysql.com's avatar
monty@mysql.com committed
940
          DBUG_PRINT("signal", ("Waiting for COND_refresh"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
941 942 943 944 945 946 947 948 949 950 951 952 953
	  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;
954
    /* Set version for table */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
955
    for (TABLE *table=thd->open_tables; table ; table= table->next)
956
      table->s->version= refresh_version;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
957
  }
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
958 959
  if (!have_lock)
    VOID(pthread_mutex_unlock(&LOCK_open));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
960 961 962 963 964 965 966 967 968 969 970 971
  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);
}


972
/*
973 974 975 976 977 978 979 980 981 982 983
  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.
984 985 986 987 988 989 990 991 992

  NOTE
    The reason we reset query_id is that it's not enough to just test
    if table->query_id != thd->query_id to know if a table is in use.

    For example
    SELECT f1_that_uses_t1() FROM t1;
    In f1_that_uses_t1() we will see one instance of t1 where query_id is
    set to query_id of original query.
993 994 995 996 997
*/

static void mark_used_tables_as_free_for_reuse(THD *thd, TABLE *table)
{
  for (; table ; table= table->next)
998
  {
999
    if (table->query_id == thd->query_id)
1000
    {
1001
      table->query_id= 0;
1002 1003 1004
      table->file->ha_reset();
    }
  }
1005 1006 1007 1008 1009 1010
}


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

1012 1013 1014 1015 1016 1017 1018
  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.
1019 1020
    stopper             When closing tables from thd->open_tables(->next)*, 
                        don't close/remove tables starting from stopper.
1021 1022 1023 1024

  IMPLEMENTATION
    Unlocks tables and frees derived tables.
    Put all normal tables used by thread in free list.
1025 1026 1027 1028 1029

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

1032
void close_thread_tables(THD *thd, bool lock_in_use, bool skip_derived)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1033
{
1034
  bool found_old_table;
1035
  prelocked_mode_type prelocked_mode= thd->prelocked_mode;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1036 1037
  DBUG_ENTER("close_thread_tables");

1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048
  /*
    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.
  */
1049 1050 1051 1052
  if (thd->derived_tables && !skip_derived)
  {
    TABLE *table, *next;
    /*
1053 1054
      Close all derived tables generated in queries like
      SELECT * FROM (SELECT * FROM t1)
1055 1056 1057 1058 1059 1060 1061 1062
    */
    for (table= thd->derived_tables ; table ; table= next)
    {
      next= table->next;
      free_tmp_table(thd, table);
    }
    thd->derived_tables= 0;
  }
1063 1064

  if (prelocked_mode)
1065
  {
1066 1067 1068 1069 1070 1071 1072 1073 1074
    /*
      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)
  {
    /*
1075 1076 1077 1078 1079 1080
      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.
1081 1082 1083
    */
    ha_commit_stmt(thd);

1084 1085
    /* Ensure we are calling ha_reset() for all used tables */
    mark_used_tables_as_free_for_reuse(thd, thd->open_tables);
1086

1087 1088
    /* We are under simple LOCK TABLES so should not do anything else. */
    if (!prelocked_mode || !thd->lex->requires_prelocking())
1089 1090 1091 1092 1093 1094
      DBUG_VOID_RETURN;

    /*
      We are in prelocked mode, so we have to leave it now with doing
      implicit UNLOCK TABLES if need.
    */
1095
    DBUG_PRINT("info",("thd->prelocked_mode= NON_PRELOCKED"));
1096 1097 1098 1099 1100 1101 1102 1103
    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 */
1104
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1105 1106 1107

  if (thd->lock)
  {
1108 1109 1110 1111 1112 1113 1114 1115 1116
    /*
      For RBR we flush the pending event just before we unlock all the
      tables.  This means that we are at the end of a topmost
      statement, so we ensure that the STMT_END_F flag is set on the
      pending event.  For statements that are *inside* stored
      functions, the pending event will not be flushed: that will be
      handled either before writing a query log event (inside
      binlog_query()) or when preparing a pending event.
     */
1117
    thd->binlog_flush_pending_rows_event(TRUE);
1118 1119
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1120
  }
1121 1122 1123 1124 1125 1126 1127 1128
  /*
    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()
  */
1129 1130
  if (!(thd->state_flags & Open_tables_state::BACKUPS_AVAIL))
    bzero(&thd->transaction.stmt, sizeof(thd->transaction.stmt));
1131
  if (!thd->active_transaction())
1132
    thd->transaction.xid_state.xid.null();
1133

1134
  if (!lock_in_use)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1135 1136
    VOID(pthread_mutex_lock(&LOCK_open));

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

1139 1140 1141 1142 1143 1144 1145
  /* 
    End open index scans and table scans and remove references to the tables 
    from the handler tables hash. After this preparation it is safe to close 
    the tables.
  */
  mysql_ha_mark_tables_for_reopen(thd, thd->open_tables);

1146
  found_old_table= 0;
1147
  while (thd->open_tables)
1148
    found_old_table|= close_thread_table(thd, &thd->open_tables);
1149
  thd->some_tables_deleted=0;
1150

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1151
  /* Free tables to hold down open files */
1152
  while (open_cache.records > table_cache_size && unused_tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1153 1154 1155 1156 1157
    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 */
1158
    broadcast_refresh();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1159
  }
1160
  if (!lock_in_use)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1161 1162
    VOID(pthread_mutex_unlock(&LOCK_open));
  /*  VOID(pthread_sigmask(SIG_SETMASK,&thd->signals,NULL)); */
1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173

  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
1174 1175 1176
  DBUG_VOID_RETURN;
}

1177

1178 1179 1180 1181
/* move one table to free list */

bool close_thread_table(THD *thd, TABLE **table_ptr)
{
1182 1183
  bool found_old_table= 0;
  TABLE *table= *table_ptr;
1184
  DBUG_ENTER("close_thread_table");
1185
  DBUG_ASSERT(table->key_read == 0);
monty@mysql.com's avatar
monty@mysql.com committed
1186
  DBUG_ASSERT(table->file->inited == handler::NONE);
1187 1188

  *table_ptr=table->next;
1189
  if (table->s->version != refresh_version ||
1190 1191 1192 1193 1194 1195 1196
      thd->version != refresh_version || !table->db_stat)
  {
    VOID(hash_delete(&open_cache,(byte*) table));
    found_old_table=1;
  }
  else
  {
1197
    /* Free memory and reset for next loop */
1198
    table->file->ha_reset();
1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212
    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
1213

1214 1215 1216 1217 1218 1219 1220
/* close_temporary_tables' internal, 4 is due to uint4korr definition */
static inline uint  tmpkeyval(THD *thd, TABLE *table)
{
  return uint4korr(table->s->table_cache_key.str + table->s->table_cache_key.length - 4);
}


1221 1222
/*
  Close all temporary tables created by 'CREATE TEMPORARY TABLE' for thread
1223
  creates one DROP TEMPORARY TABLE binlog event for each pseudo-thread 
1224
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1225 1226 1227

void close_temporary_tables(THD *thd)
{
1228
  TABLE *table;
1229 1230 1231 1232 1233 1234 1235 1236 1237 1238
  TABLE *next;
 /*
   TODO: 5.1 maintains prev link in temporary_tables
   double-linked list so we could fix it. But it is not necessary
   at this time when the list is being destroyed
 */
  TABLE *prev_table;
  /* Assume thd->options has OPTION_QUOTE_SHOW_CREATE */
  bool was_quote_show= TRUE;

1239 1240
  if (!thd->temporary_tables)
    return;
1241

1242 1243
  if (!mysql_bin_log.is_open() || thd->current_stmt_binlog_row_based)
  {
1244 1245
    TABLE *next;
    for (table= thd->temporary_tables; table; table= next)
1246
    {
1247
      next=table->next;
1248 1249 1250 1251 1252 1253
      close_temporary(table, 1, 1);
    }
    thd->temporary_tables= 0;
    return;
  }

1254
  /* Better add "if exists", in case a RESET MASTER has been done */
1255 1256 1257 1258
  const char stub[]= "DROP /*!40005 TEMPORARY */ TABLE IF EXISTS ";
  uint stub_len= sizeof(stub) - 1;
  char buf[256];
  String s_query= String(buf, sizeof(buf), system_charset_info);
1259
  bool found_user_tables= FALSE;
1260 1261
  LINT_INIT(next);

1262 1263
  memcpy(buf, stub, stub_len);

1264 1265
  /*
     insertion sort of temp tables by pseudo_thread_id to build ordered list
1266 1267
     of sublists of equal pseudo_thread_id
  */
1268 1269

  for (prev_table= thd->temporary_tables, table= prev_table->next;
1270 1271
       table;
       prev_table= table, table= table->next)
1272
  {
1273 1274
    TABLE *prev_sorted /* same as for prev_table */, *sorted;
    if (is_user_table(table))
1275
    {
1276 1277 1278 1279
      if (!found_user_tables)
        found_user_tables= true;
      for (prev_sorted= NULL, sorted= thd->temporary_tables; sorted != table;
           prev_sorted= sorted, sorted= sorted->next)
1280
      {
1281 1282
        if (!is_user_table(sorted) ||
            tmpkeyval(thd, sorted) > tmpkeyval(thd, table))
1283
        {
1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296
          /* move into the sorted part of the list from the unsorted */
          prev_table->next= table->next;
          table->next= sorted;
          if (prev_sorted)
          {
            prev_sorted->next= table;
          }
          else
          {
            thd->temporary_tables= table;
          }
          table= prev_table;
          break;
1297 1298 1299
        }
      }
    }
1300
  }
1301 1302 1303

  /* We always quote db,table names though it is slight overkill */
  if (found_user_tables &&
1304
      !(was_quote_show= test(thd->options & OPTION_QUOTE_SHOW_CREATE)))
1305
  {
1306
    thd->options |= OPTION_QUOTE_SHOW_CREATE;
1307
  }
1308

1309
  /* scan sorted tmps to generate sequence of DROP */
1310
  for (table= thd->temporary_tables; table; table= next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1311
  {
1312
    if (is_user_table(table))
1313
    {
1314
      my_thread_id save_pseudo_thread_id= thd->variables.pseudo_thread_id;
1315 1316
      /* Set pseudo_thread_id to be that of the processed table */
      thd->variables.pseudo_thread_id= tmpkeyval(thd, table);
1317 1318 1319 1320
      /*
        Loop forward through all tables within the sublist of
        common pseudo_thread_id to create single DROP query.
      */
1321 1322
      for (s_query.length(stub_len);
           table && is_user_table(table) &&
1323 1324 1325
             tmpkeyval(thd, table) == thd->variables.pseudo_thread_id;
           table= next)
      {
1326 1327 1328 1329 1330 1331 1332 1333 1334
        /*
          We are going to add 4 ` around the db/table names and possible more
          due to special characters in the names
        */
        append_identifier(thd, &s_query, table->s->db.str, strlen(table->s->db.str));
        s_query.q_append('.');
        append_identifier(thd, &s_query, table->s->table_name.str,
                          strlen(table->s->table_name.str));
        s_query.q_append(',');
1335 1336 1337 1338
        next= table->next;
        close_temporary(table, 1, 1);
      }
      thd->clear_error();
1339 1340 1341 1342 1343 1344
      CHARSET_INFO *cs_save= thd->variables.character_set_client;
      thd->variables.character_set_client= system_charset_info;
      Query_log_event qinfo(thd, s_query.ptr(),
                            s_query.length() - 1 /* to remove trailing ',' */,
                            0, FALSE);
      thd->variables.character_set_client= cs_save;
1345
      /*
1346 1347 1348 1349 1350 1351 1352 1353
        Imagine the thread had created a temp table, then was doing a
        SELECT, and the SELECT was killed. Then it's not clever to
        mark the statement above as "killed", because it's not really
        a statement updating data, and there are 99.99% chances it
        will succeed on slave.  If a real update (one updating a
        persistent table) was killed on the master, then this real
        update will be logged with error_code=killed, rightfully
        causing the slave to stop.
1354 1355 1356
      */
      qinfo.error_code= 0;
      mysql_bin_log.write(&qinfo);
1357
      thd->variables.pseudo_thread_id= save_pseudo_thread_id;
1358
    }
1359
    else
1360 1361 1362
    {
      next= table->next;
      close_temporary(table, 1, 1);
1363
    }
1364
  }
1365
  if (!was_quote_show)
1366
    thd->options&= ~OPTION_QUOTE_SHOW_CREATE; /* restore option */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1367 1368 1369
  thd->temporary_tables=0;
}

1370
/*
1371
  Find table in list.
1372 1373

  SYNOPSIS
1374
    find_table_in_list()
1375
    table		Pointer to table list
1376
    offset		Offset to which list in table structure to use
1377 1378
    db_name		Data base name
    table_name		Table name
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1379

1380 1381 1382
  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
1383 1384 1385 1386 1387 1388

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

1389
TABLE_LIST *find_table_in_list(TABLE_LIST *table,
1390
                               st_table_list *TABLE_LIST::*link,
1391 1392
                               const char *db_name,
                               const char *table_name)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1393
{
1394
  for (; table; table= table->*link )
1395
  {
1396 1397 1398 1399
    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;
1400
  }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1401 1402 1403 1404
  return table;
}


1405
/*
1406
  Test that table is unique (It's only exists once in the table list)
1407 1408 1409

  SYNOPSIS
    unique_table()
1410
    thd                   thread handle
1411
    table                 table which should be checked
1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427
    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

1428 1429 1430 1431
    We also skip tables with TABLE_LIST::prelocking_placeholder set,
    because we want to allow SELECTs from them, and their modification
    will rise the error anyway.

1432 1433
    TODO: when we will have table/view change detection we can do this check
          only once for PS/SP
1434 1435

  RETURN
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1436 1437
    found duplicate
    0 if table is unique
1438 1439
*/

1440
TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list)
1441
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1442
  TABLE_LIST *res;
1443
  const char *d_name, *t_name;
serg@serg.mylan's avatar
serg@serg.mylan committed
1444 1445
  DBUG_ENTER("unique_table");
  DBUG_PRINT("enter", ("table alias: %s", table->alias));
1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457

  /*
    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)
1458
  {
1459 1460 1461 1462 1463 1464 1465 1466 1467
    /* 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);
1468
  }
1469 1470
  d_name= table->db;
  t_name= table->table_name;
1471 1472

  DBUG_PRINT("info", ("real table: %s.%s", d_name, t_name));
1473
  for (;;)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1474
  {
1475 1476 1477
    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) &&
1478 1479
         res->select_lex && !res->select_lex->exclude_from_table_unique_test &&
         !res->prelocking_placeholder))
1480
      break;
1481
    /*
1482
      If we found entry of this table or table of SELECT which already
1483
      processed in derived table or top select of multi-update/multi-delete
1484
      (exclude_from_table_unique_test) or prelocking placeholder.
1485
    */
1486
    table_list= res->next_global;
1487 1488
    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
1489
  }
1490
  DBUG_RETURN(res);
1491 1492 1493
}


1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528
/*
  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)
    {
1529
      /* Issue the ER_NON_INSERTABLE_TABLE error for an INSERT */
1530
      if (update->view == duplicate->view)
1531 1532 1533
        my_error(!strncmp(operation, "INSERT", 6) ?
                 ER_NON_INSERTABLE_TABLE : ER_NON_UPDATABLE_TABLE, MYF(0),
                 update->alias, operation);
1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550
      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);
}


1551
TABLE *find_temporary_table(THD *thd, const char *db, const char *table_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1552
{
1553
  TABLE_LIST table_list;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1554

1555 1556 1557 1558
  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
  return find_temporary_table(thd, &table_list);
}
1559

1560 1561 1562 1563 1564 1565

TABLE *find_temporary_table(THD *thd, TABLE_LIST *table_list)
{
  char	key[MAX_DBKEY_LENGTH];
  uint	key_length;
  TABLE *table;
1566 1567 1568
  DBUG_ENTER("find_temporary_table");
  DBUG_PRINT("enter", ("table: '%s'.'%s'",
                       table_list->db, table_list->table_name));
1569 1570 1571

  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
1572
  {
1573 1574
    if (table->s->table_cache_key.length == key_length &&
	!memcmp(table->s->table_cache_key.str, key, key_length))
1575 1576 1577 1578 1579
    {
      DBUG_PRINT("info",
                 ("Found table. server_id: %u  pseudo_thread_id: %lu",
                  (uint) thd->server_id,
                  (ulong) thd->variables.pseudo_thread_id));
1580
      DBUG_RETURN(table);
1581
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1582
  }
1583
  DBUG_RETURN(0);                               // Not a temporary table
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1584 1585
}

1586 1587 1588 1589 1590 1591

/*
  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
1592
{
1593
  TABLE *table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1594

1595
  if (!(table= find_temporary_table(thd, table_list)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1596
    return 1;
1597
  close_temporary_table(thd, table, 1, 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1598 1599 1600
  return 0;
}

1601
/*
1602
  unlink from thd->temporary tables and close temporary table
1603 1604 1605 1606 1607
*/

void close_temporary_table(THD *thd, TABLE *table,
                           bool free_share, bool delete_table)
{
1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626
  if (table->prev)
  {
    table->prev->next= table->next;
    if (table->prev->next)
      table->next->prev= table->prev;
  }
  else
  {
    /* removing the item from the list */
    DBUG_ASSERT(table == thd->temporary_tables);
    /*
      slave must reset its temporary list pointer to zero to exclude
      passing non-zero value to end_slave via rli->save_temporary_tables
      when no temp tables opened, see an invariant below.
    */
    thd->temporary_tables= table->next;
    if (thd->temporary_tables)
      table->next->prev= 0;
  }
1627
  if (thd->slave_thread)
1628 1629 1630
  {
    /* natural invariant of temporary_tables */
    DBUG_ASSERT(slave_open_temp_tables || !thd->temporary_tables);
1631
    slave_open_temp_tables--;
1632
  }
1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646
  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)
{
1647
  handlerton *table_type= table->s->db_type;
1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662
  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
1663 1664 1665 1666 1667 1668 1669
/*
  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'.
*/
1670

1671
bool rename_temporary_table(THD* thd, TABLE *table, const char *db,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1672 1673 1674
			    const char *table_name)
{
  char *key;
1675
  uint key_length;
1676
  TABLE_SHARE *share= table->s;
1677 1678 1679
  TABLE_LIST table_list;
  DBUG_ENTER("rename_temporary_table");

1680
  if (!(key=(char*) alloc_root(&share->mem_root, MAX_DBKEY_LENGTH)))
1681 1682 1683 1684
    DBUG_RETURN(1);				/* purecov: inspected */

  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
1685 1686
  key_length= create_table_def_key(thd, key, &table_list, 1);
  share->set_table_cache_key(key, key_length);
1687
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716
}


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

1721
  memcpy(key, find->s->table_cache_key.str, key_length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1722 1723 1724
  for (; list ; list=next)
  {
    next=list->next;
1725 1726
    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
1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739
    {
      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
1740
  broadcast_refresh();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1741 1742 1743 1744
  return start;
}


1745
/*
1746 1747 1748 1749 1750 1751 1752 1753
   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
1754 1755
*/

1756
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
1757 1758 1759
{
  /* Wait until the current table is up to date */
  const char *proc_info;
1760 1761
  thd->mysys_var->current_mutex= mutex;
  thd->mysys_var->current_cond= cond;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1762 1763
  proc_info=thd->proc_info;
  thd->proc_info="Waiting for table";
1764
  DBUG_ENTER("wait_for_condition");
1765
  if (!thd->killed)
1766
    (void) pthread_cond_wait(cond, mutex);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1767

1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779
  /*
    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
1780 1781 1782 1783 1784
  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);
monty@mysql.com's avatar
monty@mysql.com committed
1785
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1786 1787
}

1788

1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807
/*
  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)
1808
{
1809
  TABLE *table= table_list->table;
1810
  TABLE_SHARE *share;
1811 1812 1813
  char *table_name= table_list->table_name;
  TABLE orig_table;
  DBUG_ENTER("reopen_name_locked_table");
1814

1815 1816 1817 1818 1819 1820
  safe_mutex_assert_owner(&LOCK_open);

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

  orig_table= *table;
1821

1822 1823
  if (open_unireg_entry(thd, table, table_list, table_name,
                        table->s->table_cache_key.str,
1824
                        table->s->table_cache_key.length, thd->mem_root, 0))
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1825
  {
1826 1827 1828 1829 1830 1831 1832 1833 1834
    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
1835
  }
1836

1837 1838
  share= table->s;
  share->version=0;
1839 1840
  table->in_use = thd;
  check_unused();
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
1841 1842
  table->next = thd->open_tables;
  thd->open_tables = table;
1843 1844 1845
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
1846
  table->null_row= table->maybe_null= table->force_index= 0;
1847
  table->status=STATUS_NO_RECORD;
1848 1849
  table->keys_in_use_for_query= share->keys_in_use;
  table->used_keys= share->keys_for_keyread;
1850
  DBUG_RETURN(FALSE);
1851 1852
}

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

1854 1855 1856 1857 1858
/*
  Open a table.

  SYNOPSIS
    open_table()
1859 1860 1861 1862 1863 1864 1865 1866 1867 1868
    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.
1869 1870
                          MYSQL_OPEN_IGNORE_LOCKED_TABLES - Open table
                          ignoring set of locked tables and prelocked mode.
1871 1872 1873 1874 1875 1876

  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
1877
          all other tables and retry the open.
1878 1879
    #     Success. Pointer to TABLE object for open table.
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1880 1881


bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1882
TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
1883
		  bool *refresh, uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1884 1885 1886 1887
{
  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
1888
  char	*alias= table_list->alias;
1889
  HASH_SEARCH_STATE state;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1890 1891 1892 1893 1894
  DBUG_ENTER("open_table");

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

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1900 1901
  if (thd->killed)
    DBUG_RETURN(0);
1902 1903 1904

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

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1906
  if (!table_list->skip_temporary)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1907
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1908
    for (table= thd->temporary_tables; table ; table=table->next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1909
    {
1910 1911 1912
      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
1913
		  key_length + TMP_TABLE_KEY_EXTRA))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1914
      {
1915 1916
	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
1917
	{
1918 1919 1920 1921
          DBUG_PRINT("error",
                     ("query_id: %lu  server_id: %u  pseudo_thread_id: %lu",
                      (ulong) table->query_id, (uint) thd->server_id,
                      (ulong) thd->variables.pseudo_thread_id));
1922
	  my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1923 1924 1925 1926 1927
	  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
1928 1929
        DBUG_PRINT("info",("Using temporary table"));
        goto reset;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1930 1931 1932 1933
      }
    }
  }

1934 1935
  if (!(flags & MYSQL_OPEN_IGNORE_LOCKED_TABLES) &&
      (thd->locked_tables || thd->prelocked_mode))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1936
  {						// Using table locks
1937
    TABLE *best_table= 0;
1938
    int best_distance= INT_MIN;
1939 1940 1941
    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
1942 1943
    for (table=thd->open_tables; table ; table=table->next)
    {
1944 1945
      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
1946
      {
1947 1948
        if (check_if_used && table->query_id &&
            table->query_id != thd->query_id)
1949
        {
1950 1951 1952 1953 1954 1955 1956
          /*
            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),
1957
                   table->s->table_name.str);
1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993
          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;
            }
          }
1994
        }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1995
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1996
    }
1997 1998 1999 2000 2001 2002 2003
    if (best_table)
    {
      table= best_table;
      table->query_id= thd->query_id;
      DBUG_PRINT("info",("Using locked table"));
      goto reset;
    }
2004 2005 2006 2007 2008 2009 2010
    /*
      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];
2011
      enum legacy_db_type not_used;
2012
      build_table_filename(path, sizeof(path) - 1,
2013
                           table_list->db, table_list->table_name, reg_ext, 0);
2014
      if (mysql_frm_type(thd, path, &not_used) == FRMTYPE_VIEW)
2015
      {
2016 2017 2018 2019 2020
        /*
          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;
2021
        table= &tab;
2022
        VOID(pthread_mutex_lock(&LOCK_open));
2023
        if (!open_unireg_entry(thd, table, table_list, alias,
2024
                              key, key_length, mem_root, 0))
2025
        {
2026
          DBUG_ASSERT(table_list->view != 0);
2027 2028 2029 2030 2031 2032
          VOID(pthread_mutex_unlock(&LOCK_open));
          DBUG_RETURN(0); // VIEW
        }
        VOID(pthread_mutex_unlock(&LOCK_open));
      }
    }
2033 2034 2035 2036
    if ((thd->locked_tables) && (thd->locked_tables->lock_count > 0))
      my_error(ER_TABLE_NOT_LOCKED, MYF(0), alias);
    else
      my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->db, table_list->alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2037 2038
    DBUG_RETURN(0);
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2039

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2040 2041 2042 2043
  VOID(pthread_mutex_lock(&LOCK_open));

  if (!thd->open_tables)
    thd->version=refresh_version;
2044
  else if ((thd->version != refresh_version) &&
2045
           ! (flags & MYSQL_LOCK_IGNORE_FLUSH))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2046 2047
  {
    /* Someone did a refresh while thread was opening tables */
2048 2049
    if (refresh)
      *refresh=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2050 2051 2052 2053
    VOID(pthread_mutex_unlock(&LOCK_open));
    DBUG_RETURN(0);
  }

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

2058 2059
  for (table= (TABLE*) hash_first(&open_cache, (byte*) key, key_length,
                                  &state);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2060
       table && table->in_use ;
2061 2062
       table= (TABLE*) hash_next(&open_cache, (byte*) key, key_length,
                                 &state))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2063
  {
2064 2065 2066 2067 2068
    /*
      Here we flush tables marked for flush. However we never flush log
      tables here. They are flushed only on FLUSH LOGS.
    */
    if (table->s->version != refresh_version && !table->s->log_table)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2069
    {
monty@mysql.com's avatar
monty@mysql.com committed
2070 2071 2072
      DBUG_PRINT("note",
                 ("Found table '%s.%s' with different refresh version",
                  table_list->db, table_list->table_name));
2073

2074
      if (flags & MYSQL_LOCK_IGNORE_FLUSH)
2075 2076 2077 2078 2079 2080
      {
        /* Force close at once after usage */
        thd->version= table->s->version;
        continue;
      }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2081
      /*
2082 2083
        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
2084
      */
2085
      close_old_data_files(thd,thd->open_tables,0,0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2086
      if (table->in_use != thd)
2087
        wait_for_condition(thd, &LOCK_open, &COND_refresh);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2088
      else
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2089
      {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2090
	VOID(pthread_mutex_unlock(&LOCK_open));
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2091
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106
      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;
2107
    table->in_use= thd;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2108 2109 2110
  }
  else
  {
2111
    int error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2112
    /* Free cache if too big */
2113
    while (open_cache.records > table_cache_size && unused_tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2114 2115 2116 2117
      VOID(hash_delete(&open_cache,(byte*) unused_tables)); /* purecov: tested */

    /* make a new table */
    if (!(table=(TABLE*) my_malloc(sizeof(*table),MYF(MY_WME))))
2118 2119
    {
      VOID(pthread_mutex_unlock(&LOCK_open));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2120
      DBUG_RETURN(NULL);
2121
    }
2122

2123 2124 2125
    error= open_unireg_entry(thd, table, table_list, alias, key, key_length,
                             mem_root, (flags & OPEN_VIEW_NO_PARSE));
    if (error > 0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2126
    {
2127
      my_free((gptr)table, MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2128 2129 2130
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(NULL);
    }
2131
    if (table_list->view || error < 0)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2132
    {
2133 2134 2135 2136 2137 2138 2139
      /*
        VIEW not really opened, only frm were read.
        Set 1 as a flag here
      */
      if (error < 0)
        table_list->view= (st_lex*)1;

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2140 2141 2142 2143
      my_free((gptr)table, MYF(0));
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(0); // VIEW
    }
2144
    DBUG_PRINT("info", ("inserting table 0x%lx into the cache", (long) table));
hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
2145
    VOID(my_hash_insert(&open_cache,(byte*) table));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2146 2147
  }

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2150 2151 2152 2153 2154 2155 2156 2157 2158
  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:
2159 2160
  DBUG_ASSERT(table->s->ref_count > 0 || table->s->tmp_table != NO_TMP_TABLE);

2161 2162
  if (thd->lex->need_correct_ident())
    table->alias_name_used= my_strcasecmp(table_alias_charset,
2163
                                          table->s->table_name.str, alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2164
  /* Fix alias if table name changes */
2165
  if (strcmp(table->alias, alias))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2166
  {
2167
    uint length=(uint) strlen(alias)+1;
2168 2169 2170
    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
2171 2172 2173 2174 2175
  }
  /* These variables are also set in reopen_table() */
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
2176
  table->null_row= table->maybe_null= table->force_index= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2177
  table->status=STATUS_NO_RECORD;
2178
  table->keys_in_use_for_query= table->s->keys_in_use;
2179
  table->insert_values= 0;
2180
  table->used_keys= table->s->keys_for_keyread;
2181 2182
  table->fulltext_searched= 0;
  table->file->ft_handler= 0;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2183
  if (table->timestamp_field)
2184
    table->timestamp_field_type= table->timestamp_field->get_auto_set_type();
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2185
  table->pos_in_table_list= table_list;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2186
  table_list->updatable= 1; // It is not derived table nor non-updatable VIEW
2187
  table->clear_column_bitmaps();
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
2188
  DBUG_ASSERT(table->key_read == 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199
  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)
  {
2200 2201
    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
2202 2203 2204 2205 2206 2207
      return table;
  }
  return(0);
}


2208 2209
/*
  Reopen an table because the definition has changed.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2210

2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224
  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
2225 2226
{
  TABLE tmp;
2227
  bool error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2228 2229
  Field **field;
  uint key,part;
2230 2231
  TABLE_LIST table_list;
  THD *thd= table->in_use;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2232 2233
  DBUG_ENTER("reopen_table");

2234 2235 2236
  DBUG_ASSERT(table->s->ref_count == 0);
  DBUG_ASSERT(!table->sort.io_cache);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2237 2238 2239
#ifdef EXTRA_DEBUG
  if (table->db_stat)
    sql_print_error("Table %s had a open data handler in reopen_table",
2240
		    table->alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2241
#endif
2242 2243 2244 2245 2246
  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
2247

2248 2249 2250 2251 2252 2253 2254
  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,
2255
                        thd->mem_root, 0))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2256 2257
    goto end;

2258
  /* This list copies variables set by open_table */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2259 2260 2261 2262
  tmp.tablenr=		table->tablenr;
  tmp.used_fields=	table->used_fields;
  tmp.const_table=	table->const_table;
  tmp.null_row=		table->null_row;
2263
  tmp.maybe_null=	table->maybe_null;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2264
  tmp.status=		table->status;
2265 2266
  tmp.keys_in_use_for_query= tmp.s->keys_in_use;
  tmp.used_keys= 	tmp.s->keys_for_keyread;
2267

2268 2269
  tmp.s->table_map_id=  table->s->table_map_id;

2270
  /* Get state */
2271
  tmp.in_use=    	thd;
2272
  tmp.reginfo.lock_type=table->reginfo.lock_type;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2273 2274
  tmp.grant=		table->grant;

2275
  /* Replace table in open list */
2276 2277
  tmp.next=		table->next;
  tmp.prev=		table->prev;
2278

2279
  delete table->triggers;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2280
  if (table->file)
2281
    VOID(closefrm(table, 1));		// close file, free everything
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2282

2283
  *table= tmp;
2284
  table->default_column_bitmaps();
2285
  table->file->change_table_ptr(table, table->s);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2286

2287
  DBUG_ASSERT(table->alias != 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2288 2289
  for (field=table->field ; *field ; field++)
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2290
    (*field)->table= (*field)->orig_table= table;
2291
    (*field)->table_name= &table->alias;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2292
  }
2293
  for (key=0 ; key < table->s->keys ; key++)
2294
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2295
    for (part=0 ; part < table->key_info[key].usable_key_parts ; part++)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2296
      table->key_info[key].key_part[part].field->table= table;
2297
  }
2298 2299 2300
  if (table->triggers)
    table->triggers->set_table(table);

2301
  broadcast_refresh();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312
  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
2313
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2314 2315 2316 2317

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2320 2321
  for (table=thd->open_tables; table ; table=table->next)
  {
2322 2323
    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
2324 2325
    {
      mysql_lock_remove(thd, thd->locked_tables,table);
2326
      close_handle_and_leave_table_as_lock(table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2327 2328
    }
  }
2329
  DBUG_RETURN(0);                               // For the future
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2330 2331 2332 2333 2334 2335 2336 2337 2338 2339
}


/*
  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)
{
2340 2341 2342
  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
2343
  DBUG_ENTER("reopen_tables");
2344

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2345 2346 2347
  if (!thd->open_tables)
    DBUG_RETURN(0);

2348
  safe_mutex_assert_owner(&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2349 2350 2351 2352
  if (get_locks)
  {
    /* The ptr is checked later */
    uint opens=0;
2353 2354
    for (table= thd->open_tables; table ; table=table->next)
      opens++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365
    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;
2366
    if (!tables || (!db_stat && reopen_table(table)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2367
    {
2368
      my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379
      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)
      {
2380
	table->s->version=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2381 2382 2383 2384 2385 2386 2387 2388 2389
	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;
2390 2391
    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
2392 2393 2394 2395 2396 2397 2398 2399 2400 2401
    {
      thd->locked_tables=mysql_lock_merge(thd->locked_tables,lock);
    }
    else
      error=1;
  }
  if (get_locks && tables)
  {
    my_afree((gptr) tables);
  }
2402
  broadcast_refresh();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2403 2404 2405 2406
  *prev=0;
  DBUG_RETURN(error);
}

2407

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2408 2409 2410 2411 2412 2413
/*
  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.
*/

2414 2415
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
2416
{
2417
  bool found= send_refresh;
2418
  DBUG_ENTER("close_old_data_files");
2419

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2420 2421
  for (; table ; table=table->next)
  {
2422 2423 2424 2425 2426
    /*
      Reopen marked for flush. But close log tables. They are flushed only
      explicitly on FLUSH LOGS
    */
    if (table->s->version != refresh_version && !table->s->log_table)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2427 2428 2429 2430 2431 2432
    {
      found=1;
      if (table->db_stat)
      {
	if (abort_locks)
	{
2433
	  mysql_lock_abort(thd,table, TRUE);	// Close waiting threads
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2434 2435 2436
	  mysql_lock_remove(thd, thd->locked_tables,table);
	  table->locked_by_flush=1;		// Will be reopened with locks
	}
2437
        close_handle_and_leave_table_as_lock(table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2438 2439 2440 2441
      }
    }
  }
  if (found)
2442
    broadcast_refresh();
2443
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2444 2445 2446 2447 2448 2449 2450
}


/*
  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
2451 2452 2453 2454
  NOTE: log tables are handled differently by the logging routines.
        E.g. general_log is always opened and locked by the logger
        and the table handler used by the logger, will be skipped by
        this check.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2455 2456
*/

2457
bool table_is_used(TABLE *table, bool wait_for_name_lock)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2458
{
2459
  DBUG_ENTER("table_is_used");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2460 2461
  do
  {
2462 2463 2464 2465
    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
2466 2467
    HASH_SEARCH_STATE state;
    for (TABLE *search= (TABLE*) hash_first(&open_cache, (byte*) key,
2468
                                             key_length, &state);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2469
	 search ;
2470 2471
         search= (TABLE*) hash_next(&open_cache, (byte*) key,
                                    key_length, &state))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2472
    {
2473 2474
      DBUG_PRINT("info", ("share: 0x%lx  locked_by_logger: %d "
                          "locked_by_flush: %d  locked_by_name: %d "
2475
                          "db_stat: %u  version: %lu",
2476
                          (ulong) search->s, search->locked_by_logger,
2477 2478 2479 2480 2481 2482 2483 2484 2485 2486
                          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
2487 2488 2489
        (We must wait until all engines are shut down to use the table)
        However we fo not wait if we encountered a table, locked by the logger.
        Log tables are managed separately by logging routines.
2490
      */
2491 2492 2493 2494
      if (!search->locked_by_logger &&
          (search->locked_by_name && wait_for_name_lock ||
           search->locked_by_flush ||
           (search->db_stat && search->s->version < refresh_version)))
2495
        DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2496 2497
    }
  } while ((table=table->next));
2498
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510
}


/* 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);
2511
  while (!thd->killed)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2512
  {
2513 2514
    thd->some_tables_deleted=0;
    close_old_data_files(thd,thd->open_tables,0,dropping_tables != 0);
2515
    mysql_ha_flush(thd, (TABLE_LIST*) NULL, MYSQL_HA_REOPEN_ON_USAGE, TRUE);
2516 2517
    if (!table_is_used(thd->open_tables,1))
      break;
2518
    (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2519 2520 2521 2522 2523 2524 2525
  }
  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
2526
    thd->version= refresh_version;
2527
    result=reopen_tables(thd,0,0);
2528
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2529 2530 2531 2532 2533 2534
  pthread_mutex_unlock(&LOCK_open);
  thd->proc_info=0;
  DBUG_RETURN(result);
}


2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551
/*
  drop tables from locked list

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

  INFORMATION
    This is only called on drop tables

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

2553 2554 2555 2556 2557
  RETURN
    #    If table existed, return table
    0	 Table was not locked
*/

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

2559
TABLE *drop_locked_tables(THD *thd,const char *db, const char *table_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2560
{
2561
  TABLE *table,*next,**prev, *found= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2562
  prev= &thd->open_tables;
2563 2564
  DBUG_ENTER("drop_locked_tables");

2565
  for (table= thd->open_tables; table ; table=next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2566 2567
  {
    next=table->next;
2568 2569
    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
2570 2571
    {
      mysql_lock_remove(thd, thd->locked_tables,table);
2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586
      if (!found)
      {
        found= table;
        /* Close engine table, but keep object around as a name lock */
        if (table->db_stat)
        {
          table->db_stat= 0;
          table->file->close();
        }
      }
      else
      {
        /* We already have a name lock, remove copy */
        VOID(hash_delete(&open_cache,(byte*) table));
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2587 2588 2589 2590 2591 2592 2593 2594 2595
    }
    else
    {
      *prev=table;
      prev= &table->next;
    }
  }
  *prev=0;
  if (found)
2596
    broadcast_refresh();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2597 2598 2599 2600 2601
  if (thd->locked_tables && thd->locked_tables->table_count == 0)
  {
    my_free((gptr) thd->locked_tables,MYF(0));
    thd->locked_tables=0;
  }
2602
  DBUG_RETURN(found);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2603 2604 2605
}


2606 2607 2608 2609 2610
/*
  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
2611 2612 2613 2614

void abort_locked_tables(THD *thd,const char *db, const char *table_name)
{
  TABLE *table;
2615
  for (table= thd->open_tables; table ; table= table->next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2616
  {
2617 2618
    if (!strcmp(table->s->table_name.str, table_name) &&
	!strcmp(table->s->db.str, db))
2619
    {
2620
      mysql_lock_abort(thd,table, TRUE);
2621 2622
      break;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2623 2624 2625
  }
}

2626

2627
/*
2628
  Function to assign a new table map id to a table share.
2629 2630 2631

  PARAMETERS

2632
    share - Pointer to table share structure
2633

mats@mysql.com's avatar
mats@mysql.com committed
2634 2635 2636 2637 2638 2639 2640
  DESCRIPTION

    We are intentionally not checking that share->mutex is locked
    since this function should only be called when opening a table
    share and before it is entered into the table_def_cache (meaning
    that it cannot be fetched by another thread, even accidentally).

2641 2642
  PRE-CONDITION(S)

2643
    share is non-NULL
2644 2645 2646 2647
    The LOCK_open mutex is locked

  POST-CONDITION(S)

2648 2649 2650 2651
    share->table_map_id is given a value that with a high certainty is
    not used by any other table (the only case where a table id can be
    reused is on wrap-around, which means more than 4 billion table
    shares open at the same time).
2652

2653
    share->table_map_id is not ~0UL.
2654
 */
2655
void assign_new_table_id(TABLE_SHARE *share)
2656
{
2657
  static ulong last_table_id= ~0UL;
2658

2659
  DBUG_ENTER("assign_new_table_id");
2660 2661

  /* Preconditions */
2662
  DBUG_ASSERT(share != NULL);
2663 2664 2665
  safe_mutex_assert_owner(&LOCK_open);

  ulong tid= ++last_table_id;                   /* get next id */
2666 2667 2668 2669
  /*
    There is one reserved number that cannot be used.  Remember to
    change this when 6-byte global table id's are introduced.
  */
2670
  if (unlikely(tid == ~0UL))
2671
    tid= ++last_table_id;
2672
  share->table_map_id= tid;
2673 2674 2675
  DBUG_PRINT("info", ("table_id=%lu", tid));

  /* Post conditions */
2676
  DBUG_ASSERT(share->table_map_id != ~0UL);
2677 2678 2679 2680

  DBUG_VOID_RETURN;
}

2681 2682 2683 2684 2685 2686 2687
/*
  Load a table definition from file and open unireg table

  SYNOPSIS
    open_unireg_entry()
    thd			Thread handle
    entry		Store open table definition here
2688
    table_list		TABLE_LIST with db, table_name & belong_to_view
2689
    alias		Alias name
2690 2691
    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
2692
    mem_root		temporary mem_root for parsing
2693 2694
    flags               the OPEN_VIEW_NO_PARSE flag to be passed to
                        openfrm()/open_new_frm()
2695 2696 2697

  NOTES
   Extra argument for open is taken from thd->open_options
2698
   One must have a lock on LOCK_open when calling this function
2699 2700 2701 2702

  RETURN
    0	ok
    #	Error
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2703
*/
2704 2705 2706

static int open_unireg_entry(THD *thd, TABLE *entry, TABLE_LIST *table_list,
                             const char *alias,
2707
                             char *cache_key, uint cache_key_length,
2708
                             MEM_ROOT *mem_root, uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2709
{
2710
  int error;
2711
  TABLE_SHARE *share;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2712
  uint discover_retry_count= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2713 2714
  DBUG_ENTER("open_unireg_entry");

2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728
  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),
2729 2730
                              READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD |
                              (flags & OPEN_VIEW_NO_PARSE),
2731
                              thd->open_options, entry, table_list,
2732
                              mem_root);
2733 2734 2735 2736
    if (error)
      goto err;
    /* TODO: Don't free this */
    release_table_share(share, RELEASE_NORMAL);
2737
    DBUG_RETURN((flags & OPEN_VIEW_NO_PARSE)? -1 : 0);
2738
  }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2739

2740 2741 2742 2743 2744 2745 2746
  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),
2747
                                       thd->open_options, entry, FALSE)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2748
  {
2749
    if (error == 7)                             // Table def changed
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2750
    {
2751 2752 2753 2754
      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
2755
      /*
2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766
        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
2767
      */
2768 2769
      if (ha_create_table_from_engine(thd, table_list->db,
                                      table_list->table_name))
monty@mysql.com's avatar
monty@mysql.com committed
2770
        goto err;
2771 2772 2773 2774 2775 2776
      /*
        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
2777
        goto err;
2778 2779 2780
      /* Free share and wait until it's released by all threads */
      release_table_share(share, RELEASE_WAIT_FOR_DROP);
      if (!thd->killed)
2781
      {
2782 2783 2784
        mysql_reset_errors(thd, 1);         // Clear warnings
        thd->clear_error();                 // Clear error message
        goto retry;
2785
      }
2786
      DBUG_RETURN(1);
2787
    }
2788
    if (!entry->s || !entry->s->crashed)
2789
      goto err;
2790
     // Code below is for repairing a crashed file
2791
     if ((error= lock_table_name(thd, table_list, TRUE)))
2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809
     {
       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,
2810
                               entry, FALSE) || ! entry->file ||
2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830
 	(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;
   }
2831

2832 2833 2834 2835
  if (Table_triggers_list::check_n_load(thd, share->db.str,
                                        share->table_name.str, entry, 0))
  {
    closefrm(entry, 0);
2836
    goto err;
2837
  }
2838

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2839 2840 2841 2842 2843 2844 2845 2846 2847 2848
  /*
    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;
2849 2850
      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
2851
      {
2852
        /* this DELETE FROM is needed even with row-based binlogging */
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2853
        end = strxmov(strmov(query, "DELETE FROM `"),
2854
                      share->db.str,"`.`",share->table_name.str,"`", NullS);
2855 2856
        thd->binlog_query(THD::STMT_QUERY_TYPE,
                          query, (ulong)(end-query), FALSE, FALSE);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2857 2858 2859 2860 2861 2862 2863 2864 2865
        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).
        */
2866 2867 2868
        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);
2869
        delete entry->triggers;
2870
        closefrm(entry, 0);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2871 2872 2873
        goto err;
      }
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2874 2875
  }
  DBUG_RETURN(0);
2876

2877
err:
2878
  release_table_share(share, RELEASE_NORMAL);
2879
  DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2880 2881
}

2882

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2883 2884 2885 2886 2887 2888
/*
  Open all tables in list

  SYNOPSIS
    open_tables()
    thd - thread handler
2889
    start - list of tables in/out
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2890
    counter - number of opened tables will be return using this parameter
2891 2892 2893
    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
2894

2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905
  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
2906 2907 2908 2909 2910
  RETURN
    0  - OK
    -1 - error
*/

2911
int open_tables(THD *thd, TABLE_LIST **start, uint *counter, uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2912 2913 2914 2915
{
  TABLE_LIST *tables;
  bool refresh;
  int result=0;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2916
  MEM_ROOT new_frm_mem;
2917 2918
  /* Also used for indicating that prelocking is need */
  TABLE_LIST **query_tables_last_own;
2919 2920
  bool safe_to_ignore_table;

2921
  DBUG_ENTER("open_tables");
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2922 2923 2924 2925 2926
  /*
    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
2927

2928
  thd->current_tablenr= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2929
 restart:
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2930
  *counter= 0;
2931
  query_tables_last_own= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2932
  thd->proc_info="Opening tables";
2933 2934 2935 2936 2937 2938 2939

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

  */
2940 2941

  if (!thd->prelocked_mode && !thd->lex->requires_prelocking() &&
2942
      thd->lex->sroutines_list.elements)
2943
  {
2944
    bool first_no_prelocking, need_prelocking;
2945
    TABLE_LIST **save_query_tables_last= thd->lex->query_tables_last;
2946 2947

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

2950
    if (sp_cache_routines_and_add_tables(thd, thd->lex, first_no_prelocking))
2951
    {
2952 2953 2954 2955 2956 2957
      /*
        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;
2958 2959
      goto err;
    }
2960
    else if (need_prelocking)
2961 2962 2963 2964 2965 2966 2967
    {
      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
2968
  {
2969
    safe_to_ignore_table= FALSE;                // 'FALSE', as per coding style
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2970 2971 2972
    /*
      Ignore placeholders for derived tables. After derived tables
      processing, link to created temporary table will be put here.
2973 2974
      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
2975 2976
     */
    if (tables->derived)
2977 2978 2979
    {
      if (tables->view)
        goto process_view_routines;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2980
      continue;
2981
    }
2982 2983 2984 2985 2986 2987
    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
2988
    (*counter)++;
2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010

    if (!tables->table)
    {
      if (tables->prelocking_placeholder)
      {
        /*
          For the tables added by the pre-locking code, attempt to open
          the table but fail silently if the table does not exist.
          The real failure will occur when/if a statement attempts to use
          that table.
        */
        Prelock_error_handler prelock_handler;
        thd->push_internal_handler(& prelock_handler);
        tables->table= open_table(thd, tables, &new_frm_mem, &refresh, flags);
        thd->pop_internal_handler();
        safe_to_ignore_table= prelock_handler.safely_trapped_errors();
      }
      else
        tables->table= open_table(thd, tables, &new_frm_mem, &refresh, flags);
    }

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

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3014 3015
      if (tables->view)
      {
3016
        /* VIEW placeholder */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3017
	(*counter)--;
3018

3019
        /*
3020 3021 3022 3023 3024
          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
3025 3026 3027
          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.
3028
        */
3029
        if (query_tables_last_own == &(tables->next_global) &&
3030 3031
            tables->view->query_tables)
          query_tables_last_own= tables->view->query_tables_last;
3032
        /*
3033 3034
          Let us free memory used by 'sroutines' hash here since we never
          call destructor for this LEX.
3035
        */
3036
        hash_free(&tables->view->sroutines);
3037
	goto process_view_routines;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3038 3039
      }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3040 3041
      if (refresh)				// Refresh in progress
      {
3042
        /*
3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054
          We have met name-locked or old version of table. Now we have
          to close all tables which are not up to date. We also have to
          throw away set of prelocked tables (and thus close tables from
          this set that were open by now) since it possible that one of
          tables which determined its content was changed.

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

          In order to prepare for recalculation of set of prelocked tables
          we pretend that we have finished calculation which we were doing
          currently.
3055 3056 3057
        */
        if (query_tables_last_own)
          thd->lex->mark_as_requiring_prelocking(query_tables_last_own);
3058
        close_tables_for_reopen(thd, start);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3059 3060
	goto restart;
      }
3061 3062 3063 3064 3065 3066 3067 3068

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3069 3070 3071
      result= -1;				// Fatal error
      break;
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3072
    else
3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086
    {
      /*
        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)
3087 3088
          query_tables_last_own= thd->lex->query_tables_last;
        if (sp_cache_routines_and_add_tables_for_triggers(thd, thd->lex,
3089
                                                          tables))
3090
        {
3091 3092 3093 3094 3095 3096
          /*
            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;
3097 3098
          goto err;
        }
3099
      }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3100
      free_root(&new_frm_mem, MYF(MY_KEEP_PREALLOC));
3101
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3102

3103
    if (tables->lock_type != TL_UNLOCK && ! thd->locked_tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3104 3105
      tables->table->reginfo.lock_type=tables->lock_type;
    tables->table->grant= tables->grant;
3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118

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;
3119
      if (sp_cache_routines_and_add_tables_for_view(thd, thd->lex, tables))
3120
      {
3121 3122 3123 3124 3125 3126
        /*
          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;
3127 3128
        goto err;
      }
3129
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3130
  }
3131 3132

 err:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3133
  thd->proc_info=0;
3134
  free_root(&new_frm_mem, MYF(0));              // Free pre-alloced block
3135 3136 3137 3138

  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
3139 3140 3141 3142
  DBUG_RETURN(result);
}


3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165
/*
  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)
  {
3166
    my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),table->alias);
3167 3168
    DBUG_RETURN(1);
  }
serg@serg.mylan's avatar
serg@serg.mylan committed
3169
  if ((error=table->file->start_stmt(thd, lock_type)))
3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186
  {
    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

3187 3188 3189 3190 3191
  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.

3192 3193 3194 3195 3196 3197 3198 3199 3200
  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
3201 3202 3203 3204 3205 3206 3207
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";
3208
  thd->current_tablenr= 0;
3209 3210
  /* open_ltable can be used only for BASIC TABLEs */
  table_list->required_type= FRMTYPE_TABLE;
3211
  while (!(table= open_table(thd, table_list, thd->mem_root, &refresh, 0)) &&
3212
         refresh)
3213
    ;
3214

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3215 3216
  if (table)
  {
3217
#if defined( __WIN__)
3218
    /* Win32 can't drop a file that is open */
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3219
    if (lock_type == TL_WRITE_ALLOW_READ)
3220 3221 3222
    {
      lock_type= TL_WRITE;
    }
3223
#endif /* __WIN__ */
3224 3225
    table_list->lock_type= lock_type;
    table_list->table=	   table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3226 3227 3228
    table->grant= table_list->grant;
    if (thd->locked_tables)
    {
3229 3230 3231 3232 3233
      if (check_lock_and_start_stmt(thd, table, lock_type))
	table= 0;
    }
    else
    {
3234
      DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
3235
      if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)
3236 3237
	if (! (thd->lock= mysql_lock_tables(thd, &table_list->table, 1, 0,
                                            &refresh)))
3238
	  table= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3239 3240 3241 3242 3243 3244
    }
  }
  thd->proc_info=0;
  DBUG_RETURN(table);
}

3245

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3246
/*
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259
  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
3260
    The lock will automaticaly be freed by close_thread_tables()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3261 3262
*/

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3263
int simple_open_n_lock_tables(THD *thd, TABLE_LIST *tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3264
{
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3265
  uint counter;
3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276
  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);
3277
    close_tables_for_reopen(thd, &tables);
3278
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292
  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
3293 3294
    FALSE - ok
    TRUE  - error
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3295 3296

  NOTE
3297
    The lock will automaticaly be freed by close_thread_tables()
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3298 3299
*/

3300
bool open_and_lock_tables(THD *thd, TABLE_LIST *tables)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3301 3302
{
  uint counter;
3303
  bool need_reopen;
monty@mysql.com's avatar
monty@mysql.com committed
3304
  DBUG_ENTER("open_and_lock_tables");
3305 3306 3307 3308 3309 3310 3311 3312 3313

  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);
3314
    close_tables_for_reopen(thd, &tables);
3315 3316
  }
  if (mysql_handle_derived(thd->lex, &mysql_derived_prepare) ||
3317 3318
      (thd->fill_derived_tables() &&
       mysql_handle_derived(thd->lex, &mysql_derived_filling)))
3319
    DBUG_RETURN(TRUE); /* purecov: inspected */
monty@mysql.com's avatar
monty@mysql.com committed
3320
  DBUG_RETURN(0);
monty@mysql.com's avatar
monty@mysql.com committed
3321 3322 3323
}


3324 3325 3326 3327 3328 3329
/*
  Open all tables in list and process derived tables

  SYNOPSIS
    open_normal_and_derived_tables
    thd		- thread handler
3330
    tables	- list of tables for open
3331 3332 3333
    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.
3334 3335 3336 3337 3338 3339 3340 3341 3342 3343

  RETURN
    FALSE - ok
    TRUE  - error

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

3344
bool open_normal_and_derived_tables(THD *thd, TABLE_LIST *tables, uint flags)
3345 3346 3347
{
  uint counter;
  DBUG_ENTER("open_normal_and_derived_tables");
monty@mysql.com's avatar
monty@mysql.com committed
3348
  DBUG_ASSERT(!thd->fill_derived_tables());
3349
  if (open_tables(thd, &tables, &counter, flags) ||
monty@mysql.com's avatar
monty@mysql.com committed
3350 3351 3352
      mysql_handle_derived(thd->lex, &mysql_derived_prepare))
    DBUG_RETURN(TRUE); /* purecov: inspected */
  DBUG_RETURN(0);
3353 3354 3355
}


3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371
/*
  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)
3372
    if (!table->placeholder())
3373 3374 3375 3376
      table->table->query_id= 0;
}


3377 3378 3379 3380 3381 3382 3383
/*
  Lock all tables in list

  SYNOPSIS
    lock_tables()
    thd			Thread handler
    tables		Tables to lock
3384 3385 3386 3387 3388 3389
    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).
3390

3391 3392 3393 3394 3395
  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.

3396 3397 3398 3399
    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.

3400 3401 3402 3403 3404
  RETURN VALUES
   0	ok
   -1	Error
*/

3405
int lock_tables(THD *thd, TABLE_LIST *tables, uint count, bool *need_reopen)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3406
{
3407
  TABLE_LIST *table;
3408 3409 3410 3411 3412 3413 3414 3415

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

3416 3417
  *need_reopen= FALSE;

3418 3419 3420 3421 3422 3423
  /*
    CREATE ... SELECT UUID() locks no tables, we have to test here.
  */
  if (thd->lex->binlog_row_based_if_mixed)
    thd->set_current_stmt_binlog_row_based_if_mixed();

3424
  if (!tables && !thd->lex->requires_prelocking())
3425
    DBUG_RETURN(0);
3426

3427 3428 3429 3430 3431 3432 3433 3434 3435 3436
  /*
    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
3437
  {
3438
    DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3439
    TABLE **start,**ptr;
3440

3441
    if (!(ptr=start=(TABLE**) thd->alloc(sizeof(TABLE*)*count)))
3442
      DBUG_RETURN(-1);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3443
    for (table= tables; table; table= table->next_global)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3444
    {
3445
      if (!table->placeholder())
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3446 3447
	*(ptr++)= table->table;
    }
3448 3449 3450 3451 3452 3453

    /* 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;
3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464
      /*
        If we have >= 2 different tables to update with auto_inc columns,
        statement-based binlogging won't work. We can solve this problem in
        mixed mode by switching to row-based binlogging:
      */
      if (thd->variables.binlog_format == BINLOG_FORMAT_MIXED &&
          has_two_write_locked_tables_with_auto_increment(tables))
      {
        thd->lex->binlog_row_based_if_mixed= TRUE;
        thd->set_current_stmt_binlog_row_based_if_mixed();
      }
3465 3466
    }

3467 3468 3469
    if (! (thd->lock= mysql_lock_tables(thd, start, (uint) (ptr - start),
                                        MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN,
                                        need_reopen)))
3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497
    {
      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)
      {
3498
        if (!table->placeholder())
3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515
        {
          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);
3516
      DBUG_PRINT("info",("prelocked_mode= PRELOCKED"));
3517 3518
      thd->prelocked_mode= PRELOCKED;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3519
  }
3520 3521
  else
  {
3522 3523
    TABLE_LIST *first_not_own= thd->lex->first_not_own_table();
    for (table= tables; table != first_not_own; table= table->next_global)
3524
    {
3525
      if (!table->placeholder() &&
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3526
	  check_lock_and_start_stmt(thd, table->table, table->lock_type))
3527
      {
3528
	ha_rollback_stmt(thd);
3529
	DBUG_RETURN(-1);
3530 3531
      }
    }
3532 3533 3534 3535 3536 3537 3538 3539
    /*
      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);
3540
      DBUG_PRINT("info", ("thd->prelocked_mode= PRELOCKED_UNDER_LOCK_TABLES"));
3541 3542
      thd->prelocked_mode= PRELOCKED_UNDER_LOCK_TABLES;
    }
3543
  }
3544
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3545 3546
}

3547

3548 3549 3550 3551 3552 3553
/*
  Prepare statement for reopening of tables and recalculation of set of
  prelocked tables.

  SYNOPSIS
    close_tables_for_reopen()
3554 3555
      thd    in     Thread context
      tables in/out List of tables which we were trying to open and lock
3556 3557 3558

*/

3559
void close_tables_for_reopen(THD *thd, TABLE_LIST **tables)
3560
{
3561 3562 3563 3564 3565 3566
  /*
    If table list consists only from tables from prelocking set, table list
    for new attempt should be empty, so we have to update list's root pointer.
  */
  if (thd->lex->first_not_own_table() == *tables)
    *tables= 0;
3567 3568
  thd->lex->chop_off_not_own_tables();
  sp_remove_not_own_routines(thd->lex);
3569 3570 3571
  for (TABLE_LIST *tmp= *tables; tmp; tmp= tmp->next_global)
    tmp->table= 0;
  mark_used_tables_as_free_for_reuse(thd, thd->temporary_tables);
3572 3573 3574 3575
  close_thread_tables(thd);
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
3576
/*
3577
  Open a single table without table caching and don't set it in open_list
3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593

  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
3594 3595 3596 3597 3598 3599
*/

TABLE *open_temporary_table(THD *thd, const char *path, const char *db,
			    const char *table_name, bool link_in_list)
{
  TABLE *tmp_table;
3600
  TABLE_SHARE *share;
3601 3602 3603
  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
3604
  DBUG_ENTER("open_temporary_table");
3605 3606 3607 3608 3609
  DBUG_PRINT("enter",
             ("table: '%s'.'%s'  path: '%s'  server_id: %u  "
              "pseudo_thread_id: %lu",
              db, table_name, path,
              (uint) thd->server_id, (ulong) thd->variables.pseudo_thread_id));
3610

3611 3612 3613 3614 3615 3616 3617 3618
  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
3619 3620
    DBUG_RETURN(0);				/* purecov: inspected */

3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634
  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,
3635
                            tmp_table, FALSE))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3636
  {
3637 3638
    /* No need to lock share->mutex as this is not needed for tmp tables */
    free_table_share(share);
3639
    my_free((char*) tmp_table,MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3640 3641 3642
    DBUG_RETURN(0);
  }

3643
  tmp_table->reginfo.lock_type= TL_WRITE;	 // Simulate locked
3644 3645
  share->tmp_table= (tmp_table->file->has_transactions() ? 
                     TRANSACTIONAL_TMP_TABLE : TMP_TABLE);
3646

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3647 3648
  if (link_in_list)
  {
3649 3650 3651 3652
    /* growing temp list at the head */
    tmp_table->next= thd->temporary_tables;
    if (tmp_table->next)
      tmp_table->next->prev= tmp_table;
3653
    thd->temporary_tables= tmp_table;
3654
    thd->temporary_tables->prev= 0;
3655 3656
    if (thd->slave_thread)
      slave_open_temp_tables++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3657
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3658
  tmp_table->pos_in_table_list= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3659 3660 3661 3662
  DBUG_RETURN(tmp_table);
}


3663
bool rm_temporary_table(handlerton *base, char *path)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3664 3665
{
  bool error=0;
3666 3667
  handler *file;
  char *ext;
3668 3669
  DBUG_ENTER("rm_temporary_table");

3670
  strmov(ext= strend(path), reg_ext);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3671 3672
  if (my_delete(path,MYF(0)))
    error=1; /* purecov: inspected */
3673 3674
  *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
3675
  if (file && file->delete_table(path))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3676
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3677
    error=1;
3678
    sql_print_warning("Could not remove temporary table: '%s', error: %d",
serg@serg.mylan's avatar
serg@serg.mylan committed
3679
                      path, my_errno);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3680
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3681
  delete file;
3682
  DBUG_RETURN(error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3683 3684 3685 3686
}


/*****************************************************************************
3687 3688 3689 3690 3691 3692
* 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
3693 3694
******************************************************************************/

3695
/* Special Field pointers as return values of find_field_in_XXX functions. */
3696 3697
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
3698

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

3701 3702
static void update_field_dependencies(THD *thd, Field *field, TABLE *table)
{
3703 3704
  DBUG_ENTER("update_field_dependencies");
  if (thd->mark_used_columns != MARK_COLUMNS_NONE)
3705
  {
3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716
    MY_BITMAP *current_bitmap, *other_bitmap;

    /*
      We always want to register the used keys, as the column bitmap may have
      been set for all fields (for example for view).
    */
      
    table->used_keys.intersect(field->part_of_key);
    table->merge_keys.merge(field->part_of_key);

    if (thd->mark_used_columns == MARK_COLUMNS_READ)
3717
    {
3718 3719
      current_bitmap= table->read_set;
      other_bitmap=   table->write_set;
3720 3721
    }
    else
3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744
    {
      current_bitmap= table->write_set;
      other_bitmap=   table->read_set;
    }

    if (bitmap_fast_test_and_set(current_bitmap, field->field_index))
    {
      if (thd->mark_used_columns == MARK_COLUMNS_WRITE)
      {
        DBUG_PRINT("warning", ("Found duplicated field"));
        thd->dup_field= field;
      }
      else
      {
        DBUG_PRINT("note", ("Field found before"));
      }
      DBUG_VOID_RETURN;
    }
    if (table->get_fields_in_item_tree)
      field->flags|= GET_FIXED_FIELDS_FLAG;
    table->used_fields++;
  }
  else if (table->get_fields_in_item_tree)
3745
    field->flags|= GET_FIXED_FIELDS_FLAG;
3746
  DBUG_VOID_RETURN;
3747 3748
}

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3749 3750

/*
3751
  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
3752 3753

  SYNOPSIS
3754
    find_field_in_view()
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3755
    thd				thread handler
3756
    table_list			view to search for 'name'
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3757 3758
    name			name of field
    length			length of name
3759
    item_name                   name of item if it will be created (VIEW)
3760 3761
    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
3762
    register_tree_change        TRUE if ref is not stack variable and we
3763
                                need register changes in item tree
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3764 3765 3766 3767

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

3771 3772
static Field *
find_field_in_view(THD *thd, TABLE_LIST *table_list,
3773 3774
                   const char *name, uint length,
                   const char *item_name, Item **ref,
3775
                   bool register_tree_change)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3776
{
3777 3778 3779 3780 3781 3782
  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);
3783
  Query_arena *arena, backup;  
3784
  LINT_INIT(arena);
3785
  
3786 3787 3788
  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
3789
  {
3790
    if (!my_strcasecmp(system_charset_info, field_it.name(), name))
3791
    {
3792 3793 3794
      // in PS use own arena or data will be freed after prepare
      if (register_tree_change)
        arena= thd->activate_stmt_arena_if_needed(&backup);
3795 3796 3797 3798
      /*
        create_item() may, or may not create a new Item, depending on
        the column reference. See create_view_field() for details.
      */
3799
      Item *item= field_it.create_item(thd);
3800 3801 3802
      if (register_tree_change && arena)
        thd->restore_active_arena(arena, &backup);
      
3803 3804 3805 3806 3807 3808
      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.
3809
       We need to set alias on both ref itself and on ref real item.
3810 3811
      */
      if (*ref && !(*ref)->is_autogenerated_name)
3812
      {
3813 3814
        item->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
3815 3816 3817
        item->real_item()->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
      }
3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845
      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

3846 3847 3848 3849 3850 3851
  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.

3852
  RETURN
3853 3854 3855
    NULL        if the field was not found
    WRONG_GRANT if no access rights to the found field
    #           Pointer to the found Field
3856 3857 3858 3859
*/

static Field *
find_field_in_natural_join(THD *thd, TABLE_LIST *table_ref, const char *name,
3860
                           uint length, Item **ref, bool register_tree_change,
3861
                           TABLE_LIST **actual_table)
3862
{
3863 3864
  List_iterator_fast<Natural_join_column>
    field_it(*(table_ref->join_columns));
3865
  Natural_join_column *nj_col, *curr_nj_col;
3866
  Field *found_field;
3867
  Query_arena *arena, backup;
3868
  DBUG_ENTER("find_field_in_natural_join");
3869
  DBUG_PRINT("enter", ("field name: '%s', ref 0x%lx",
3870 3871
		       name, (ulong) ref));
  DBUG_ASSERT(table_ref->is_natural_join && table_ref->join_columns);
3872
  DBUG_ASSERT(*actual_table == NULL);
3873

3874
  LINT_INIT(arena);
3875
  LINT_INIT(found_field);
3876

3877 3878
  for (nj_col= NULL, curr_nj_col= field_it++; curr_nj_col; 
       curr_nj_col= field_it++)
3879
  {
3880 3881 3882 3883 3884 3885 3886 3887 3888
    if (!my_strcasecmp(system_charset_info, curr_nj_col->name(), name))
    {
      if (nj_col)
      {
        my_error(ER_NON_UNIQ_ERROR, MYF(0), name, thd->where);
        DBUG_RETURN(NULL);
      }
      nj_col= curr_nj_col;
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3889
  }
3890 3891
  if (!nj_col)
    DBUG_RETURN(NULL);
3892 3893 3894

  if (nj_col->view_field)
  {
monty@mysql.com's avatar
monty@mysql.com committed
3895
    Item *item;
3896
    LINT_INIT(arena);
3897 3898
    if (register_tree_change)
      arena= thd->activate_stmt_arena_if_needed(&backup);
3899 3900 3901 3902
    /*
      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
3903
    item= nj_col->create_item(thd);
3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916
    /*
     *ref != NULL means that *ref contains the item that we need to
     replace. If the item was aliased by the user, set the alias to
     the replacing item.
     We need to set alias on both ref itself and on ref real item.
     */
    if (*ref && !(*ref)->is_autogenerated_name)
    {
      item->set_name((*ref)->name, (*ref)->name_length,
                     system_charset_info);
      item->real_item()->set_name((*ref)->name, (*ref)->name_length,
                                  system_charset_info);
    }
3917 3918 3919
    if (register_tree_change && arena)
      thd->restore_active_arena(arena, &backup);

3920 3921 3922 3923
    if (!item)
      DBUG_RETURN(NULL);
    DBUG_ASSERT(nj_col->table_field == NULL);
    if (nj_col->table_ref->schema_table_reformed)
3924
    {
3925 3926 3927 3928 3929 3930
      /*
        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);
3931
    }
3932 3933 3934 3935 3936 3937 3938 3939 3940 3941
    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);
3942
    DBUG_ASSERT(nj_col->table_ref->table == nj_col->table_field->table);
3943 3944 3945 3946 3947 3948 3949
    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
3950 3951
}

3952

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3953
/*
3954
  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
3955 3956

  SYNOPSIS
3957
    find_field_in_table()
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3958
    thd				thread handler
3959
    table			table where to search for the field
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3960 3961 3962
    name			name of field
    length			length of name
    allow_rowid			do allow finding of "_rowid" field?
3963 3964
    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
3965 3966

  RETURN
3967 3968
    0	field is not found
    #	pointer to field
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3969 3970
*/

3971 3972
Field *
find_field_in_table(THD *thd, TABLE *table, const char *name, uint length,
3973
                    bool allow_rowid, uint *cached_field_index_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3974
{
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3975 3976
  Field **field_ptr, *field;
  uint cached_field_index= *cached_field_index_ptr;
3977 3978
  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
3979 3980

  /* We assume here that table->field < NO_CACHED_FIELD_INDEX = UINT_MAX */
3981
  if (cached_field_index < table->s->fields &&
3982
      !my_strcasecmp(system_charset_info,
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3983 3984
                     table->field[cached_field_index]->field_name, name))
    field_ptr= table->field + cached_field_index;
3985
  else if (table->s->name_hash.records)
3986
  {
3987 3988
    field_ptr= (Field**) hash_search(&table->s->name_hash, (byte*) name,
                                     length);
3989 3990 3991 3992 3993 3994 3995 3996 3997
    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
3998 3999 4000
  else
  {
    if (!(field_ptr= table->field))
4001
      DBUG_RETURN((Field *)0);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4002 4003 4004 4005 4006 4007
    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
4008
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4009 4010
    *cached_field_index_ptr= field_ptr - table->field;
    field= *field_ptr;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4011 4012 4013
  }
  else
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4014 4015
    if (!allow_rowid ||
        my_strcasecmp(system_charset_info, name, "_rowid") ||
4016
        table->s->rowid_field_offset == 0)
4017
      DBUG_RETURN((Field*) 0);
4018
    field= table->field[table->s->rowid_field_offset-1];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4019 4020
  }

4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034
  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
4035
    length		   [in]  field length of name
4036 4037
    item_name              [in]  name of item if it will be created (VIEW)
    db_name                [in]  optional database name that qualifies the
4038
    table_name             [in]  optional table name that qualifies the field
4039 4040
    ref		       [in/out] if 'name' is resolved to a view field, ref
                                 is set to point to the found view field
4041
    check_privileges       [in]  check privileges
4042 4043 4044 4045 4046 4047 4048 4049 4050
    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
4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062
  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.

4063 4064 4065 4066 4067 4068 4069 4070
  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,
4071 4072 4073
                        const char *name, uint length,
                        const char *item_name, const char *db_name,
                        const char *table_name, Item **ref,
4074 4075
                        bool check_privileges, bool allow_rowid,
                        uint *cached_field_index_ptr,
4076 4077 4078 4079
                        bool register_tree_change, TABLE_LIST **actual_table)
{
  Field *fld;
  DBUG_ENTER("find_field_in_table_ref");
4080 4081 4082
  DBUG_ASSERT(table_list->alias);
  DBUG_ASSERT(name);
  DBUG_ASSERT(item_name);
4083 4084 4085 4086 4087 4088
  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
4089 4090
    are the same as the table reference we are going to search for the field.

4091 4092 4093 4094
    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
4095 4096 4097 4098 4099 4100

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

4101 4102
    TODO: Ensure that table_name, db_name and tables->db always points to
          something !
4103
  */
4104 4105
  if (/* Exclude nested joins. */
      (!table_list->nested_join ||
timour@mysql.com's avatar
timour@mysql.com committed
4106 4107 4108 4109 4110 4111
       /* Include merge views and information schema tables. */
       table_list->field_translation) &&
      /*
        Test if the field qualifiers match the table reference we plan
        to search.
      */
4112 4113
      table_name && table_name[0] &&
      (my_strcasecmp(table_alias_charset, table_list->alias, table_name) ||
4114 4115 4116 4117
       (db_name && db_name[0] && table_list->db && table_list->db[0] &&
        strcmp(db_name, table_list->db))))
    DBUG_RETURN(0);

4118
  *actual_table= NULL;
timour@mysql.com's avatar
timour@mysql.com committed
4119

4120 4121
  if (table_list->field_translation)
  {
timour@mysql.com's avatar
timour@mysql.com committed
4122
    /* 'table_list' is a view or an information schema table. */
4123
    if ((fld= find_field_in_view(thd, table_list, name, length, item_name, ref,
4124
                                 register_tree_change)))
4125 4126
      *actual_table= table_list;
  }
4127
  else if (!table_list->nested_join)
4128
  {
4129 4130
    /* 'table_list' is a stored table. */
    DBUG_ASSERT(table_list->table);
timour@mysql.com's avatar
timour@mysql.com committed
4131
    if ((fld= find_field_in_table(thd, table_list->table, name, length,
4132 4133
                                  allow_rowid,
                                  cached_field_index_ptr)))
timour@mysql.com's avatar
timour@mysql.com committed
4134 4135 4136
      *actual_table= table_list;
  }
  else
4137
  {
timour@mysql.com's avatar
timour@mysql.com committed
4138
    /*
timour@mysql.com's avatar
timour@mysql.com committed
4139 4140 4141 4142 4143
      '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
4144
    */
4145 4146 4147 4148 4149 4150
    if (table_name && table_name[0])
    {
      List_iterator<TABLE_LIST> it(table_list->nested_join->join_list);
      TABLE_LIST *table;
      while ((table= it++))
      {
4151 4152
        if ((fld= find_field_in_table_ref(thd, table, name, length, item_name,
                                          db_name, table_name, ref,
4153 4154
                                          check_privileges, allow_rowid,
                                          cached_field_index_ptr,
4155 4156 4157 4158 4159 4160 4161
                                          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
4162 4163 4164
      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.
4165 4166
    */
    fld= find_field_in_natural_join(thd, table_list, name, length, ref,
4167
                                    register_tree_change, actual_table);
4168
  }
4169

4170 4171
  if (fld)
  {
4172
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4173 4174 4175 4176 4177
    /* Check if there are sufficient access rights to the found field. */
    if (check_privileges &&
        check_column_grant_in_table_ref(thd, *actual_table, name, length))
      fld= WRONG_GRANT;
    else
4178
#endif
4179
      if (thd->mark_used_columns != MARK_COLUMNS_NONE)
4180
      {
4181
        /*
4182 4183 4184
          Get rw_set correct for this field so that the handler
          knows that this field is involved in the query and gets
          retrieved/updated
4185
         */
4186 4187 4188 4189 4190 4191
        Field *field_to_set= NULL;
        if (fld == view_ref_found)
        {
          Item *it= (*ref)->real_item();
          if (it->type() == Item::FIELD_ITEM)
            field_to_set= ((Item_field*)it)->field;
4192 4193 4194 4195 4196
          else
          {
            if (thd->mark_used_columns == MARK_COLUMNS_READ)
              it->walk(&Item::register_field_in_read_map, 1, (byte *) 0);
          }
4197 4198 4199 4200
        }
        else
          field_to_set= fld;
        if (field_to_set)
4201 4202 4203 4204 4205 4206 4207
        {
          TABLE *table= field_to_set->table;
          if (thd->mark_used_columns == MARK_COLUMNS_READ)
            bitmap_set_bit(table->read_set, field_to_set->field_index);
          else
            bitmap_set_bit(table->write_set, field_to_set->field_index);
        }
4208 4209
      }
  }
4210
  DBUG_RETURN(fld);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4211 4212
}

4213

4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232
/*
  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)
4233
  {
4234 4235
    field_ptr= (Field**)hash_search(&table->s->name_hash,(byte*) name,
                                    strlen(name));
4236 4237 4238 4239 4240 4241 4242 4243 4244
    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));
    }
  }
4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259
  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;
}


4260 4261 4262 4263 4264
/*
  Find field in table list.

  SYNOPSIS
    find_field_in_tables()
4265 4266 4267 4268 4269 4270
    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
4271
                          point to the found view field
4272
    report_error	  Degree of error reporting:
4273 4274
                          - IGNORE_ERRORS then do not report any error
                          - IGNORE_EXCEPT_NON_UNIQUE report only non-unique
4275
                            fields, suppress all other errors
4276 4277 4278 4279
                          - REPORT_EXCEPT_NON_UNIQUE report all other errors
                            except when non-unique fields were found
                          - REPORT_ALL_ERRORS
    check_privileges      need to check privileges
4280 4281
    register_tree_change  TRUE if ref is not a stack variable and we
                          to need register changes in item tree
4282 4283

  RETURN VALUES
4284 4285 4286
    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.
4287 4288 4289 4290 4291
    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
4292
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4293 4294

Field *
4295 4296
find_field_in_tables(THD *thd, Item_ident *item,
                     TABLE_LIST *first_table, TABLE_LIST *last_table,
4297
		     Item **ref, find_item_error_report_type report_error,
4298
                     bool check_privileges, bool register_tree_change)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4299 4300
{
  Field *found=0;
4301 4302 4303
  const char *db= item->db_name;
  const char *table_name= item->table_name;
  const char *name= item->field_name;
4304
  uint length=(uint) strlen(name);
4305
  char name_buff[NAME_LEN+1];
4306 4307
  TABLE_LIST *cur_table= first_table;
  TABLE_LIST *actual_table;
4308 4309 4310 4311 4312 4313 4314 4315 4316
  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
4317

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4318 4319 4320
  if (item->cached_table)
  {
    /*
4321 4322
      This shortcut is used by prepared statements. We assume that
      TABLE_LIST *first_table is not changed during query execution (which
4323
      is true for all queries except RENAME but luckily RENAME doesn't
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4324
      use fields...) so we can rely on reusing pointer to its member.
timour@mysql.com's avatar
timour@mysql.com committed
4325
      With this optimization we also miss case when addition of one more
4326
      field makes some prepared query ambiguous and so erroneous, but we
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4327 4328
      accept this trade off.
    */
4329 4330 4331 4332 4333 4334 4335 4336
    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,
4337
                                 TRUE, &(item->cached_field_index));
4338
    else
4339
      found= find_field_in_table_ref(thd, table_ref, name, length, item->name,
4340 4341
                                     NULL, NULL, ref, check_privileges,
                                     TRUE, &(item->cached_field_index),
4342 4343
                                     register_tree_change,
                                     &actual_table);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4344 4345 4346
    if (found)
    {
      if (found == WRONG_GRANT)
4347
	return (Field*) 0;
4348 4349 4350 4351 4352 4353

      /*
        Only views fields should be marked as dependent, not an underlying
        fields.
      */
      if (!table_ref->belong_to_view)
4354 4355
      {
        SELECT_LEX *current_sel= thd->lex->current_select;
4356
        SELECT_LEX *last_select= table_ref->select_lex;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4357 4358
        /*
          If the field was an outer referencee, mark all selects using this
4359
          sub query as dependent on the outer query
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4360
        */
4361
        if (current_sel != last_select)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4362
          mark_select_range_as_dependent(thd, last_select, current_sel,
4363 4364
                                         found, *ref, item);
      }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4365 4366 4367 4368
      return found;
    }
  }

4369 4370 4371
  if (db && lower_case_table_names)
  {
    /*
timour@mysql.com's avatar
timour@mysql.com committed
4372
      convert database to lower case for comparison.
4373 4374 4375 4376
      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
4377
    my_casedn_str(files_charset_info, name_buff);
4378 4379
    db= name_buff;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4380

4381 4382 4383 4384 4385
  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
4386
  {
4387 4388
    Field *cur_field= find_field_in_table_ref(thd, cur_table, name, length,
                                              item->name, db, table_name, ref,
4389
                                              check_privileges, allow_rowid,
4390 4391 4392 4393
                                              &(item->cached_field_index),
                                              register_tree_change,
                                              &actual_table);
    if (cur_field)
4394
    {
4395
      if (cur_field == WRONG_GRANT)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4396
	return (Field*) 0;
4397 4398 4399 4400 4401 4402 4403 4404

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

4405 4406 4407 4408 4409
      DBUG_ASSERT(thd->where);
      /*
        If we found a fully qualified field we return it directly as it can't
        have duplicates.
       */
4410
      if (db)
4411 4412
        return cur_field;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4413 4414
      if (found)
      {
4415 4416
        if (report_error == REPORT_ALL_ERRORS ||
            report_error == IGNORE_EXCEPT_NON_UNIQUE)
4417
          my_error(ER_NON_UNIQ_ERROR, MYF(0),
4418
                   table_name ? item->full_name() : name, thd->where);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4419 4420
	return (Field*) 0;
      }
4421
      found= cur_field;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4422 4423
    }
  }
4424

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4425 4426
  if (found)
    return found;
4427 4428 4429 4430 4431 4432 4433 4434

  /*
    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.
  */
4435
  if (table_name && (cur_table == first_table) &&
4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446
      (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);
  }
4447
  else
4448
  {
4449 4450 4451 4452 4453
    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;
4454
  }
4455
  return found;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4456 4457
}

4458 4459 4460

/*
  Find Item in list of items (find_field_in_tables analog)
4461 4462 4463 4464

  TODO
    is it better return only counter?

4465 4466
  SYNOPSIS
    find_item_in_list()
4467 4468 4469
    find			Item to find
    items			List of items
    counter			To return number of found item
4470
    report_error
4471 4472 4473 4474 4475
      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
4476 4477 4478 4479
    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.

4480
  RETURN VALUES
4481 4482 4483 4484 4485
    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
4486
                        found field
4487 4488
*/

4489
/* Special Item pointer to serve as a return value from find_item_in_list(). */
4490
Item **not_found_item= (Item**) 0x1;
4491 4492


bk@work.mysql.com's avatar
bk@work.mysql.com committed
4493
Item **
4494
find_item_in_list(Item *find, List<Item> &items, uint *counter,
4495
                  find_item_error_report_type report_error, bool *unaliased)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4496 4497
{
  List_iterator<Item> li(items);
4498
  Item **found=0, **found_unaliased= 0, *item;
4499
  const char *db_name=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4500 4501
  const char *field_name=0;
  const char *table_name=0;
4502
  bool found_unaliased_non_uniq= 0;
4503 4504 4505 4506 4507
  /*
    true if the item that we search for is a valid name reference
    (and not an item that happens to have a name).
  */
  bool is_ref_by_name= 0;
4508
  uint unaliased_counter;
4509

4510 4511
  LINT_INIT(unaliased_counter);                 // Dependent on found_unaliased

4512 4513
  *unaliased= FALSE;

4514 4515 4516
  is_ref_by_name= (find->type() == Item::FIELD_ITEM  || 
                   find->type() == Item::REF_ITEM);
  if (is_ref_by_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4517 4518 4519
  {
    field_name= ((Item_ident*) find)->field_name;
    table_name= ((Item_ident*) find)->table_name;
4520
    db_name=    ((Item_ident*) find)->db_name;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4521 4522
  }

4523
  for (uint i= 0; (item=li++); i++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4524
  {
4525
    if (field_name && item->real_item()->type() == Item::FIELD_ITEM)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4526
    {
4527
      Item_ident *item_field= (Item_ident*) item;
4528

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4529 4530 4531 4532 4533 4534
      /*
	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
      */ 
4535 4536 4537 4538
      if (!item_field->name)
        continue;

      if (table_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4539
      {
4540 4541 4542
        /*
          If table name is specified we should find field 'field_name' in
          table 'table_name'. According to SQL-standard we should ignore
4543 4544 4545 4546 4547
          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.
4548

4549
          We use strcmp for table names and database names as these may be
4550 4551
          case sensitive. In cases where they are not case sensitive, they
          are always in lower case.
4552 4553

	  item_field->field_name and item_field->table_name can be 0x0 if
4554
	  item is not fix_field()'ed yet.
4555
        */
4556 4557
        if (item_field->field_name && item_field->table_name &&
	    !my_strcasecmp(system_charset_info, item_field->field_name,
4558 4559 4560 4561 4562
                           field_name) &&
            !strcmp(item_field->table_name, table_name) &&
            (!db_name || (item_field->db_name &&
                          !strcmp(item_field->db_name, db_name))))
        {
4563
          if (found_unaliased)
4564
          {
4565 4566 4567 4568 4569 4570 4571
            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.
            */
4572
            if (report_error != IGNORE_ERRORS)
4573 4574
              my_error(ER_NON_UNIQ_ERROR, MYF(0),
                       find->full_name(), current_thd->where);
4575 4576
            return (Item**) 0;
          }
4577 4578
          found_unaliased= li.ref();
          unaliased_counter= i;
4579 4580
          if (db_name)
            break;                              // Perfect match
4581 4582 4583
        }
      }
      else if (!my_strcasecmp(system_charset_info, item_field->name,
4584
                              field_name))
4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597
      {
        /*
          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)
4598 4599
            my_error(ER_NON_UNIQ_ERROR, MYF(0),
                     find->full_name(), current_thd->where);
4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624
          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
4625 4626
      }
    }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4627
    else if (!table_name && (find->eq(item,0) ||
4628
			     is_ref_by_name && find->name && item->name &&
4629 4630
			     !my_strcasecmp(system_charset_info, 
					    item->name,find->name)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4631
    {
4632 4633
      found= li.ref();
      *counter= i;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4634 4635 4636
      break;
    }
  }
4637 4638 4639 4640 4641
  if (!found)
  {
    if (found_unaliased_non_uniq)
    {
      if (report_error != IGNORE_ERRORS)
4642 4643
        my_error(ER_NON_UNIQ_ERROR, MYF(0),
                 find->full_name(), current_thd->where);
4644 4645 4646 4647 4648 4649
      return (Item **) 0;
    }
    if (found_unaliased)
    {
      found= found_unaliased;
      *counter= unaliased_counter;
4650
      *unaliased= TRUE;
4651 4652
    }
  }
4653 4654
  if (found)
    return found;
4655
  if (report_error != REPORT_EXCEPT_NOT_FOUND)
4656 4657
  {
    if (report_error == REPORT_ALL_ERRORS)
4658 4659
      my_error(ER_BAD_FIELD_ERROR, MYF(0),
               find->full_name(), current_thd->where);
4660 4661 4662 4663
    return (Item **) 0;
  }
  else
    return (Item **) not_found_item;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4664 4665
}

4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693

/*
  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;
4694
    if (!my_strcasecmp(system_charset_info, find, curr_str->ptr()))
4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715
      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
4716 4717
    FALSE  if all OK
    TRUE   otherwise
4718 4719 4720 4721 4722 4723
*/

static bool
set_new_item_local_context(THD *thd, Item_ident *item, TABLE_LIST *table_ref)
{
  Name_resolution_context *context;
4724
  if (!(context= new (thd->mem_root) Name_resolution_context))
4725 4726
    return TRUE;
  context->init();
4727 4728
  context->first_name_resolution_table=
    context->last_name_resolution_table= table_ref;
4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760
  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
4761 4762
    TRUE   error when some common column is non-unique, or out of memory
    FALSE  OK
4763 4764 4765 4766 4767 4768 4769 4770 4771 4772
*/

static bool
mark_common_columns(THD *thd, TABLE_LIST *table_ref_1, TABLE_LIST *table_ref_2,
                    List<String> *using_fields, uint *found_using_fields)
{
  Field_iterator_table_ref it_1, it_2;
  Natural_join_column *nj_col_1, *nj_col_2;
  Query_arena *arena, backup;
  bool result= TRUE;
timour@mysql.com's avatar
timour@mysql.com committed
4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783
  bool first_outer_loop= TRUE;
  /*
    Leaf table references to which new natural join columns are added
    if the leaves are != NULL.
  */
  TABLE_LIST *leaf_1= (table_ref_1->nested_join &&
                       !table_ref_1->is_natural_join) ?
                      NULL : table_ref_1;
  TABLE_LIST *leaf_2= (table_ref_2->nested_join &&
                       !table_ref_2->is_natural_join) ?
                      NULL : table_ref_2;
4784 4785

  DBUG_ENTER("mark_common_columns");
4786
  DBUG_PRINT("info", ("operand_1: %s  operand_2: %s",
4787 4788
                      table_ref_1->alias, table_ref_2->alias));

4789
  *found_using_fields= 0;
konstantin@mysql.com's avatar
konstantin@mysql.com committed
4790
  arena= thd->activate_stmt_arena_if_needed(&backup);
4791 4792 4793

  for (it_1.set(table_ref_1); !it_1.end_of_fields(); it_1.next())
  {
4794
    bool found= FALSE;
konstantin@mysql.com's avatar
konstantin@mysql.com committed
4795
    const char *field_name_1;
4796 4797
    /* true if field_name_1 is a member of using_fields */
    bool is_using_column_1;
timour@mysql.com's avatar
timour@mysql.com committed
4798
    if (!(nj_col_1= it_1.get_or_create_column_ref(leaf_1)))
4799 4800
      goto err;
    field_name_1= nj_col_1->name();
4801 4802 4803 4804 4805
    is_using_column_1= using_fields && 
      test_if_string_in_list(field_name_1, using_fields);
    DBUG_PRINT ("info", ("field_name_1=%s.%s", 
                         nj_col_1->table_name() ? nj_col_1->table_name() : "", 
                         field_name_1));
4806

4807 4808 4809 4810 4811 4812 4813
    /*
      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.
    */
4814 4815 4816 4817
    nj_col_2= NULL;
    for (it_2.set(table_ref_2); !it_2.end_of_fields(); it_2.next())
    {
      Natural_join_column *cur_nj_col_2;
4818
      const char *cur_field_name_2;
timour@mysql.com's avatar
timour@mysql.com committed
4819
      if (!(cur_nj_col_2= it_2.get_or_create_column_ref(leaf_2)))
4820
        goto err;
4821
      cur_field_name_2= cur_nj_col_2->name();
4822 4823 4824 4825
      DBUG_PRINT ("info", ("cur_field_name_2=%s.%s", 
                           cur_nj_col_2->table_name() ? 
                             cur_nj_col_2->table_name() : "", 
                           cur_field_name_2));
4826

timour@mysql.com's avatar
timour@mysql.com committed
4827 4828 4829 4830 4831 4832
      /*
        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).
4833 4834 4835 4836
        Note that it is too early to check the columns outside of the
        USING list for ambiguity because they are not actually "referenced"
        here. These columns must be checked only on unqualified reference 
        by name (e.g. in SELECT list).
timour@mysql.com's avatar
timour@mysql.com committed
4837
      */
4838 4839
      if (!my_strcasecmp(system_charset_info, field_name_1, cur_field_name_2))
      {
4840 4841 4842
        DBUG_PRINT ("info", ("match c1.is_common=%d", nj_col_1->is_common));
        if (cur_nj_col_2->is_common ||
            (found && (!using_fields || is_using_column_1)))
4843 4844 4845 4846 4847 4848 4849 4850
        {
          my_error(ER_NON_UNIQ_ERROR, MYF(0), field_name_1, thd->where);
          goto err;
        }
        nj_col_2= cur_nj_col_2;
        found= TRUE;
      }
    }
timour@mysql.com's avatar
timour@mysql.com committed
4851 4852 4853 4854 4855 4856 4857 4858 4859
    if (first_outer_loop && leaf_2)
    {
      /*
        Make sure that the next inner loop "knows" that all columns
        are materialized already.
      */
      leaf_2->is_join_columns_complete= TRUE;
      first_outer_loop= FALSE;
    }
4860
    if (!found)
4861
      continue;                                 // No matching field
4862 4863 4864 4865 4866 4867

    /*
      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.
    */
4868
    if (nj_col_2 && (!using_fields ||is_using_column_1))
4869 4870 4871 4872 4873 4874
    {
      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;
4875 4876 4877 4878 4879
      Item_func_eq *eq_cond;

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

4880
      /*
4881
        The following assert checks that the two created items are of
4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905
        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.
      */
4906 4907
      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))
4908 4909
        goto err;

4910 4911
      if (!(eq_cond= new Item_func_eq(item_ident_1, item_ident_2)))
        goto err;                               /* Out of memory. */
4912 4913 4914 4915 4916 4917

      /*
        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.
       */
4918 4919 4920
      add_join_on((table_ref_1->outer_join & JOIN_TYPE_RIGHT ?
                   table_ref_1 : table_ref_2),
                  eq_cond);
4921 4922

      nj_col_1->is_common= nj_col_2->is_common= TRUE;
4923 4924 4925 4926 4927 4928 4929
      DBUG_PRINT ("info", ("%s.%s and %s.%s are common", 
                           nj_col_1->table_name() ? 
                             nj_col_1->table_name() : "", 
                           nj_col_1->name(),
                           nj_col_2->table_name() ? 
                             nj_col_2->table_name() : "", 
                           nj_col_2->name()));
4930 4931 4932

      if (field_1)
      {
4933
        TABLE *table_1= nj_col_1->table_ref->table;
4934
        /* Mark field_1 used for table cache. */
4935
        bitmap_set_bit(table_1->read_set, field_1->field_index);
4936
        table_1->used_keys.intersect(field_1->part_of_key);
4937
        table_1->merge_keys.merge(field_1->part_of_key);
4938 4939 4940
      }
      if (field_2)
      {
4941
        TABLE *table_2= nj_col_2->table_ref->table;
4942
        /* Mark field_2 used for table cache. */
4943
        bitmap_set_bit(table_2->read_set, field_2->field_index);
4944
        table_2->used_keys.intersect(field_2->part_of_key);
4945
        table_2->merge_keys.merge(field_2->part_of_key);
4946 4947 4948 4949 4950 4951
      }

      if (using_fields != NULL)
        ++(*found_using_fields);
    }
  }
timour@mysql.com's avatar
timour@mysql.com committed
4952 4953
  if (leaf_1)
    leaf_1->is_join_columns_complete= TRUE;
4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965

  /*
    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
4966
    thd->restore_active_arena(arena, &backup);
4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002
  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
5003 5004
    TRUE    error: Some common column is ambiguous
    FALSE   OK
5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017
*/

static bool
store_natural_using_join_columns(THD *thd, TABLE_LIST *natural_using_join,
                                 TABLE_LIST *table_ref_1,
                                 TABLE_LIST *table_ref_2,
                                 List<String> *using_fields,
                                 uint found_using_fields)
{
  Field_iterator_table_ref it_1, it_2;
  Natural_join_column *nj_col_1, *nj_col_2;
  Query_arena *arena, backup;
  bool result= TRUE;
5018
  List<Natural_join_column> *non_join_columns;
5019 5020
  DBUG_ENTER("store_natural_using_join_columns");

5021 5022
  DBUG_ASSERT(!natural_using_join->join_columns);

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

5025 5026
  if (!(non_join_columns= new List<Natural_join_column>) ||
      !(natural_using_join->join_columns= new List<Natural_join_column>))
5027 5028 5029 5030 5031
    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())
  {
5032
    nj_col_1= it_1.get_natural_column_ref();
5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053
    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++))
    {
5054
      const char *using_field_name_ptr= using_field_name->c_ptr();
5055 5056 5057
      List_iterator_fast<Natural_join_column>
        it(*(natural_using_join->join_columns));
      Natural_join_column *common_field;
5058 5059

      for (;;)
5060
      {
5061 5062 5063 5064 5065 5066 5067
        /* 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;
        }
5068 5069
        if (!my_strcasecmp(system_charset_info,
                           common_field->name(), using_field_name_ptr))
5070
          break;                                // Found match
5071 5072 5073 5074 5075 5076 5077
      }
    }
  }

  /* 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())
  {
5078
    nj_col_2= it_2.get_natural_column_ref();
5079 5080 5081
    if (!nj_col_2->is_common)
      non_join_columns->push_back(nj_col_2);
    else
5082
    {
5083 5084
      /* Reset the common columns for the next call to mark_common_columns. */
      nj_col_2->is_common= FALSE;
5085
    }
5086 5087 5088 5089 5090 5091 5092 5093 5094 5095
  }

  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
5096
    thd->restore_active_arena(arena, &backup);
5097 5098 5099
  DBUG_RETURN(result);
}

5100

5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126
/*
  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
5127 5128
    TRUE   Error
    FALSE  OK
5129 5130 5131 5132 5133 5134 5135
*/

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
5136 5137 5138
  Query_arena *arena, backup;
  bool result= TRUE;

5139
  DBUG_ENTER("store_top_level_join_columns");
5140

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

5143 5144 5145 5146
  /* Call the procedure recursively for each nested table reference. */
  if (table_ref->nested_join)
  {
    List_iterator_fast<TABLE_LIST> nested_it(table_ref->nested_join->join_list);
timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
5147 5148 5149 5150
    TABLE_LIST *same_level_left_neighbor= nested_it++;
    TABLE_LIST *same_level_right_neighbor= NULL;
    /* Left/right-most neighbors, possibly at higher levels in the join tree. */
    TABLE_LIST *real_left_neighbor, *real_right_neighbor;
5151

timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
5152
    while (same_level_left_neighbor)
5153
    {
timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
5154 5155
      TABLE_LIST *cur_table_ref= same_level_left_neighbor;
      same_level_left_neighbor= nested_it++;
5156 5157 5158 5159
      /*
        The order of RIGHT JOIN operands is reversed in 'join list' to
        transform it into a LEFT JOIN. However, in this procedure we need
        the join operands in their lexical order, so below we reverse the
timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
5160 5161 5162 5163 5164
        join operands. Notice that this happens only in the first loop,
        and not in the second one, as in the second loop
        same_level_left_neighbor == NULL.
        This is the correct behavior, because the second loop sets
        cur_table_ref reference correctly after the join operands are
5165 5166
        swapped in the first loop.
      */
timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
5167
      if (same_level_left_neighbor &&
5168 5169 5170 5171
          cur_table_ref->outer_join & JOIN_TYPE_RIGHT)
      {
        /* This can happen only for JOIN ... ON. */
        DBUG_ASSERT(table_ref->nested_join->join_list.elements == 2);
timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
5172
        swap_variables(TABLE_LIST*, same_level_left_neighbor, cur_table_ref);
5173 5174
      }

timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
5175 5176 5177 5178 5179 5180 5181 5182 5183
      /*
        Pick the parent's left and right neighbors if there are no immediate
        neighbors at the same level.
      */
      real_left_neighbor=  (same_level_left_neighbor) ?
                           same_level_left_neighbor : left_neighbor;
      real_right_neighbor= (same_level_right_neighbor) ?
                           same_level_right_neighbor : right_neighbor;

5184 5185
      if (cur_table_ref->nested_join &&
          store_top_level_join_columns(thd, cur_table_ref,
timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
5186
                                       real_left_neighbor, real_right_neighbor))
timour@mysql.com's avatar
timour@mysql.com committed
5187
        goto err;
timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
5188
      same_level_right_neighbor= cur_table_ref;
5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218
    }
  }

  /*
    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
5219
      goto err;
5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230

    /*
      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
5231
      goto err;
5232 5233 5234 5235 5236 5237 5238 5239 5240

    /*
      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
5241 5242 5243 5244 5245
    /* 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. */

5246 5247 5248
    /* Change this table reference to become a leaf for name resolution. */
    if (left_neighbor)
    {
5249
      TABLE_LIST *last_leaf_on_the_left;
5250 5251 5252 5253 5254
      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)
    {
5255
      TABLE_LIST *first_leaf_on_the_right;
5256 5257 5258 5259 5260 5261
      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
5262 5263 5264 5265
  result= FALSE; /* All is OK. */

err:
  if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
5266
    thd->restore_active_arena(arena, &backup);
timour@mysql.com's avatar
timour@mysql.com committed
5267
  DBUG_RETURN(result);
5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291
}


/*
  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
5292 5293
    TRUE   Error
    FALSE  OK
5294
*/
5295 5296
static bool setup_natural_join_row_types(THD *thd,
                                         List<TABLE_LIST> *from_clause,
5297 5298 5299 5300 5301 5302 5303 5304 5305
                                         Name_resolution_context *context)
{
  thd->where= "from clause";
  if (from_clause->elements == 0)
    return FALSE; /* We come here in the case of UNIONs. */

  List_iterator_fast<TABLE_LIST> table_ref_it(*from_clause);
  TABLE_LIST *table_ref; /* Current table reference. */
  /* Table reference to the left of the current. */
5306
  TABLE_LIST *left_neighbor;
5307 5308 5309
  /* Table reference to the right of the current. */
  TABLE_LIST *right_neighbor= NULL;

5310 5311
  /* Note that tables in the list are in reversed order */
  for (left_neighbor= table_ref_it++; left_neighbor ; )
5312 5313 5314
  {
    table_ref= left_neighbor;
    left_neighbor= table_ref_it++;
5315 5316
    /* For stored procedures do not redo work if already done. */
    if (context->select_lex->first_execution)
5317
    {
5318 5319 5320 5321 5322 5323 5324 5325 5326
      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;
      }
5327 5328 5329 5330 5331 5332 5333
    }
    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
5334
    right_neighbor points to the left-most top-level table reference in the
5335 5336 5337 5338 5339 5340 5341 5342 5343 5344
    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
5345
/****************************************************************************
5346
** Expand all '*' in given fields
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5347 5348
****************************************************************************/

5349 5350 5351
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
5352
{
5353
  if (!wild_num)
5354
    return(0);
5355

5356
  Item *item;
5357
  List_iterator<Item> it(fields);
serg@serg.mylan's avatar
serg@serg.mylan committed
5358
  Query_arena *arena, backup;
5359
  DBUG_ENTER("setup_wild");
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5360 5361

  /*
5362 5363
    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
5364
  */
konstantin@mysql.com's avatar
konstantin@mysql.com committed
5365
  arena= thd->activate_stmt_arena_if_needed(&backup);
5366

monty@mysql.com's avatar
monty@mysql.com committed
5367
  while (wild_num && (item= it++))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5368
  {
5369 5370
    if (item->type() == Item::FIELD_ITEM &&
        ((Item_field*) item)->field_name &&
5371 5372
	((Item_field*) item)->field_name[0] == '*' &&
	!((Item_field*) item)->field)
5373
    {
5374
      uint elem= fields.elements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5375
      bool any_privileges= ((Item_field *) item)->any_privileges;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386
      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));
      }
5387 5388
      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
5389
                             ((Item_field*) item)->table_name, &it,
5390
                             any_privileges))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5391 5392
      {
	if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
5393
	  thd->restore_active_arena(arena, &backup);
5394
	DBUG_RETURN(-1);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5395
      }
5396
      if (sum_func_list)
5397 5398 5399 5400 5401 5402 5403 5404
      {
	/*
	  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;
      }
5405
      wild_num--;
5406 5407
    }
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5408 5409 5410 5411 5412 5413 5414
  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
5415
    thd->restore_active_arena(arena, &backup);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5416
  }
5417
  DBUG_RETURN(0);
5418 5419
}

5420 5421 5422 5423
/****************************************************************************
** Check that all given fields exists and fill struct with current data
****************************************************************************/

5424
bool setup_fields(THD *thd, Item **ref_pointer_array,
5425
                  List<Item> &fields, enum_mark_columns mark_used_columns,
5426
                  List<Item> *sum_func_list, bool allow_sum_func)
5427 5428
{
  reg2 Item *item;
5429
  enum_mark_columns save_mark_used_columns= thd->mark_used_columns;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5430
  nesting_map save_allow_sum_func= thd->lex->allow_sum_func;
5431 5432 5433
  List_iterator<Item> it(fields);
  DBUG_ENTER("setup_fields");

5434 5435
  thd->mark_used_columns= mark_used_columns;
  DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5436 5437
  if (allow_sum_func)
    thd->lex->allow_sum_func|= 1 << thd->lex->current_select->nest_level;
5438
  thd->where= THD::DEFAULT_WHERE;
5439

5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453
  /*
    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);

5454
  Item **ref= ref_pointer_array;
5455
  thd->lex->current_select->cur_pos_in_select_list= 0;
5456
  while ((item= it++))
5457
  {
5458
    if (!item->fixed && item->fix_fields(thd, it.ref()) ||
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5459
	(item= *(it.ref()))->check_cols(1))
5460
    {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5461
      thd->lex->allow_sum_func= save_allow_sum_func;
5462 5463
      thd->mark_used_columns= save_mark_used_columns;
      DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
5464
      DBUG_RETURN(TRUE); /* purecov: inspected */
5465
    }
5466 5467
    if (ref)
      *(ref++)= item;
5468 5469
    if (item->with_sum_func && item->type() != Item::SUM_FUNC_ITEM &&
	sum_func_list)
5470
      item->split_sum_func(thd, ref_pointer_array, *sum_func_list);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5471
    thd->used_tables|= item->used_tables();
5472
    thd->lex->current_select->cur_pos_in_select_list++;
5473
  }
5474 5475
  thd->lex->current_select->cur_pos_in_select_list= UNDEF_POS;

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5476
  thd->lex->allow_sum_func= save_allow_sum_func;
5477 5478
  thd->mark_used_columns= save_mark_used_columns;
  DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
5479
  DBUG_RETURN(test(thd->net.report_error));
5480
}
5481

5482

5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497
/*
  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)
  {
5498 5499 5500 5501 5502 5503
    if (table->merge_underlying_list)
    {
      DBUG_ASSERT(table->view &&
                  table->effective_algorithm == VIEW_ALGORITHM_MERGE);
      list= make_leaves_list(list, table->merge_underlying_list);
    }
5504 5505 5506 5507 5508 5509 5510 5511 5512
    else
    {
      *list= table;
      list= &table->next_leaf;
    }
  }
  return list;
}

5513
/*
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5514 5515 5516 5517
  prepare tables

  SYNOPSIS
    setup_tables()
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5518
    thd		  Thread handler
5519
    context       name resolution contest to setup table list there
5520 5521 5522
    from_clause   Top-level list of table references in the FROM clause
    tables	  Table list (select_lex->table_list)
    leaves        List of join table leaves list (select_lex->leaf_tables)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5523 5524
    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
5525

monty@mysql.com's avatar
monty@mysql.com committed
5526 5527
  NOTE
    Check also that the 'used keys' and 'ignored keys' exists and set up the
5528 5529 5530 5531
    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.
5532

monty@mysql.com's avatar
monty@mysql.com committed
5533 5534
    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
5535

monty@mysql.com's avatar
monty@mysql.com committed
5536
  RETURN
5537
    FALSE ok;  In this case *map will includes the chosen index
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5538
    TRUE  error
5539 5540
*/

5541
bool setup_tables(THD *thd, Name_resolution_context *context,
5542
                  List<TABLE_LIST> *from_clause, TABLE_LIST *tables,
5543
                  TABLE_LIST **leaves, bool select_insert)
5544
{
monty@mysql.com's avatar
monty@mysql.com committed
5545
  uint tablenr= 0;
5546
  DBUG_ENTER("setup_tables");
5547

5548 5549
  DBUG_ASSERT ((select_insert && !tables->next_name_resolution_table) || !tables || 
               (context->table_list && context->first_name_resolution_table));
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5550 5551
  /*
    this is used for INSERT ... SELECT.
5552
    For select we setup tables except first (and its underlying tables)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5553 5554 5555 5556
  */
  TABLE_LIST *first_select_table= (select_insert ?
                                   tables->next_local:
                                   0);
5557 5558 5559
  if (!(*leaves))
    make_leaves_list(leaves, tables);

5560 5561
  TABLE_LIST *table_list;
  for (table_list= *leaves;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5562
       table_list;
5563
       table_list= table_list->next_leaf, tablenr++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5564
  {
5565
    TABLE *table= table_list->table;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5566
    table->pos_in_table_list= table_list;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5567
    if (first_select_table &&
5568
        table_list->top_table() == first_select_table)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5569 5570 5571 5572 5573
    {
      /* new counting for SELECT of INSERT ... SELECT command */
      first_select_table= 0;
      tablenr= 0;
    }
5574
    setup_table_map(table, table_list, tablenr);
5575
    table->used_keys= table->s->keys_for_keyread;
5576
    table->merge_keys.clear_all();
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5577
    if (table_list->use_index)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5578
    {
5579 5580 5581
      key_map map;
      get_key_map_from_key_list(&map, table, table_list->use_index);
      if (map.is_set_all())
5582
	DBUG_RETURN(1);
5583 5584 5585 5586 5587 5588
      /* 
	 Don't introduce keys in keys_in_use_for_query that weren't there 
	 before. FORCE/USE INDEX should not add keys, it should only remove
	 all keys except the key(s) specified in the hint.
      */
      table->keys_in_use_for_query.intersect(map);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5589
    }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5590
    if (table_list->ignore_index)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5591
    {
5592 5593 5594
      key_map map;
      get_key_map_from_key_list(&map, table, table_list->ignore_index);
      if (map.is_set_all())
5595
	DBUG_RETURN(1);
5596
      table->keys_in_use_for_query.subtract(map);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5597
    }
5598
    table->used_keys.intersect(table->keys_in_use_for_query);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5599 5600 5601 5602
  }
  if (tablenr > MAX_TABLES)
  {
    my_error(ER_TOO_MANY_TABLES,MYF(0),MAX_TABLES);
5603
    DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5604
  }
5605
  for (table_list= tables;
5606 5607
       table_list;
       table_list= table_list->next_local)
5608
  {
5609
    if (table_list->merge_underlying_list)
5610
    {
5611 5612
      DBUG_ASSERT(table_list->view &&
                  table_list->effective_algorithm == VIEW_ALGORITHM_MERGE);
konstantin@mysql.com's avatar
konstantin@mysql.com committed
5613
      Query_arena *arena= thd->stmt_arena, backup;
5614 5615 5616 5617
      bool res;
      if (arena->is_conventional())
        arena= 0;                                   // For easier test
      else
konstantin@mysql.com's avatar
konstantin@mysql.com committed
5618
        thd->set_n_backup_active_arena(arena, &backup);
5619
      res= table_list->setup_underlying(thd);
5620
      if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
5621
        thd->restore_active_arena(arena, &backup);
5622 5623 5624
      if (res)
        DBUG_RETURN(1);
    }
5625
  }
5626 5627 5628 5629 5630

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

5631
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5632
}
5633

bk@work.mysql.com's avatar
bk@work.mysql.com committed
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
/*
  prepare tables and check access for the view tables

  SYNOPSIS
    setup_tables_and_check_view_access()
    thd		  Thread handler
    context       name resolution contest to setup table list there
    from_clause   Top-level list of table references in the FROM clause
    tables	  Table list (select_lex->table_list)
    conds	  Condition of current SELECT (can be changed by VIEW)
    leaves        List of join table leaves list (select_lex->leaf_tables)
    refresh       It is onle refresh for subquery
    select_insert It is SELECT ... INSERT command
    want_access   what access is needed

  NOTE
    a wrapper for check_tables that will also check the resulting
    table leaves list for access to all the tables that belong to a view

  RETURN
    FALSE ok;  In this case *map will include the chosen index
    TRUE  error
*/
bool setup_tables_and_check_access(THD *thd, 
                                   Name_resolution_context *context,
                                   List<TABLE_LIST> *from_clause,
                                   TABLE_LIST *tables,
monty@mysql.com's avatar
monty@mysql.com committed
5662
                                   TABLE_LIST **leaves,
5663
                                   bool select_insert,
5664
                                   ulong want_access_first,
5665 5666
                                   ulong want_access)
{
monty@mysql.com's avatar
monty@mysql.com committed
5667
  TABLE_LIST *leaves_tmp= NULL;
5668
  bool first_table= true;
5669

monty@mysql.com's avatar
monty@mysql.com committed
5670 5671
  if (setup_tables(thd, context, from_clause, tables,
                   &leaves_tmp, select_insert))
5672 5673
    return TRUE;

monty@mysql.com's avatar
monty@mysql.com committed
5674
  *leaves= leaves_tmp;
5675 5676

  for (; leaves_tmp; leaves_tmp= leaves_tmp->next_leaf)
monty@mysql.com's avatar
monty@mysql.com committed
5677
  {
5678
    if (leaves_tmp->belong_to_view && 
5679 5680
        check_single_table_access(thd, first_table ? want_access_first :
                                  want_access,  leaves_tmp))
5681 5682 5683 5684
    {
      tables->hide_view_error(thd);
      return TRUE;
    }
5685
    first_table= 0;
monty@mysql.com's avatar
monty@mysql.com committed
5686
  }
5687 5688 5689 5690
  return FALSE;
}


5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705
/*
   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,
5706
                               List<String> *index_list)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5707
{
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
5708
  List_iterator_fast<String> it(*index_list);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5709 5710
  String *name;
  uint pos;
5711 5712

  map->clear_all();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5713 5714
  while ((name=it++))
  {
5715 5716 5717
    if (table->s->keynames.type_names == 0 ||
        (pos= find_type(&table->s->keynames, name->ptr(),
                        name->length(), 1)) <=
5718
        0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5719
    {
5720
      my_error(ER_KEY_DOES_NOT_EXITS, MYF(0), name->c_ptr(),
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5721
	       table->pos_in_table_list->alias);
5722
      map->set_all();
5723
      return 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5724
    }
5725
    map->set_bit(pos-1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5726
  }
5727
  return 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5728 5729
}

5730

5731 5732 5733 5734 5735 5736
/*
  Drops in all fields instead of current '*' field

  SYNOPSIS
    insert_fields()
    thd			Thread handler
5737
    context             Context for name resolution
5738 5739 5740 5741 5742 5743 5744
    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
5745
    0	ok     'it' is updated to point at last inserted
monty@mysql.com's avatar
monty@mysql.com committed
5746
    1	error.  Error message is generated but not sent to client
5747
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5748

sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
5749
bool
5750
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
5751
	      const char *table_name, List_iterator<Item> *it,
5752
              bool any_privileges)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5753
{
5754 5755
  Field_iterator_table_ref field_iterator;
  bool found;
monty@mysql.com's avatar
monty@mysql.com committed
5756
  char name_buff[NAME_LEN+1];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5757
  DBUG_ENTER("insert_fields");
konstantin@mysql.com's avatar
konstantin@mysql.com committed
5758
  DBUG_PRINT("arena", ("stmt arena: 0x%lx", (ulong)thd->stmt_arena));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5759

5760 5761
  if (db_name && lower_case_table_names)
  {
monty@mysql.com's avatar
monty@mysql.com committed
5762 5763 5764 5765 5766
    /*
      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
5767
    strmake(name_buff, db_name, sizeof(name_buff)-1);
monty@mysql.com's avatar
monty@mysql.com committed
5768
    my_casedn_str(files_charset_info, name_buff);
monty@mysql.com's avatar
monty@mysql.com committed
5769
    db_name= name_buff;
5770 5771
  }

5772
  found= FALSE;
5773 5774 5775 5776 5777 5778 5779 5780

  /*
    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);
5781
       tables;
5782 5783 5784
       tables= (table_name ? tables->next_local :
                tables->next_name_resolution_table)
       )
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5785
  {
5786 5787 5788
    Field *field;
    TABLE *table= tables->table;

5789 5790
    DBUG_ASSERT(tables->is_leaf_for_name_resolution());

5791 5792 5793 5794
    if (table_name && my_strcasecmp(table_alias_charset, table_name,
                                    tables->alias) ||
        (db_name && strcmp(tables->db,db_name)))
      continue;
5795

hf@deer.(none)'s avatar
hf@deer.(none) committed
5796
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5797 5798 5799 5800 5801 5802 5803
    /* 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(),
5804 5805
                                  field_iterator.db_name(),
                                  field_iterator.table_name(),
5806 5807 5808
                                  &field_iterator))
        DBUG_RETURN(TRUE);
    }
hf@deer.(none)'s avatar
hf@deer.(none) committed
5809
#endif
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5810

5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833
    /*
      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)
5834
      {
5835
        found= TRUE;
5836
        it->replace(item); /* Replace '*' with the first found item. */
5837
      }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5838
      else
5839 5840 5841 5842 5843 5844 5845
        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,
5846 5847 5848
        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.
5849 5850
      */
      if (any_privileges)
5851
      {
5852 5853 5854 5855
        DBUG_ASSERT(tables->field_translation == NULL && table ||
                    tables->is_natural_join);
        DBUG_ASSERT(item->type() == Item::FIELD_ITEM);
        Item_field *fld= (Item_field*) item;
5856
        const char *field_table_name= field_iterator.table_name();
5857

5858 5859 5860 5861
        if (!tables->schema_table && 
            !(fld->have_privileges=
              (get_column_grant(thd, field_iterator.grant(),
                                field_iterator.db_name(),
5862
                                field_table_name, fld->field_name) &
5863 5864 5865
               VIEW_ANY_ACL)))
        {
          my_error(ER_COLUMNACCESS_DENIED_ERROR, MYF(0), "ANY",
5866 5867
                   thd->security_ctx->priv_user,
                   thd->security_ctx->host_or_ip,
5868
                   fld->field_name, field_table_name);
5869 5870
          DBUG_RETURN(TRUE);
        }
5871
      }
5872
#endif
5873

5874
      if ((field= field_iterator.field()))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5875
      {
5876 5877
        /* Mark fields as used to allow storage engine to optimze access */
        bitmap_set_bit(field->table->read_set, field->field_index);
5878
        if (table)
5879
        {
5880
          table->used_keys.intersect(field->part_of_key);
5881 5882
          table->merge_keys.merge(field->part_of_key);
        }
5883
        if (tables->is_natural_join)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5884
        {
5885 5886
          TABLE *field_table;
          /*
5887
            In this case we are sure that the column ref will not be created
5888
            because it was already created and stored with the natural join.
5889
          */
5890
          Natural_join_column *nj_col;
timour@mysql.com's avatar
timour@mysql.com committed
5891
          if (!(nj_col= field_iterator.get_natural_column_ref()))
5892
            DBUG_RETURN(TRUE);
timour@mysql.com's avatar
timour@mysql.com committed
5893
          DBUG_ASSERT(nj_col->table_field);
5894 5895
          field_table= nj_col->table_ref->table;
          if (field_table)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5896
          {
5897 5898
            thd->used_tables|= field_table->map;
            field_table->used_keys.intersect(field->part_of_key);
5899
            field_table->merge_keys.merge(field->part_of_key);
5900
            field_table->used_fields++;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5901
          }
5902
        }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5903
      }
5904 5905
      else
        thd->used_tables|= item->used_tables();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5906
    }
5907 5908 5909 5910 5911 5912 5913 5914
    /*
      In case of stored tables, all fields are considered as used,
      while in the case of views, the fields considered as used are the
      ones marked in setup_tables during fix_fields of view columns.
      For NATURAL joins, used_tables is updated in the IF above.
    */
    if (table)
      table->used_fields= table->s->fields;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5915
  }
5916
  if (found)
5917
    DBUG_RETURN(FALSE);
5918

5919
  /*
5920 5921 5922
    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.
5923
  */
5924
  if (!table_name)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5925
    my_message(ER_NO_TABLES_USED, ER(ER_NO_TABLES_USED), MYF(0));
5926 5927
  else
    my_error(ER_BAD_TABLE_ERROR, MYF(0), table_name);
5928 5929

  DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5930 5931 5932 5933
}


/*
5934
  Fix all conditions and outer join expressions.
5935 5936 5937 5938

  SYNOPSIS
    setup_conds()
    thd     thread handler
5939 5940 5941 5942 5943 5944 5945 5946 5947 5948
    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
5949 5950
*/

5951 5952
int setup_conds(THD *thd, TABLE_LIST *tables, TABLE_LIST *leaves,
                COND **conds)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5953
{
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5954
  SELECT_LEX *select_lex= thd->lex->current_select;
konstantin@mysql.com's avatar
konstantin@mysql.com committed
5955
  Query_arena *arena= thd->stmt_arena, backup;
pem@mysql.comhem.se's avatar
pem@mysql.comhem.se committed
5956
  TABLE_LIST *table= NULL;	// For HP compilers
5957 5958 5959 5960 5961 5962 5963 5964 5965 5966
  /*
    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
5967
  DBUG_ENTER("setup_conds");
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5968

monty@mysql.com's avatar
monty@mysql.com committed
5969
  if (select_lex->conds_processed_with_permanent_arena ||
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5970
      arena->is_conventional())
monty@mysql.com's avatar
monty@mysql.com committed
5971 5972
    arena= 0;                                   // For easier test

5973 5974
  thd->mark_used_columns= MARK_COLUMNS_READ;
  DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5975
  select_lex->cond_count= 0;
5976
  select_lex->between_count= 0;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5977

5978 5979 5980 5981 5982 5983
  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
5984 5985 5986
  if (*conds)
  {
    thd->where="where clause";
5987
    if (!(*conds)->fixed && (*conds)->fix_fields(thd, conds) ||
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5988
	(*conds)->check_cols(1))
5989
      goto err_no_arena;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5990 5991
  }

5992 5993 5994 5995
  /*
    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
5996
  for (table= leaves; table; table= table->next_leaf)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5997
  {
5998 5999
    TABLE_LIST *embedded; /* The table at the current level of nesting. */
    TABLE_LIST *embedding= table; /* The parent nested table reference. */
6000
    do
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6001
    {
6002 6003
      embedded= embedding;
      if (embedded->on_expr)
6004
      {
6005 6006
        /* Make a join an a expression */
        thd->where="on clause";
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6007
        if (!embedded->on_expr->fixed &&
6008
            embedded->on_expr->fix_fields(thd, &embedded->on_expr) ||
6009
	    embedded->on_expr->check_cols(1))
6010
	  goto err_no_arena;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6011
        select_lex->cond_count++;
6012
      }
6013
      embedding= embedded->embedding;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6014
    }
6015 6016
    while (embedding &&
           embedding->nested_join->join_list.head() == embedded);
6017 6018 6019 6020

    /* process CHECK OPTION */
    if (it_is_update)
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6021
      TABLE_LIST *view= table->top_table();
6022 6023 6024 6025 6026 6027 6028
      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
6029
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6030

konstantin@mysql.com's avatar
konstantin@mysql.com committed
6031
  if (!thd->stmt_arena->is_conventional())
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6032 6033 6034 6035 6036 6037 6038 6039 6040 6041
  {
    /*
      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;
  }
6042
  DBUG_RETURN(test(thd->net.report_error));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6043

6044
err_no_arena:
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6045
  DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6046 6047 6048 6049 6050 6051 6052 6053
}


/******************************************************************************
** 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
6054 6055 6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069

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

6070
static bool
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6071 6072
fill_record(THD * thd, List<Item> &fields, List<Item> &values,
            bool ignore_errors)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6073
{
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
6074
  List_iterator_fast<Item> f(fields),v(values);
6075
  Item *value, *fld;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6076 6077 6078
  Item_field *field;
  DBUG_ENTER("fill_record");

6079
  while ((fld= f++))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6080
  {
6081 6082 6083 6084 6085
    if (!(field= fld->filed_for_view_update()))
    {
      my_error(ER_NONUPDATEABLE_COLUMN, MYF(0), fld->name);
      DBUG_RETURN(TRUE);
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6086
    value=v++;
6087 6088
    Field *rfield= field->field;
    TABLE *table= rfield->table;
6089
    if (rfield == table->next_number_field)
6090
      table->auto_increment_field_not_null= TRUE;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6091
    if ((value->save_in_field(rfield, 0) < 0) && !ignore_errors)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6092 6093 6094 6095
    {
      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
6096
  }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6097
  DBUG_RETURN(thd->net.report_error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
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
/*
  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
6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152
/*
  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
6153
{
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
6154
  List_iterator_fast<Item> v(values);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6155 6156 6157 6158 6159 6160 6161
  Item *value;
  DBUG_ENTER("fill_record");

  Field *field;
  while ((field = *ptr++))
  {
    value=v++;
6162
    TABLE *table= field->table;
6163
    if (field == table->next_number_field)
6164
      table->auto_increment_field_not_null= TRUE;
6165
    if (value->save_in_field(field, 0) == -1)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6166
      DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6167
  }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6168
  DBUG_RETURN(thd->net.report_error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
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
/*
  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));
}


6207
my_bool mysql_rm_tmp_tables(void)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6208
{
6209
  uint i, idx;
6210
  char	filePath[FN_REFLEN], *tmpdir, filePathCopy[FN_REFLEN];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6211 6212
  MY_DIR *dirp;
  FILEINFO *file;
6213
  TABLE_SHARE share;
6214
  THD *thd;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6215 6216
  DBUG_ENTER("mysql_rm_tmp_tables");

6217 6218
  if (!(thd= new THD))
    DBUG_RETURN(1);
6219
  thd->thread_stack= (char*) &thd;
6220 6221
  thd->store_globals();

6222 6223 6224
  for (i=0; i<=mysql_tmpdir_list.max; i++)
  {
    tmpdir=mysql_tmpdir_list.list[i];
6225
    /* See if the directory exists */
6226 6227
    if (!(dirp = my_dir(tmpdir,MYF(MY_WME | MY_DONT_SORT))))
      continue;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6228

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

6231 6232 6233
    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
6234

6235 6236 6237 6238
      /* 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
6239

6240
      if (!bcmp(file->name,tmp_file_prefix,tmp_file_prefix_length))
6241
      {
6242 6243 6244 6245 6246 6247
        char *ext= fn_ext(file->name);
        uint ext_len= strlen(ext);
        uint filePath_len= my_snprintf(filePath, sizeof(filePath),
                                       "%s%c%s", tmpdir, FN_LIBCHAR,
                                       file->name);
        if (!bcmp(reg_ext, ext, ext_len))
6248
        {
6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261
          handler *handler_file= 0;
          /* We should cut file extention before deleting of table */
          memcpy(filePathCopy, filePath, filePath_len - ext_len);
          filePathCopy[filePath_len - ext_len]= 0;
          init_tmp_table_share(&share, "", 0, "", filePathCopy);
          if (!open_table_def(thd, &share, 0) &&
              ((handler_file= get_new_handler(&share, thd->mem_root,
                                              share.db_type))))
          {
            handler_file->delete_table(filePathCopy);
            delete handler_file;
          }
          free_table_share(&share);
6262
        }
6263 6264 6265 6266 6267 6268
        /*
          File can be already deleted by tmp_table.file->delete_table().
          So we hide error messages which happnes during deleting of these
          files(MYF(0)).
        */
        VOID(my_delete(filePath, MYF(0))); 
6269
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6270
    }
6271
    my_dirend(dirp);
6272
  }
6273 6274 6275
  delete thd;
  my_pthread_setspecific_ptr(THR_THD,  0);
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6276 6277 6278 6279 6280 6281 6282 6283 6284
}



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

/*
6285 6286 6287 6288 6289 6290 6291 6292 6293 6294
  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
6295 6296
*/

6297
void remove_db_from_cache(const char *db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6298 6299 6300 6301
{
  for (uint idx=0 ; idx < open_cache.records ; idx++)
  {
    TABLE *table=(TABLE*) hash_element(&open_cache,idx);
6302
    if (!strcmp(table->s->db.str, db))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6303
    {
6304
      table->s->version= 0L;			/* Free when thread is ready */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6305 6306 6307 6308
      if (!table->in_use)
	relink_unused(table);
    }
  }
6309
  while (unused_tables && !unused_tables->s->version)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6310 6311 6312 6313 6314
    VOID(hash_delete(&open_cache,(byte*) unused_tables));
}


/*
6315 6316 6317 6318 6319
  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
6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331
*/

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


/*
6332 6333 6334 6335 6336
  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
6337 6338 6339
  PREREQUISITES
    Lock on LOCK_open()

6340 6341 6342 6343
  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
6344 6345
*/

6346
bool remove_table_from_cache(THD *thd, const char *db, const char *table_name,
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
6347
                             uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6348 6349 6350 6351
{
  char key[MAX_DBKEY_LENGTH];
  uint key_length;
  TABLE *table;
6352 6353
  TABLE_SHARE *share;
  bool result= 0, signalled= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6354
  DBUG_ENTER("remove_table_from_cache");
monty@mysql.com's avatar
monty@mysql.com committed
6355
  DBUG_PRINT("enter", ("Table: '%s.%s'  flags: %u", db, table_name, flags));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6356 6357

  key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
6358
  for (;;)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6359
  {
6360
    HASH_SEARCH_STATE state;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
6361 6362
    result= signalled= 0;

6363 6364
    for (table= (TABLE*) hash_first(&open_cache, (byte*) key, key_length,
                                    &state);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
6365
         table;
6366 6367
         table= (TABLE*) hash_next(&open_cache, (byte*) key, key_length,
                                   &state))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6368
    {
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
6369
      THD *in_use;
6370

6371
      table->s->version=0L;		/* Free when thread is ready */
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
6372
      if (!(in_use=table->in_use))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6373
      {
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
6374 6375
        DBUG_PRINT("info",("Table was not in use"));
        relink_unused(table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6376
      }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
6377
      else if (in_use != thd)
6378
      {
6379
        DBUG_PRINT("info", ("Table was in use by other thread"));
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
6380 6381
        in_use->some_tables_deleted=1;
        if (table->db_stat)
monty@mysql.com's avatar
monty@mysql.com committed
6382 6383
        {
          DBUG_PRINT("info", ("Found another active instance of the table"));
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
6384
  	  result=1;
monty@mysql.com's avatar
monty@mysql.com committed
6385
        }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
6386 6387 6388 6389
        /* Kill delayed insert threads */
        if ((in_use->system_thread & SYSTEM_THREAD_DELAYED_INSERT) &&
            ! in_use->killed)
        {
6390
	  in_use->killed= THD::KILL_CONNECTION;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
6391 6392 6393 6394 6395 6396 6397 6398 6399 6400 6401 6402 6403 6404 6405 6406 6407 6408 6409
	  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
6410
	    signalled|= mysql_lock_abort_for_thread(thd, thd_table);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
6411
        }
6412
      }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
6413
      else
6414 6415 6416
      {
        DBUG_PRINT("info", ("Table was in use by current thread. db_stat: %u",
                            table->db_stat));
6417
        result= result || (flags & RTFC_OWNED_BY_THD_FLAG);
6418
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6419
    }
6420
    while (unused_tables && !unused_tables->s->version)
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
6421
      VOID(hash_delete(&open_cache,(byte*) unused_tables));
6422 6423 6424 6425 6426 6427 6428 6429 6430 6431 6432 6433 6434 6435 6436 6437

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

6438
    if (result && (flags & RTFC_WAIT_OTHER_THREAD_FLAG))
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
6439
    {
monty@mysql.com's avatar
monty@mysql.com committed
6440 6441 6442 6443
      /*
        Signal any thread waiting for tables to be freed to
        reopen their tables
      */
6444
      broadcast_refresh();
monty@mysql.com's avatar
monty@mysql.com committed
6445
      DBUG_PRINT("info", ("Waiting for refresh signal"));
6446
      if (!(flags & RTFC_CHECK_KILLED_FLAG) || !thd->killed)
6447
      {
monty@mysql.com's avatar
monty@mysql.com committed
6448
        dropping_tables++;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
6449 6450 6451 6452
        if (likely(signalled))
          (void) pthread_cond_wait(&COND_refresh, &LOCK_open);
        else
        {
monty@mysql.com's avatar
monty@mysql.com committed
6453
          struct timespec abstime;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
6454 6455 6456 6457 6458 6459 6460 6461 6462 6463
          /*
            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
6464 6465
          set_timespec(abstime, 10);
          pthread_cond_timedwait(&COND_refresh, &LOCK_open, &abstime);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
6466
        }
monty@mysql.com's avatar
monty@mysql.com committed
6467 6468
        dropping_tables--;
        continue;
6469
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6470
    }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
6471
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6472 6473 6474 6475
  }
  DBUG_RETURN(result);
}

6476

6477
int setup_ftfuncs(SELECT_LEX *select_lex)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6478
{
6479 6480
  List_iterator<Item_func_match> li(*(select_lex->ftfunc_list)),
                                 lj(*(select_lex->ftfunc_list));
6481
  Item_func_match *ftf, *ftf2;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6482 6483

  while ((ftf=li++))
6484
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6485 6486
    if (ftf->fix_index())
      return 1;
6487 6488
    lj.rewind();
    while ((ftf2=lj++) != ftf)
6489
    {
6490
      if (ftf->eq(ftf2,1) && !ftf2->master)
6491 6492 6493
        ftf2->master=ftf;
    }
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6494 6495 6496

  return 0;
}
6497

6498

6499
int init_ftfuncs(THD *thd, SELECT_LEX *select_lex, bool no_order)
6500
{
6501
  if (select_lex->ftfunc_list->elements)
6502
  {
6503
    List_iterator<Item_func_match> li(*(select_lex->ftfunc_list));
6504 6505 6506
    Item_func_match *ifm;
    DBUG_PRINT("info",("Performing FULLTEXT search"));
    thd->proc_info="FULLTEXT initialization";
6507

6508 6509 6510
    while ((ifm=li++))
      ifm->init_search(no_order);
  }
6511 6512
  return 0;
}
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6513 6514 6515 6516 6517 6518 6519


/*
  open new .frm format table

  SYNOPSIS
    open_new_frm()
6520
    THD		  thread handler
6521
    path	  path to .frm file (without extension)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6522
    alias	  alias for table
6523 6524
    db            database
    table_name    name of table
6525
    db_stat	  open flags (for example ->OPEN_KEYFILE|HA_OPEN_RNDFILE..)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6526 6527 6528 6529 6530 6531 6532
		  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
*/
6533

6534
static bool
6535
open_new_frm(THD *thd, TABLE_SHARE *share, const char *alias,
6536
             uint db_stat, uint prgflag,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6537 6538 6539 6540
	     uint ha_open_flags, TABLE *outparam, TABLE_LIST *table_desc,
	     MEM_ROOT *mem_root)
{
  LEX_STRING pathstr;
6541
  File_parser *parser;
6542
  char path[FN_REFLEN];
6543 6544
  DBUG_ENTER("open_new_frm");

6545 6546 6547 6548
  /* Create path with extension */
  pathstr.length= (uint) (strxmov(path, share->normalized_path.str, reg_ext,
                                  NullS)- path);
  pathstr.str=    path;
6549

6550
  if ((parser= sql_parse_prepare(&pathstr, mem_root, 1)))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6551
  {
6552
    if (is_equal(&view_type, parser->type()))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6553
    {
6554
      if (table_desc == 0 || table_desc->required_type == FRMTYPE_TABLE)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6555
      {
6556 6557
        my_error(ER_WRONG_OBJECT, MYF(0), share->db.str, share->table_name.str,
                 "BASE TABLE");
6558
        goto err;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6559
      }
6560 6561
      if (mysql_make_view(thd, parser, table_desc,
                          (prgflag & OPEN_VIEW_NO_PARSE)))
6562
        goto err;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6563 6564 6565 6566
    }
    else
    {
      /* only VIEWs are supported now */
6567
      my_error(ER_FRM_UNKNOWN_TYPE, MYF(0), share->path,  parser->type()->str);
6568
      goto err;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6569
    }
6570
    DBUG_RETURN(0);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6571
  }
monty@mysql.com's avatar
monty@mysql.com committed
6572
 
6573 6574 6575
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
6576
}
6577 6578 6579 6580 6581 6582


bool is_equal(const LEX_STRING *a, const LEX_STRING *b)
{
  return a->length == b->length && !strncmp(a->str, b->str, a->length);
}
6583 6584 6585 6586 6587 6588 6589


/*
  SYNOPSIS
    abort_and_upgrade_lock()
    lpt                           Parameter passing struct
    All parameters passed through the ALTER_PARTITION_PARAM_TYPE object
6590 6591
  RETURN VALUE
    0
6592 6593 6594 6595 6596 6597 6598 6599 6600 6601 6602 6603 6604
  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
*/

6605
int abort_and_upgrade_lock(ALTER_PARTITION_PARAM_TYPE *lpt)
6606 6607 6608 6609 6610 6611 6612 6613 6614
{
  uint flags= RTFC_WAIT_OTHER_THREAD_FLAG | RTFC_CHECK_KILLED_FLAG;
  DBUG_ENTER("abort_and_upgrade_locks");

  lpt->old_lock_type= lpt->table->reginfo.lock_type;
  VOID(pthread_mutex_lock(&LOCK_open));
  mysql_lock_abort(lpt->thd, lpt->table, TRUE);
  VOID(remove_table_from_cache(lpt->thd, lpt->db, lpt->table_name, flags));
  VOID(pthread_mutex_unlock(&LOCK_open));
6615
  DBUG_RETURN(0);
6616 6617 6618 6619 6620 6621 6622 6623 6624 6625 6626 6627 6628 6629 6630 6631 6632 6633 6634 6635 6636 6637 6638 6639 6640 6641 6642 6643 6644 6645 6646 6647 6648 6649 6650 6651 6652 6653 6654 6655 6656 6657 6658 6659 6660 6661 6662 6663 6664 6665 6666 6667 6668 6669 6670 6671 6672 6673 6674 6675 6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686 6687 6688 6689 6690 6691 6692 6693 6694 6695 6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712 6713 6714 6715 6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727
}


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

6728 6729 6730 6731 6732 6733 6734 6735 6736 6737 6738 6739 6740 6741 6742 6743 6744 6745 6746 6747 6748 6749 6750

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

  SYNOPSIS
    has_two_write_locked_tables_with_auto_increment
      tables        Table list

  NOTES:
    Call this function only when you have established the list of all tables
    which you'll want to update (including stored functions, triggers, views
    inside your statement).

  RETURN
    0  No
    1  Yes
*/

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

6753 6754 6755 6756 6757 6758 6759 6760 6761 6762 6763 6764 6765 6766 6767 6768 6769 6770 6771 6772
  for (TABLE_LIST *table= tables; table; table= table->next_global)
  {
    /* we must do preliminary checks as table->table may be NULL */
    if (!table->placeholder() && !table->schema_table &&
        table->table->found_next_number_field &&
        (table->lock_type >= TL_WRITE_ALLOW_WRITE))
    {
      if (first_table_name == NULL)
      {
        first_table_name= table->table_name;
        first_db= table->db;
        DBUG_ASSERT(first_db);
      }
      else if (strcmp(first_db, table->db) ||
               strcmp(first_table_name, table->table_name))
        return 1;
    }
  }
  return 0;
}