sql_base.cc 290 KB
Newer Older
Marc Alff's avatar
Marc Alff committed
1
/* Copyright 2000-2008 MySQL AB, 2008-2009 Sun Microsystems, Inc.
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 "debug_sync.h"
21
#include "sql_select.h"
22
#include "sp_head.h"
23
#include "sp.h"
24
#include "sql_trigger.h"
25
#include "sql_prepare.h"
bk@work.mysql.com's avatar
bk@work.mysql.com committed
26 27 28
#include <m_ctype.h>
#include <my_dir.h>
#include <hash.h>
29
#include "rpl_filter.h"
30
#ifdef  __WIN__
bk@work.mysql.com's avatar
bk@work.mysql.com committed
31 32 33
#include <io.h>
#endif

34 35
#define FLAGSTR(S,F) ((S) & (F) ? #F " " : "")

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

Marc Alff's avatar
Marc Alff committed
50 51 52 53 54 55
  virtual bool handle_condition(THD *thd,
                                uint sql_errno,
                                const char* sqlstate,
                                MYSQL_ERROR::enum_warning_level level,
                                const char* msg,
                                MYSQL_ERROR ** cond_hdl);
56 57 58 59 60 61 62 63 64 65

  bool safely_trapped_errors();

private:
  int m_handled_errors;
  int m_unhandled_errors;
};


bool
Marc Alff's avatar
Marc Alff committed
66 67 68 69 70 71 72 73
Prelock_error_handler::handle_condition(THD *,
                                        uint sql_errno,
                                        const char*,
                                        MYSQL_ERROR::enum_warning_level,
                                        const char*,
                                        MYSQL_ERROR ** cond_hdl)
{
  *cond_hdl= NULL;
74 75 76
  if (sql_errno == ER_NO_SUCH_TABLE)
  {
    m_handled_errors++;
77
    return TRUE;
78 79 80
  }

  m_unhandled_errors++;
81
  return FALSE;
82 83 84 85 86 87 88 89 90 91 92 93 94
}


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

95 96 97 98
/**
  @defgroup Data_Dictionary Data Dictionary
  @{
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
99 100
TABLE *unused_tables;				/* Used by mysql_test */
HASH open_cache;				/* Used by mysql_test */
101 102
static HASH table_def_cache;
static TABLE_SHARE *oldest_unused_share, end_of_unused_share;
Marc Alff's avatar
Marc Alff committed
103
static mysql_mutex_t LOCK_table_share;
104 105 106 107
static bool table_def_inited= 0;

static int open_unireg_entry(THD *thd, TABLE *entry, TABLE_LIST *table_list,
			     const char *alias,
108
                             char *cache_key, uint cache_key_length,
109
			     MEM_ROOT *mem_root, uint flags);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
110
static void free_cache_entry(TABLE *entry);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
111
static void close_old_data_files(THD *thd, TABLE *table, bool morph_locks,
112
                                 bool send_refresh);
113
static bool
114
has_write_table_with_auto_increment(TABLE_LIST *tables);
115

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

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

125

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
126
bool table_cache_init(void)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
127
{
Konstantin Osipov's avatar
Konstantin Osipov committed
128 129 130
  return my_hash_init(&open_cache, &my_charset_bin, table_cache_size+16,
                      0, 0, table_cache_key,
                      (my_hash_free_key) free_cache_entry, 0) != 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
131 132 133 134 135
}

void table_cache_free(void)
{
  DBUG_ENTER("table_cache_free");
136 137
  if (table_def_inited)
  {
138
    close_cached_tables(NULL, NULL, FALSE, FALSE, FALSE);
139
    if (!open_cache.records)			// Safety first
Konstantin Osipov's avatar
Konstantin Osipov committed
140
      my_hash_free(&open_cache);
141
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
142 143 144
  DBUG_VOID_RETURN;
}

145
uint cached_open_tables(void)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
146 147 148 149
{
  return open_cache.records;
}

150

bk@work.mysql.com's avatar
bk@work.mysql.com committed
151 152 153
#ifdef EXTRA_DEBUG
static void check_unused(void)
{
154
  uint count= 0, open_files= 0, idx= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
  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++)
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
175
    TABLE *entry=(TABLE*) my_hash_element(&open_cache,idx);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
176 177
    if (!entry->in_use)
      count--;
178 179
    if (entry->file)
      open_files++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
180 181 182
  }
  if (count != 0)
  {
183
    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
184 185
			count)); /* purecov: inspected */
  }
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204

#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
205 206 207 208 209
}
#else
#define check_unused()
#endif

210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235

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

236
uint create_table_def_key(THD *thd, char *key, TABLE_LIST *table_list,
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
                          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)
*****************************************************************************/

256
extern "C" uchar *table_def_key(const uchar *record, size_t *length,
257 258 259 260
                               my_bool not_used __attribute__((unused)))
{
  TABLE_SHARE *entry=(TABLE_SHARE*) record;
  *length= entry->table_cache_key.length;
261
  return (uchar*) entry->table_cache_key.str;
262 263 264 265 266 267 268 269 270
}


static void table_def_free_entry(TABLE_SHARE *share)
{
  DBUG_ENTER("table_def_free_entry");
  if (share->prev)
  {
    /* remove from old_unused_share list */
Marc Alff's avatar
Marc Alff committed
271
    mysql_mutex_lock(&LOCK_table_share);
272 273
    *share->prev= share->next;
    share->next->prev= share->prev;
Marc Alff's avatar
Marc Alff committed
274
    mysql_mutex_unlock(&LOCK_table_share);
275 276 277 278 279 280 281 282 283
  }
  free_table_share(share);
  DBUG_VOID_RETURN;
}


bool table_def_init(void)
{
  table_def_inited= 1;
Marc Alff's avatar
Marc Alff committed
284
  mysql_mutex_init(key_LOCK_table_share, &LOCK_table_share, MY_MUTEX_INIT_FAST);
285 286 287
  oldest_unused_share= &end_of_unused_share;
  end_of_unused_share.prev= &oldest_unused_share;

Konstantin Osipov's avatar
Konstantin Osipov committed
288 289 290
  return my_hash_init(&table_def_cache, &my_charset_bin, table_def_size,
                      0, 0, table_def_key,
                      (my_hash_free_key) table_def_free_entry, 0) != 0;
291 292 293 294 295 296 297 298 299
}


void table_def_free(void)
{
  DBUG_ENTER("table_def_free");
  if (table_def_inited)
  {
    table_def_inited= 0;
Marc Alff's avatar
Marc Alff committed
300
    mysql_mutex_destroy(&LOCK_table_share);
Konstantin Osipov's avatar
Konstantin Osipov committed
301
    my_hash_free(&table_def_cache);
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
  }
  DBUG_VOID_RETURN;
}


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


/*
  Get TABLE_SHARE for a table.

  get_table_share()
317
  thd			Thread handle
318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337
  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
*/

338
TABLE_SHARE *get_table_share(THD *thd, TABLE_LIST *table_list, char *key,
339 340 341 342 343 344 345 346
                             uint key_length, uint db_flags, int *error)
{
  TABLE_SHARE *share;
  DBUG_ENTER("get_table_share");

  *error= 0;

  /* Read table definition from cache */
Konstantin Osipov's avatar
Konstantin Osipov committed
347 348
  if ((share= (TABLE_SHARE*) my_hash_search(&table_def_cache,(uchar*) key,
                                            key_length)))
349 350 351 352 353 354 355 356 357 358 359
    goto found;

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

  /*
    Lock mutex to be able to read table definition from file without
    conflicts
  */
Marc Alff's avatar
Marc Alff committed
360
  mysql_mutex_lock(&share->mutex);
361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376

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

377
  if (my_hash_insert(&table_def_cache, (uchar*) share))
378 379 380 381 382 383 384
  {
    free_table_share(share);
    DBUG_RETURN(0);				// return error
  }
  if (open_table_def(thd, share, db_flags))
  {
    *error= share->error;
Konstantin Osipov's avatar
Konstantin Osipov committed
385
    (void) my_hash_delete(&table_def_cache, (uchar*) share);
386 387 388 389 390
    DBUG_RETURN(0);
  }
  share->ref_count++;				// Mark in use
  DBUG_PRINT("exit", ("share: 0x%lx  ref_count: %u",
                      (ulong) share, share->ref_count));
Marc Alff's avatar
Marc Alff committed
391
  mysql_mutex_unlock(&share->mutex);
392 393 394 395 396 397 398 399 400
  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 */
Marc Alff's avatar
Marc Alff committed
401
  mysql_mutex_lock(&share->mutex);
402 403 404 405
  if (share->error)
  {
    /* Table definition contained an error */
    open_table_error(share, share->error, share->open_errno, share->errarg);
Marc Alff's avatar
Marc Alff committed
406
    mysql_mutex_unlock(&share->mutex);
407 408 409 410 411
    DBUG_RETURN(0);
  }
  if (share->is_view && !(db_flags & OPEN_VIEW))
  {
    open_table_error(share, 1, ENOENT, 0);
Marc Alff's avatar
Marc Alff committed
412
    mysql_mutex_unlock(&share->mutex);
413 414 415 416 417 418 419 420 421 422
    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"));
Marc Alff's avatar
Marc Alff committed
423
    mysql_mutex_lock(&LOCK_table_share);
424 425 426 427
    *share->prev= share->next;
    share->next->prev= share->prev;
    share->next= 0;
    share->prev= 0;
Marc Alff's avatar
Marc Alff committed
428
    mysql_mutex_unlock(&LOCK_table_share);
429
  }
Marc Alff's avatar
Marc Alff committed
430
  mysql_mutex_unlock(&share->mutex);
431 432 433 434 435

   /* Free cache if too big */
  while (table_def_cache.records > table_def_size &&
         oldest_unused_share->next)
  {
Marc Alff's avatar
Marc Alff committed
436
    mysql_mutex_lock(&oldest_unused_share->mutex);
Konstantin Osipov's avatar
Konstantin Osipov committed
437
    my_hash_delete(&table_def_cache, (uchar*) oldest_unused_share);
438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453
  }

  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,
454
                             char *key, uint key_length,
455 456 457 458 459 460
                             uint db_flags, int *error)
{
  TABLE_SHARE *share;
  int tmp;
  DBUG_ENTER("get_table_share_with_create");

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

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

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

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

    @todo Rework alternative ways to deal with ER_NO_SUCH TABLE.
  */
Marc Alff's avatar
Marc Alff committed
481
  if (share || (thd->is_error() && thd->stmt_da->sql_errno() != ER_NO_SUCH_TABLE))
482

483 484 485
    DBUG_RETURN(share);

  /* Table didn't exist. Check if some engine can provide it */
Staale Smedseng's avatar
Staale Smedseng committed
486 487 488
  tmp= ha_create_table_from_engine(thd, table_list->db,
                                   table_list->table_name);
  if (tmp < 0)
489 490 491
  {
    /*
      No such table in any engine.
492 493 494 495 496
      Hide "Table doesn't exist" errors if the table belongs to a view.
      The check for thd->is_error() is necessary to not push an
      unwanted error in case of pre-locking, which silences
      "no such table" errors.
      @todo Rework the alternative ways to deal with ER_NO_SUCH TABLE.
497
    */
498
    if (thd->is_error())
499
    {
500 501 502 503 504 505 506 507 508 509 510 511
      if (table_list->parent_l)
      {
        thd->clear_error();
        my_error(ER_WRONG_MRG_TABLE, MYF(0));
      }
      else 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);
      }
512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527
    }
    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 */
Marc Alff's avatar
Marc Alff committed
528
  thd->warning_info->clear_warning_info(thd->query_id);
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
  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));

Marc Alff's avatar
Marc Alff committed
565
  mysql_mutex_assert_owner(&LOCK_open);
566

Marc Alff's avatar
Marc Alff committed
567
  mysql_mutex_lock(&share->mutex);
568 569 570 571 572 573 574 575 576 577
  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);
Marc Alff's avatar
Marc Alff committed
578
      mysql_mutex_lock(&LOCK_table_share);
579 580 581 582
      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;
Marc Alff's avatar
Marc Alff committed
583
      mysql_mutex_unlock(&LOCK_table_share);
584 585 586 587 588 589 590 591

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

  if (to_be_deleted)
  {
    DBUG_PRINT("info", ("Deleting share"));
Konstantin Osipov's avatar
Konstantin Osipov committed
592
    my_hash_delete(&table_def_cache, (uchar*) share);
593 594
    DBUG_VOID_RETURN;
  }
Marc Alff's avatar
Marc Alff committed
595
  mysql_mutex_unlock(&share->mutex);
596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614
  DBUG_VOID_RETURN;
}


/*
  Check if table definition exits in cache

  SYNOPSIS
    get_cached_table_share()
    db			Database name
    table_name		Table name

  RETURN
    0  Not cached
    #  TABLE_SHARE for table
*/

TABLE_SHARE *get_cached_table_share(const char *db, const char *table_name)
{
615
  char key[NAME_LEN*2+2];
616 617
  TABLE_LIST table_list;
  uint key_length;
Marc Alff's avatar
Marc Alff committed
618
  mysql_mutex_assert_owner(&LOCK_open);
619 620 621 622

  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
  key_length= create_table_def_key((THD*) 0, key, &table_list, 0);
Konstantin Osipov's avatar
Konstantin Osipov committed
623 624
  return (TABLE_SHARE*) my_hash_search(&table_def_cache,
                                       (uchar*) key, key_length);
625 626 627 628 629 630 631 632 633 634 635 636 637 638 639
}  


/*
  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
640 641 642

    If closing a MERGE child, the calling function has to take care for
    closing the parent too, if necessary.
643 644 645
*/


646
void close_handle_and_leave_table_as_lock(TABLE *table)
647 648
{
  TABLE_SHARE *share, *old_share= table->s;
649
  char *key_buff;
650 651 652
  MEM_ROOT *mem_root= &table->mem_root;
  DBUG_ENTER("close_handle_and_leave_table_as_lock");

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

655 656 657 658 659
  /*
    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
  */
660 661 662 663
  if (multi_alloc_root(mem_root,
                       &share, sizeof(*share),
                       &key_buff, old_share->table_cache_key.length,
                       NULL))
664 665
  {
    bzero((char*) share, sizeof(*share));
666 667
    share->set_table_cache_key(key_buff, old_share->table_cache_key.str,
                               old_share->table_cache_key.length);
668 669 670
    share->tmp_table= INTERNAL_TMP_TABLE;       // for intern_close_table()
  }

671 672 673 674 675 676
  /*
    When closing a MERGE parent or child table, detach the children first.
    Do not clear child table references to allow for reopen.
  */
  if (table->child_l || table->parent)
    detach_merge_children(table, FALSE);
677 678 679 680
  table->file->close();
  table->db_stat= 0;                            // Mark file closed
  release_table_share(table->s, RELEASE_NORMAL);
  table->s= share;
681
  table->file->change_table_ptr(table, table->s);
682 683 684 685 686 687

  DBUG_VOID_RETURN;
}



monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705
/*
  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.
*/

706
OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *db, const char *wild)
707 708
{
  int result = 0;
709
  OPEN_TABLE_LIST **start_list, *open_list;
710 711
  TABLE_LIST table_list;
  DBUG_ENTER("list_open_tables");
712

Marc Alff's avatar
Marc Alff committed
713
  mysql_mutex_lock(&LOCK_open);
714
  bzero((char*) &table_list,sizeof(table_list));
715 716
  start_list= &open_list;
  open_list=0;
717

718
  for (uint idx=0 ; result == 0 && idx < open_cache.records; idx++)
719
  {
720
    OPEN_TABLE_LIST *table;
Konstantin Osipov's avatar
Konstantin Osipov committed
721
    TABLE *entry=(TABLE*) my_hash_element(&open_cache,idx);
722
    TABLE_SHARE *share= entry->s;
723

724
    if (db && my_strcasecmp(system_charset_info, db, share->db.str))
725
      continue;
726
    if (wild && wild_compare(share->table_name.str, wild, 0))
727
      continue;
728

729
    /* Check if user has SELECT privilege for any column in the table */
730 731
    table_list.db=         share->db.str;
    table_list.table_name= share->table_name.str;
732
    table_list.grant.privilege=0;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
733

734
    if (check_table_access(thd,SELECT_ACL,&table_list, TRUE, 1, TRUE))
735 736 737
      continue;
    /* need to check if we haven't already listed it */
    for (table= open_list  ; table ; table=table->next)
738
    {
739 740
      if (!strcmp(table->table, share->table_name.str) &&
	  !strcmp(table->db,    share->db.str))
741 742 743 744 745 746 747
      {
	if (entry->in_use)
	  table->in_use++;
	if (entry->locked_by_name)
	  table->locked++;
	break;
      }
748
    }
749
    if (table)
750
      continue;
751
    if (!(*start_list = (OPEN_TABLE_LIST *)
752
	  sql_alloc(sizeof(**start_list)+share->table_cache_key.length)))
753
    {
754
      open_list=0;				// Out of memory
755
      break;
756
    }
757 758
    strmov((*start_list)->table=
	   strmov(((*start_list)->db= (char*) ((*start_list)+1)),
759 760
		  share->db.str)+1,
	   share->table_name.str);
761 762 763
    (*start_list)->in_use= entry->in_use ? 1 : 0;
    (*start_list)->locked= entry->locked_by_name ? 1 : 0;
    start_list= &(*start_list)->next;
764
    *start_list=0;
765
  }
Marc Alff's avatar
Marc Alff committed
766
  mysql_mutex_unlock(&LOCK_open);
767
  DBUG_RETURN(open_list);
768
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
769 770 771 772 773 774 775 776

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


void intern_close_table(TABLE *table)
{						// Free all structures
777
  DBUG_ENTER("intern_close_table");
778 779 780 781
  DBUG_PRINT("tcache", ("table: '%s'.'%s' 0x%lx",
                        table->s ? table->s->db.str : "?",
                        table->s ? table->s->table_name.str : "?",
                        (long) table));
782

bk@work.mysql.com's avatar
bk@work.mysql.com committed
783
  free_io_cache(table);
784
  delete table->triggers;
785
  if (table->file)                              // Not true if name lock
Konstantin Osipov's avatar
Konstantin Osipov committed
786
    (void) closefrm(table, 1);			// close file
787
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
788 789
}

790 791 792 793 794 795 796 797 798 799
/*
  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
800 801 802 803 804

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

805 806 807
  /* Assert that MERGE children are not attached before final close. */
  DBUG_ASSERT(!table->is_children_attached());

bk@work.mysql.com's avatar
bk@work.mysql.com committed
808 809 810 811 812 813 814 815 816 817 818 819 820
  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
  }
821
  my_free((uchar*) table,MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
822 823 824
  DBUG_VOID_RETURN;
}

825
/* Free resources allocated by filesort() and read_record() */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
826 827 828

void free_io_cache(TABLE *table)
{
829
  DBUG_ENTER("free_io_cache");
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
830
  if (table->sort.io_cache)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
831
  {
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
832
    close_cached_file(table->sort.io_cache);
833
    my_free((uchar*) table->sort.io_cache,MYF(0));
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
834
    table->sort.io_cache=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
835
  }
836
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
837 838
}

839

840 841 842
/*
  Close all tables which aren't in use by any thread

843 844 845 846 847 848 849 850 851 852
  @param thd Thread context
  @param tables List of tables to remove from the cache
  @param have_lock If LOCK_open is locked
  @param wait_for_refresh Wait for a impending flush
  @param wait_for_placeholders Wait for tables being reopened so that the GRL
         won't proceed while write-locked tables are being reopened by other
         threads.

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

855 856
bool close_cached_tables(THD *thd, TABLE_LIST *tables, bool have_lock,
                         bool wait_for_refresh, bool wait_for_placeholders)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
857 858 859
{
  bool result=0;
  DBUG_ENTER("close_cached_tables");
860
  DBUG_ASSERT(thd || (!wait_for_refresh && !tables));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
861

tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
862
  if (!have_lock)
Marc Alff's avatar
Marc Alff committed
863
    mysql_mutex_lock(&LOCK_open);
864
  if (!tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
865
  {
866
    refresh_version++;				// Force close of open tables
867 868
    while (unused_tables)
    {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
869
#ifdef EXTRA_DEBUG
Konstantin Osipov's avatar
Konstantin Osipov committed
870
      if (my_hash_delete(&open_cache,(uchar*) unused_tables))
871
	printf("Warning: Couldn't delete open table from hash\n");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
872
#else
Konstantin Osipov's avatar
Konstantin Osipov committed
873
      (void) my_hash_delete(&open_cache,(uchar*) unused_tables);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
874
#endif
875
    }
876 877 878
    /* Free table shares */
    while (oldest_unused_share->next)
    {
Marc Alff's avatar
Marc Alff committed
879
      mysql_mutex_lock(&oldest_unused_share->mutex);
Konstantin Osipov's avatar
Konstantin Osipov committed
880
      (void) my_hash_delete(&table_def_cache, (uchar*) oldest_unused_share);
881
    }
882 883
    DBUG_PRINT("tcache", ("incremented global refresh_version to: %lu",
                          refresh_version));
884
    if (wait_for_refresh)
885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924
    {
      /*
        Other threads could wait in a loop in open_and_lock_tables(),
        trying to lock one or more of our tables.

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

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

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

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

        In other words (reviewer suggestion): You need this setting of
        some_tables_deleted for the case when table was opened and all
        related checks were passed before incrementing refresh_version
        (which you already have) but attempt to lock the table happened
        after the call to close_old_data_files() i.e. after removal of
        current thread locks.
      */
      for (uint idx=0 ; idx < open_cache.records ; idx++)
      {
Konstantin Osipov's avatar
Konstantin Osipov committed
925
        TABLE *table=(TABLE*) my_hash_element(&open_cache,idx);
926 927 928 929
        if (table->in_use)
          table->in_use->some_tables_deleted= 1;
      }
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
930
  }
931
  else
bk@work.mysql.com's avatar
bk@work.mysql.com committed
932
  {
933
    bool found=0;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
934
    for (TABLE_LIST *table= tables; table; table= table->next_local)
935
    {
936
      if (remove_table_from_cache(thd, table->db, table->table_name,
937
                                  RTFC_OWNED_BY_THD_FLAG))
938 939 940
	found=1;
    }
    if (!found)
941
      wait_for_refresh=0;			// Nothing to wait for
bk@work.mysql.com's avatar
bk@work.mysql.com committed
942
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
943
#ifndef EMBEDDED_LIBRARY
944 945
  if (!tables)
    kill_delayed_threads();
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
946
#endif
947
  if (wait_for_refresh)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
948 949 950 951 952 953 954
  {
    /*
      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;
955
    thd_proc_info(thd, "Flushing tables");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
956

957
    close_old_data_files(thd,thd->open_tables,1,1);
958
    mysql_ha_flush(thd);
959
    DEBUG_SYNC(thd, "after_flush_unlock");
960

bk@work.mysql.com's avatar
bk@work.mysql.com committed
961 962
    bool found=1;
    /* Wait until all threads has closed all the tables we had locked */
963
    DBUG_PRINT("info",
monty@mysql.com's avatar
monty@mysql.com committed
964
	       ("Waiting for other threads to close their open tables"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
965 966 967 968 969
    while (found && ! thd->killed)
    {
      found=0;
      for (uint idx=0 ; idx < open_cache.records ; idx++)
      {
Konstantin Osipov's avatar
Konstantin Osipov committed
970
	TABLE *table=(TABLE*) my_hash_element(&open_cache,idx);
971 972 973
        /* Avoid a self-deadlock. */
        if (table->in_use == thd)
          continue;
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
974 975 976 977 978 979 980 981 982 983 984 985 986 987
        /*
          Note that we wait here only for tables which are actually open, and
          not for placeholders with TABLE::open_placeholder set. Waiting for
          latter will cause deadlock in the following scenario, for example:

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

          It also does not make sense to wait for those of placeholders that
          are employed by CREATE TABLE as in this case table simply does not
          exist yet.
        */
988 989
	if (table->needs_reopen_or_name_lock() && (table->db_stat ||
            (table->open_placeholder && wait_for_placeholders)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
990 991
	{
	  found=1;
monty@mysql.com's avatar
monty@mysql.com committed
992
          DBUG_PRINT("signal", ("Waiting for COND_refresh"));
Marc Alff's avatar
Marc Alff committed
993
          mysql_cond_wait(&COND_refresh, &LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
994 995 996 997 998 999 1000 1001 1002 1003 1004 1005
	  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;
1006
    /* Set version for table */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1007
    for (TABLE *table=thd->open_tables; table ; table= table->next)
1008 1009 1010 1011 1012 1013 1014 1015
    {
      /*
        Preserve the version (0) of write locked tables so that a impending
        global read lock won't sneak in.
      */
      if (table->reginfo.lock_type < TL_WRITE_ALLOW_WRITE)
        table->s->version= refresh_version;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1016
  }
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
1017
  if (!have_lock)
Marc Alff's avatar
Marc Alff committed
1018
    mysql_mutex_unlock(&LOCK_open);
1019
  if (wait_for_refresh)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1020
  {
Marc Alff's avatar
Marc Alff committed
1021
    mysql_mutex_lock(&thd->mysys_var->mutex);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1022 1023
    thd->mysys_var->current_mutex= 0;
    thd->mysys_var->current_cond= 0;
1024
    thd_proc_info(thd, 0);
Marc Alff's avatar
Marc Alff committed
1025
    mysql_mutex_unlock(&thd->mysys_var->mutex);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1026 1027 1028 1029 1030
  }
  DBUG_RETURN(result);
}


1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045
/*
  Close all tables which match specified connection string or
  if specified string is NULL, then any table with a connection string.
*/

bool close_cached_connection_tables(THD *thd, bool if_wait_for_refresh,
                                    LEX_STRING *connection, bool have_lock)
{
  uint idx;
  TABLE_LIST tmp, *tables= NULL;
  bool result= FALSE;
  DBUG_ENTER("close_cached_connections");
  DBUG_ASSERT(thd);

  bzero(&tmp, sizeof(TABLE_LIST));
1046

1047
  if (!have_lock)
Marc Alff's avatar
Marc Alff committed
1048
    mysql_mutex_lock(&LOCK_open);
1049

1050 1051
  for (idx= 0; idx < table_def_cache.records; idx++)
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
1052
    TABLE_SHARE *share= (TABLE_SHARE *) my_hash_element(&table_def_cache, idx);
1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077

    /* Ignore if table is not open or does not have a connect_string */
    if (!share->connect_string.length || !share->ref_count)
      continue;

    /* Compare the connection string */
    if (connection &&
        (connection->length > share->connect_string.length ||
         (connection->length < share->connect_string.length &&
          (share->connect_string.str[connection->length] != '/' &&
           share->connect_string.str[connection->length] != '\\')) ||
         strncasecmp(connection->str, share->connect_string.str,
                     connection->length)))
      continue;

    /* close_cached_tables() only uses these elements */
    tmp.db= share->db.str;
    tmp.table_name= share->table_name.str;
    tmp.next_local= tables;

    tables= (TABLE_LIST *) memdup_root(thd->mem_root, (char*)&tmp, 
                                       sizeof(TABLE_LIST));
  }

  if (tables)
1078 1079
    result= close_cached_tables(thd, tables, TRUE, FALSE, FALSE);

1080
  if (!have_lock)
Marc Alff's avatar
Marc Alff committed
1081
    mysql_mutex_unlock(&LOCK_open);
1082

1083 1084
  if (if_wait_for_refresh)
  {
Marc Alff's avatar
Marc Alff committed
1085
    mysql_mutex_lock(&thd->mysys_var->mutex);
1086 1087 1088
    thd->mysys_var->current_mutex= 0;
    thd->mysys_var->current_cond= 0;
    thd->proc_info=0;
Marc Alff's avatar
Marc Alff committed
1089
    mysql_mutex_unlock(&thd->mysys_var->mutex);
1090 1091 1092 1093 1094 1095
  }

  DBUG_RETURN(result);
}


1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
/**
  Mark all temporary tables which were used by the current statement or
  substatement as free for reuse, but only if the query_id can be cleared.

  @param thd thread context

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

static void mark_temp_tables_as_free_for_reuse(THD *thd)
{
  for (TABLE *table= thd->temporary_tables ; table ; table= table->next)
  {
    if ((table->query_id == thd->query_id) && ! table->open_by_handler)
    {
      table->query_id= 0;
      table->file->ha_reset();
1114 1115 1116 1117 1118 1119 1120 1121
      /*
        Detach temporary MERGE children from temporary parent to allow new
        attach at next open. Do not do the detach, if close_thread_tables()
        is called from a sub-statement. The temporary table might still be
        used in the top-level statement.
      */
      if (table->child_l || table->parent)
        detach_merge_children(table, TRUE);
1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
      /*
        Reset temporary table lock type to it's default value (TL_WRITE).

        Statements such as INSERT INTO .. SELECT FROM tmp, CREATE TABLE
        .. SELECT FROM tmp and UPDATE may under some circumstances modify
        the lock type of the tables participating in the statement. This
        isn't a problem for non-temporary tables since their lock type is
        reset at every open, but the same does not occur for temporary
        tables for historical reasons.

        Furthermore, the lock type of temporary tables is not really that
        important because they can only be used by one query at a time and
        not even twice in a query -- a temporary table is represented by
        only one TABLE object. Nonetheless, it's safer from a maintenance
        point of view to reset the lock type of this singleton TABLE object
        as to not cause problems when the table is reused.

        Even under LOCK TABLES mode its okay to reset the lock type as
        LOCK TABLES is allowed (but ignored) for a temporary table.
      */
      table->reginfo.lock_type= TL_WRITE;
1143 1144 1145 1146 1147
    }
  }
}


1148
/*
1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159
  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.
1160 1161 1162 1163 1164 1165 1166 1167 1168

  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.
1169 1170 1171 1172 1173
*/

static void mark_used_tables_as_free_for_reuse(THD *thd, TABLE *table)
{
  for (; table ; table= table->next)
1174
  {
1175
    if (table->query_id == thd->query_id)
1176
    {
1177
      table->query_id= 0;
1178 1179 1180
      table->file->ha_reset();
    }
  }
1181 1182 1183
}


1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195
/**
  Auxiliary function to close all tables in the open_tables list.

  @param thd Thread context.

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

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

Marc Alff's avatar
Marc Alff committed
1196
  mysql_mutex_assert_not_owner(&LOCK_open);
1197

Marc Alff's avatar
Marc Alff committed
1198
  mysql_mutex_lock(&LOCK_open);
1199 1200 1201 1202 1203 1204 1205 1206 1207

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

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

  /* Free tables to hold down open files */
  while (open_cache.records > table_cache_size && unused_tables)
Konstantin Osipov's avatar
Konstantin Osipov committed
1208
    my_hash_delete(&open_cache,(uchar*) unused_tables); /* purecov: tested */
1209 1210 1211 1212 1213 1214 1215
  check_unused();
  if (found_old_table)
  {
    /* Tell threads waiting for refresh that something has happened */
    broadcast_refresh();
  }

Marc Alff's avatar
Marc Alff committed
1216
  mysql_mutex_unlock(&LOCK_open);
1217 1218 1219
}


1220 1221 1222
/*
  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
1223

1224 1225 1226 1227 1228 1229 1230
  SYNOPSIS
    close_thread_tables()
    thd			Thread handler

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

1232 1233 1234 1235
    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.
1236
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1237

1238
void close_thread_tables(THD *thd)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1239
{
1240
  TABLE *table;
1241
  prelocked_mode_type prelocked_mode= thd->prelocked_mode;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1242 1243
  DBUG_ENTER("close_thread_tables");

1244 1245 1246 1247 1248 1249 1250
#ifdef EXTRA_DEBUG
  DBUG_PRINT("tcache", ("open tables:"));
  for (table= thd->open_tables; table; table= table->next)
    DBUG_PRINT("tcache", ("table: '%s'.'%s' 0x%lx", table->s->db.str,
                          table->s->table_name.str, (long) table));
#endif

1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261
  /*
    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.
  */
1262
  if (thd->derived_tables)
1263
  {
1264
    TABLE *next;
1265
    /*
1266 1267
      Close all derived tables generated in queries like
      SELECT * FROM (SELECT * FROM t1)
1268 1269 1270 1271 1272 1273 1274 1275
    */
    for (table= thd->derived_tables ; table ; table= next)
    {
      next= table->next;
      free_tmp_table(thd, table);
    }
    thd->derived_tables= 0;
  }
1276

1277 1278 1279 1280
  /*
    Mark all temporary tables used by this statement as free for reuse.
  */
  mark_temp_tables_as_free_for_reuse(thd);
1281 1282 1283 1284 1285 1286 1287 1288 1289
  /*
    Let us commit transaction for statement. Since in 5.0 we only have
    one statement transaction and don't allow several nested statement
    transactions this call will do nothing if we are inside of stored
    function or trigger (i.e. statement transaction is already active and
    does not belong to statement for which we do close_thread_tables()).
    TODO: This should be fixed in later releases.
   */
  if (!(thd->state_flags & Open_tables_state::BACKUPS_AVAIL))
1290
  {
Marc Alff's avatar
Marc Alff committed
1291
    thd->stmt_da->can_overwrite_status= TRUE;
1292
    ha_autocommit_or_rollback(thd, thd->is_error());
Marc Alff's avatar
Marc Alff committed
1293
    thd->stmt_da->can_overwrite_status= FALSE;
1294

1295
    /*
1296 1297
      Reset transaction state, but only if we're not inside a
      sub-statement of a prelocked statement.
1298
    */
1299 1300 1301 1302 1303 1304
    if (! prelocked_mode || thd->lex->requires_prelocking())
      thd->transaction.stmt.reset();
  }

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

1306 1307
    /* Ensure we are calling ha_reset() for all used tables */
    mark_used_tables_as_free_for_reuse(thd, thd->open_tables);
1308

1309 1310 1311 1312
    /*
      We are under simple LOCK TABLES or we're inside a sub-statement
      of a prelocked statement, so should not do anything else.
    */
1313
    if (!prelocked_mode || !thd->lex->requires_prelocking())
1314 1315 1316
      DBUG_VOID_RETURN;

    /*
1317 1318 1319
      We are in the top-level statement of a prelocked statement,
      so we have to leave the prelocked mode now with doing implicit
      UNLOCK TABLES if needed.
1320
    */
1321
    DBUG_PRINT("info",("thd->prelocked_mode= NON_PRELOCKED"));
1322 1323 1324 1325 1326 1327 1328 1329
    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 */
1330
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1331 1332 1333

  if (thd->lock)
  {
1334 1335 1336 1337 1338 1339 1340 1341 1342
    /*
      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.
     */
1343
    (void)thd->binlog_flush_pending_rows_event(TRUE);
1344 1345
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1346
  }
1347 1348 1349 1350 1351 1352 1353
  /*
    Note that we need to hold LOCK_open while changing the
    open_tables list. Another thread may work on it.
    (See: remove_table_from_cache(), mysql_wait_completed_table())
    Closing a MERGE child before the parent would be fatal if the
    other thread tries to abort the MERGE lock in between.
  */
1354 1355
  if (thd->open_tables)
    close_open_tables(thd);
1356 1357 1358 1359 1360 1361 1362 1363

  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());
1364
    thd->variables.option_bits&= ~(OPTION_TABLE_LOCK);
1365 1366
  }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1367 1368 1369
  DBUG_VOID_RETURN;
}

1370

1371 1372 1373 1374
/* move one table to free list */

bool close_thread_table(THD *thd, TABLE **table_ptr)
{
1375 1376
  bool found_old_table= 0;
  TABLE *table= *table_ptr;
1377
  DBUG_ENTER("close_thread_table");
1378
  DBUG_ASSERT(table->key_read == 0);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
1379
  DBUG_ASSERT(!table->file || table->file->inited == handler::NONE);
1380 1381
  DBUG_PRINT("tcache", ("table: '%s'.'%s' 0x%lx", table->s->db.str,
                        table->s->table_name.str, (long) table));
1382 1383

  *table_ptr=table->next;
1384 1385 1386 1387 1388 1389 1390
  /*
    When closing a MERGE parent or child table, detach the children first.
    Clear child table references to force new assignment at next open.
  */
  if (table->child_l || table->parent)
    detach_merge_children(table, TRUE);

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
1391
  if (table->needs_reopen_or_name_lock() ||
1392 1393
      thd->version != refresh_version || !table->db_stat)
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
1394
    my_hash_delete(&open_cache,(uchar*) table);
1395 1396 1397 1398
    found_old_table=1;
  }
  else
  {
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
1399 1400 1401 1402 1403 1404
    /*
      Open placeholders have TABLE::db_stat set to 0, so they should be
      handled by the first alternative.
    */
    DBUG_ASSERT(!table->open_placeholder);

1405 1406 1407
    /* Assert that MERGE children are not attached in unused_tables. */
    DBUG_ASSERT(!table->is_children_attached());

1408
    /* Free memory and reset for next loop */
1409 1410
    free_field_buffers_larger_than(table,MAX_TDC_BLOB_SIZE);
    
1411
    table->file->ha_reset();
1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425
    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
1426

1427 1428 1429 1430 1431 1432 1433
/* 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);
}


1434 1435
/*
  Close all temporary tables created by 'CREATE TEMPORARY TABLE' for thread
1436
  creates one DROP TEMPORARY TABLE binlog event for each pseudo-thread 
1437
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1438 1439 1440

void close_temporary_tables(THD *thd)
{
1441
  TABLE *table;
Staale Smedseng's avatar
Staale Smedseng committed
1442
  TABLE *next= NULL;
1443
  TABLE *prev_table;
1444
  /* Assume thd->variables.option_bits has OPTION_QUOTE_SHOW_CREATE */
1445 1446
  bool was_quote_show= TRUE;

1447 1448
  if (!thd->temporary_tables)
    return;
1449

1450 1451
  if (!mysql_bin_log.is_open() || 
      (thd->current_stmt_binlog_row_based && thd->variables.binlog_format == BINLOG_FORMAT_ROW))
1452
  {
1453 1454
    TABLE *tmp_next;
    for (table= thd->temporary_tables; table; table= tmp_next)
1455
    {
1456
      tmp_next= table->next;
1457 1458 1459 1460 1461 1462
      close_temporary(table, 1, 1);
    }
    thd->temporary_tables= 0;
    return;
  }

1463
  /* Better add "if exists", in case a RESET MASTER has been done */
1464 1465 1466 1467
  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);
1468
  bool found_user_tables= FALSE;
1469

1470 1471
  memcpy(buf, stub, stub_len);

1472
  /*
1473 1474
    Insertion sort of temp tables by pseudo_thread_id to build ordered list
    of sublists of equal pseudo_thread_id
1475
  */
1476 1477

  for (prev_table= thd->temporary_tables, table= prev_table->next;
1478 1479
       table;
       prev_table= table, table= table->next)
1480
  {
1481 1482
    TABLE *prev_sorted /* same as for prev_table */, *sorted;
    if (is_user_table(table))
1483
    {
1484 1485 1486 1487
      if (!found_user_tables)
        found_user_tables= true;
      for (prev_sorted= NULL, sorted= thd->temporary_tables; sorted != table;
           prev_sorted= sorted, sorted= sorted->next)
1488
      {
1489 1490
        if (!is_user_table(sorted) ||
            tmpkeyval(thd, sorted) > tmpkeyval(thd, table))
1491
        {
1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504
          /* 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;
1505 1506 1507
        }
      }
    }
1508
  }
1509 1510 1511

  /* We always quote db,table names though it is slight overkill */
  if (found_user_tables &&
1512
      !(was_quote_show= test(thd->variables.option_bits & OPTION_QUOTE_SHOW_CREATE)))
1513
  {
1514
    thd->variables.option_bits |= OPTION_QUOTE_SHOW_CREATE;
1515
  }
1516

1517
  /* scan sorted tmps to generate sequence of DROP */
1518
  for (table= thd->temporary_tables; table; table= next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1519
  {
1520
    if (is_user_table(table))
1521
    {
1522
      my_thread_id save_pseudo_thread_id= thd->variables.pseudo_thread_id;
1523 1524
      /* Set pseudo_thread_id to be that of the processed table */
      thd->variables.pseudo_thread_id= tmpkeyval(thd, table);
1525
      String db;
1526
      db.append(table->s->db.str);
1527 1528 1529
      /* Loop forward through all tables that belong to a common database
         within the sublist of common pseudo_thread_id to create single
         DROP query 
1530
      */
1531 1532
      for (s_query.length(stub_len);
           table && is_user_table(table) &&
1533
             tmpkeyval(thd, table) == thd->variables.pseudo_thread_id &&
1534 1535
             table->s->db.length == db.length() &&
             strcmp(table->s->db.str, db.ptr()) == 0;
1536 1537
           table= next)
      {
1538
        /*
1539 1540
          We are going to add ` around the table names and possible more
          due to special characters
1541 1542 1543
        */
        append_identifier(thd, &s_query, table->s->table_name.str,
                          strlen(table->s->table_name.str));
1544
        s_query.append(',');
1545 1546 1547 1548
        next= table->next;
        close_temporary(table, 1, 1);
      }
      thd->clear_error();
1549 1550 1551 1552
      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 ',' */,
1553
                            0, FALSE, 0);
1554
      qinfo.db= db.ptr();
1555
      qinfo.db_len= db.length();
1556
      thd->variables.character_set_client= cs_save;
1557 1558 1559 1560 1561
      if (mysql_bin_log.write(&qinfo))
      {
        push_warning(thd, MYSQL_ERROR::WARN_LEVEL_ERROR, MYF(0),
                     "Failed to write the DROP statement for temporary tables to binary log");
      }
1562
      thd->variables.pseudo_thread_id= save_pseudo_thread_id;
1563
    }
1564
    else
1565 1566 1567
    {
      next= table->next;
      close_temporary(table, 1, 1);
1568
    }
1569
  }
1570
  if (!was_quote_show)
1571
    thd->variables.option_bits&= ~OPTION_QUOTE_SHOW_CREATE; /* restore option */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1572 1573 1574
  thd->temporary_tables=0;
}

1575
/*
1576
  Find table in list.
1577 1578

  SYNOPSIS
1579
    find_table_in_list()
1580
    table		Pointer to table list
1581
    offset		Offset to which list in table structure to use
1582 1583
    db_name		Data base name
    table_name		Table name
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1584

1585 1586 1587
  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
1588 1589 1590 1591 1592 1593

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

1594
TABLE_LIST *find_table_in_list(TABLE_LIST *table,
1595
                               TABLE_LIST *TABLE_LIST::*link,
1596 1597
                               const char *db_name,
                               const char *table_name)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1598
{
1599
  for (; table; table= table->*link )
1600
  {
1601 1602 1603 1604
    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;
1605
  }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1606 1607 1608 1609
  return table;
}


1610
/*
1611
  Test that table is unique (It's only exists once in the table list)
1612 1613 1614

  SYNOPSIS
    unique_table()
1615
    thd                   thread handle
1616
    table                 table which should be checked
1617
    table_list            list of tables
1618
    check_alias           whether to check tables' aliases
1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633

  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

1634 1635 1636 1637
    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.

1638 1639
    TODO: when we will have table/view change detection we can do this check
          only once for PS/SP
1640 1641

  RETURN
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1642 1643
    found duplicate
    0 if table is unique
1644 1645
*/

1646 1647
TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list,
                         bool check_alias)
1648
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1649
  TABLE_LIST *res;
1650
  const char *d_name, *t_name, *t_alias;
serg@serg.mylan's avatar
serg@serg.mylan committed
1651 1652
  DBUG_ENTER("unique_table");
  DBUG_PRINT("enter", ("table alias: %s", table->alias));
1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664

  /*
    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)
1665
  {
1666 1667 1668 1669 1670 1671 1672 1673 1674
    /* 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);
1675
  }
1676 1677
  d_name= table->db;
  t_name= table->table_name;
1678
  t_alias= table->alias;
1679 1680

  DBUG_PRINT("info", ("real table: %s.%s", d_name, t_name));
1681
  for (;;)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1682
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698
    /*
      Table is unique if it is present only once in the global list
      of tables and once in the list of table locks.
    */
    if (! (res= find_table_in_global_list(table_list, d_name, t_name)) &&
        ! (res= mysql_lock_have_duplicate(thd, table, table_list)))
      break;

    /* Skip if same underlying table. */
    if (res->table && (res->table == table->table))
      goto next;

    /* Skip if table alias does not match. */
    if (check_alias)
    {
      if (lower_case_table_names ?
evgen@sunlight.local's avatar
evgen@sunlight.local committed
1699
          my_strcasecmp(files_charset_info, t_alias, res->alias) :
Konstantin Osipov's avatar
Konstantin Osipov committed
1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710
          strcmp(t_alias, res->alias))
        goto next;
    }

    /*
      Skip if marked to be excluded (could be a derived table) or if
      entry is a prelocking placeholder.
    */
    if (res->select_lex &&
        !res->select_lex->exclude_from_table_unique_test &&
        !res->prelocking_placeholder)
1711
      break;
Konstantin Osipov's avatar
Konstantin Osipov committed
1712

1713
    /*
1714
      If we found entry of this table or table of SELECT which already
1715
      processed in derived table or top select of multi-update/multi-delete
1716
      (exclude_from_table_unique_test) or prelocking placeholder.
1717
    */
Konstantin Osipov's avatar
Konstantin Osipov committed
1718
next:
1719
    table_list= res->next_global;
1720 1721
    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
1722
  }
1723
  DBUG_RETURN(res);
1724 1725 1726
}


1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761
/*
  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)
    {
1762
      /* Issue the ER_NON_INSERTABLE_TABLE error for an INSERT */
1763
      if (update->view == duplicate->view)
1764 1765 1766
        my_error(!strncmp(operation, "INSERT", 6) ?
                 ER_NON_INSERTABLE_TABLE : ER_NON_UPDATABLE_TABLE, MYF(0),
                 update->alias, operation);
1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783
      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);
}


1784
TABLE *find_temporary_table(THD *thd, const char *db, const char *table_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1785
{
1786
  TABLE_LIST table_list;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1787

1788 1789 1790 1791
  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
  return find_temporary_table(thd, &table_list);
}
1792

1793 1794 1795 1796 1797 1798

TABLE *find_temporary_table(THD *thd, TABLE_LIST *table_list)
{
  char	key[MAX_DBKEY_LENGTH];
  uint	key_length;
  TABLE *table;
1799 1800 1801
  DBUG_ENTER("find_temporary_table");
  DBUG_PRINT("enter", ("table: '%s'.'%s'",
                       table_list->db, table_list->table_name));
1802 1803 1804

  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
1805
  {
1806 1807
    if (table->s->table_cache_key.length == key_length &&
	!memcmp(table->s->table_cache_key.str, key, key_length))
1808 1809 1810 1811 1812
    {
      DBUG_PRINT("info",
                 ("Found table. server_id: %u  pseudo_thread_id: %lu",
                  (uint) thd->server_id,
                  (ulong) thd->variables.pseudo_thread_id));
1813
      DBUG_RETURN(table);
1814
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1815
  }
1816
  DBUG_RETURN(0);                               // Not a temporary table
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1817 1818
}

1819

1820 1821 1822 1823 1824
/**
  Drop a temporary table.

  Try to locate the table in the list of thd->temporary_tables.
  If the table is found:
1825
   - if the table is being used by some outer statement, fail.
1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839
   - if the table is in thd->locked_tables, unlock it and
     remove it from the list of locked tables. Currently only transactional
     temporary tables are present in the locked_tables list.
   - Close the temporary table, remove its .FRM
   - remove the table from the list of temporary tables

  This function is used to drop user temporary tables, as well as
  internal tables created in CREATE TEMPORARY TABLE ... SELECT
  or ALTER TABLE. Even though part of the work done by this function
  is redundant when the table is internal, as long as we
  link both internal and user temporary tables into the same
  thd->temporary_tables list, it's impossible to tell here whether
  we're dealing with an internal or a user temporary table.

1840 1841 1842 1843
  @retval  0  the table was found and dropped successfully.
  @retval  1  the table was not found in the list of temporary tables
              of this thread
  @retval -1  the table is in use by a outer query
1844 1845
*/

1846
int drop_temporary_table(THD *thd, TABLE_LIST *table_list)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1847
{
1848
  TABLE *table;
1849
  DBUG_ENTER("drop_temporary_table");
1850 1851
  DBUG_PRINT("tmptable", ("closing table: '%s'.'%s'",
                          table_list->db, table_list->table_name));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1852

1853
  if (!(table= find_temporary_table(thd, table_list)))
1854 1855 1856 1857 1858 1859 1860 1861 1862
    DBUG_RETURN(1);

  /* Table might be in use by some outer statement. */
  if (table->query_id && table->query_id != thd->query_id)
  {
    my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
    DBUG_RETURN(-1);
  }

1863 1864 1865 1866 1867
  /*
    If LOCK TABLES list is not empty and contains this table,
    unlock the table and remove the table from this list.
  */
  mysql_lock_remove(thd, thd->locked_tables, table, FALSE);
1868
  close_temporary_table(thd, table, 1, 1);
1869
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1870 1871
}

1872
/*
1873
  unlink from thd->temporary tables and close temporary table
1874 1875 1876 1877 1878
*/

void close_temporary_table(THD *thd, TABLE *table,
                           bool free_share, bool delete_table)
{
1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896
  DBUG_ENTER("close_temporary_table");
  DBUG_PRINT("tmptable", ("closing table: '%s'.'%s' 0x%lx  alias: '%s'",
                          table->s->db.str, table->s->table_name.str,
                          (long) table, table->alias));

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

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

1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915
  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;
  }
1916
  if (thd->slave_thread)
1917 1918 1919
  {
    /* natural invariant of temporary_tables */
    DBUG_ASSERT(slave_open_temp_tables || !thd->temporary_tables);
1920
    slave_open_temp_tables--;
1921
  }
1922
  close_temporary(table, free_share, delete_table);
1923
  DBUG_VOID_RETURN;
1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936
}


/*
  Close and delete a temporary table

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

void close_temporary(TABLE *table, bool free_share, bool delete_table)
{
antony@ppcg5.local's avatar
antony@ppcg5.local committed
1937
  handlerton *table_type= table->s->db_type();
1938
  DBUG_ENTER("close_temporary");
1939 1940
  DBUG_PRINT("tmptable", ("closing table: '%s'.'%s'",
                          table->s->db.str, table->s->table_name.str));
1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954

  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
1955 1956 1957 1958 1959 1960 1961
/*
  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'.
*/
1962

1963
bool rename_temporary_table(THD* thd, TABLE *table, const char *db,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1964 1965 1966
			    const char *table_name)
{
  char *key;
1967
  uint key_length;
1968
  TABLE_SHARE *share= table->s;
1969 1970 1971
  TABLE_LIST table_list;
  DBUG_ENTER("rename_temporary_table");

1972
  if (!(key=(char*) alloc_root(&share->mem_root, MAX_DBKEY_LENGTH)))
1973 1974 1975 1976
    DBUG_RETURN(1);				/* purecov: inspected */

  table_list.db= (char*) db;
  table_list.table_name= (char*) table_name;
1977 1978
  key_length= create_table_def_key(thd, key, &table_list, 1);
  share->set_table_cache_key(key, key_length);
1979
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1980 1981 1982 1983 1984 1985 1986
}


	/* move table first in unused links */

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003
  if (table != unused_tables)
  {
    table->prev->next=table->next;		/* Remove from unused list */
    table->next->prev=table->prev;
    table->next=unused_tables;			/* Link in unused tables */
    table->prev=unused_tables->prev;
    unused_tables->prev->next=table;
    unused_tables->prev=table;
    unused_tables=table;
    check_unused();
  }
}


dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2004
/**
2005
  Prepare an open merge table for close.
2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074

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

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

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

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

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

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

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

  DBUG_VOID_RETURN;
}


dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2075
/**
2076 2077
    Remove all instances of table from thread's open list and
    table cache.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2078 2079 2080 2081 2082 2083 2084 2085

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

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

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2090
void unlink_open_table(THD *thd, TABLE *find, bool unlock)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2091 2092
{
  char key[MAX_DBKEY_LENGTH];
2093
  uint key_length= find->s->table_cache_key.length;
2094
  TABLE *list, **prev;
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2095 2096
  DBUG_ENTER("unlink_open_table");

Marc Alff's avatar
Marc Alff committed
2097
  mysql_mutex_assert_owner(&LOCK_open);
2098

2099
  memcpy(key, find->s->table_cache_key.str, key_length);
2100 2101 2102 2103 2104 2105 2106 2107
  /*
    Note that we need to hold LOCK_open while changing the
    open_tables list. Another thread may work on it.
    (See: remove_table_from_cache(), mysql_wait_completed_table())
    Closing a MERGE child before the parent would be fatal if the
    other thread tries to abort the MERGE lock in between.
  */
  for (prev= &thd->open_tables; *prev; )
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2108
  {
2109 2110
    list= *prev;

2111 2112
    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
2113
    {
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2114
      if (unlock && thd->locked_tables)
2115 2116 2117 2118 2119 2120 2121 2122 2123
        mysql_lock_remove(thd, thd->locked_tables,
                          list->parent ? list->parent : list, TRUE);

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

      /* Remove table from open_tables list. */
      *prev= list->next;
      /* Close table. */
Konstantin Osipov's avatar
Konstantin Osipov committed
2124
      my_hash_delete(&open_cache,(uchar*) list); // Close table
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2125 2126 2127
    }
    else
    {
2128
      /* Step to next entry in open_tables list. */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2129 2130 2131
      prev= &list->next;
    }
  }
2132

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2133
  // Notify any 'refresh' threads
2134
  broadcast_refresh();
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2135 2136 2137 2138 2139
  DBUG_VOID_RETURN;
}


/**
2140
    Auxiliary routine which closes and drops open table.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2141 2142 2143 2144 2145 2146 2147 2148

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

    @note This routine assumes that table to be closed is open only
          by calling thread so we needn't wait until other threads
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2149 2150 2151 2152 2153
          will close the table. Also unless called under implicit or
          explicit LOCK TABLES mode it assumes that table to be
          dropped is already unlocked. In the former case it will
          also remove lock on the table. But one should not rely on
          this behaviour as it may change in future.
2154 2155
          Currently, however, this function is never called for a
          table that was locked with LOCK TABLES.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2156 2157 2158 2159 2160 2161 2162 2163 2164
*/

void drop_open_table(THD *thd, TABLE *table, const char *db_name,
                     const char *table_name)
{
  if (table->s->tmp_table)
    close_temporary_table(thd, table, 1, 1);
  else
  {
kostja@vajra.(none)'s avatar
kostja@vajra.(none) committed
2165
    handlerton *table_type= table->s->db_type();
Marc Alff's avatar
Marc Alff committed
2166
    mysql_mutex_lock(&LOCK_open);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2167 2168 2169 2170 2171 2172
    /*
      unlink_open_table() also tells threads waiting for refresh or close
      that something has happened.
    */
    unlink_open_table(thd, table, FALSE);
    quick_rm_table(table_type, db_name, table_name, 0);
Marc Alff's avatar
Marc Alff committed
2173
    mysql_mutex_unlock(&LOCK_open);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2174
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2175 2176 2177
}


2178
/*
2179 2180 2181 2182 2183 2184 2185 2186
   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
2187 2188
*/

Marc Alff's avatar
Marc Alff committed
2189
void wait_for_condition(THD *thd, mysql_mutex_t *mutex, mysql_cond_t *cond)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2190 2191 2192
{
  /* Wait until the current table is up to date */
  const char *proc_info;
2193 2194
  thd->mysys_var->current_mutex= mutex;
  thd->mysys_var->current_cond= cond;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2195
  proc_info=thd->proc_info;
2196
  thd_proc_info(thd, "Waiting for table");
2197
  DBUG_ENTER("wait_for_condition");
2198
  if (!thd->killed)
Marc Alff's avatar
Marc Alff committed
2199
    mysql_cond_wait(cond, mutex);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2200

2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211
  /*
    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
  */
    
Marc Alff's avatar
Marc Alff committed
2212 2213
  mysql_mutex_unlock(mutex);
  mysql_mutex_lock(&thd->mysys_var->mutex);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2214 2215
  thd->mysys_var->current_mutex= 0;
  thd->mysys_var->current_cond= 0;
2216
  thd_proc_info(thd, proc_info);
Marc Alff's avatar
Marc Alff committed
2217
  mysql_mutex_unlock(&thd->mysys_var->mutex);
monty@mysql.com's avatar
monty@mysql.com committed
2218
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2219 2220
}

2221

2222 2223 2224 2225 2226
/**
  Exclusively name-lock a table that is already write-locked by the
  current thread.

  @param thd current thread context
2227
  @param tables table list containing one table to open.
2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256

  @return FALSE on success, TRUE otherwise.
*/

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

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

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

  DBUG_RETURN(TRUE);
}


2257 2258 2259 2260 2261 2262 2263 2264 2265
/*
  Open table which is already name-locked by this thread.

  SYNOPSIS
    reopen_name_locked_table()
      thd         Thread handle
      table_list  TABLE_LIST object for table to be open, TABLE_LIST::table
                  member should point to TABLE object which was used for
                  name-locking.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2266 2267 2268 2269 2270
      link_in     TRUE  - if TABLE object for table to be opened should be
                          linked into THD::open_tables list.
                  FALSE - placeholder used for name-locking is already in
                          this list so we only need to preserve TABLE::next
                          pointer.
2271 2272 2273 2274 2275 2276 2277 2278 2279

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

  RETURN VALUE
    FALSE - Success
    TRUE  - Error
*/

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2280
bool reopen_name_locked_table(THD* thd, TABLE_LIST* table_list, bool link_in)
2281
{
2282
  TABLE *table= table_list->table;
2283
  TABLE_SHARE *share;
2284 2285 2286
  char *table_name= table_list->table_name;
  TABLE orig_table;
  DBUG_ENTER("reopen_name_locked_table");
2287

Marc Alff's avatar
Marc Alff committed
2288
  mysql_mutex_assert_owner(&LOCK_open);
2289 2290 2291 2292 2293

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

  orig_table= *table;
2294

2295 2296
  if (open_unireg_entry(thd, table, table_list, table_name,
                        table->s->table_cache_key.str,
2297
                        table->s->table_cache_key.length, thd->mem_root, 0))
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2298
  {
2299 2300 2301 2302 2303 2304 2305 2306 2307
    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
2308
  }
2309

2310
  share= table->s;
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2311 2312 2313 2314 2315 2316 2317 2318
  /*
    We want to prevent other connections from opening this table until end
    of statement as it is likely that modifications of table's metadata are
    not yet finished (for example CREATE TRIGGER have to change .TRG file,
    or we might want to drop table if CREATE TABLE ... SELECT fails).
    This also allows us to assume that no other connection will sneak in
    before we will get table-level lock on this table.
  */
2319
  share->version=0;
2320 2321
  table->in_use = thd;
  check_unused();
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336

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

2337 2338 2339
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
2340 2341
  table->null_row= table->maybe_null= 0;
  table->force_index= table->force_index_order= table->force_index_group= 0;
2342
  table->status=STATUS_NO_RECORD;
2343
  DBUG_RETURN(FALSE);
2344 2345
}

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

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2347
/**
2348 2349 2350
    Create and insert into table cache placeholder for table
    which will prevent its opening (or creation) (a.k.a lock
    table name).
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367

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

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

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

Marc Alff's avatar
Marc Alff committed
2368
  mysql_mutex_assert_owner(&LOCK_open);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387

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

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

2388
  if (my_hash_insert(&open_cache, (uchar*)table))
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2389
  {
jani@linux-th5m.site's avatar
jani@linux-th5m.site committed
2390
    my_free((uchar*) table, MYF(0));
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2391 2392 2393 2394 2395 2396 2397 2398
    DBUG_RETURN(NULL);
  }

  DBUG_RETURN(table);
}


/**
2399 2400
    Obtain an exclusive name lock on the table if it is not cached
    in the table cache.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427

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

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

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

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

  key_length= (uint)(strmov(strmov(key, db) + 1, table_name) - key) + 1;
Marc Alff's avatar
Marc Alff committed
2428
  mysql_mutex_lock(&LOCK_open);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2429

Konstantin Osipov's avatar
Konstantin Osipov committed
2430
  if (my_hash_search(&open_cache, (uchar *)key, key_length))
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2431
  {
Marc Alff's avatar
Marc Alff committed
2432
    mysql_mutex_unlock(&LOCK_open);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2433 2434 2435 2436 2437 2438
    DBUG_PRINT("info", ("Table is cached, name-lock is not obtained"));
    *table= 0;
    DBUG_RETURN(FALSE);
  }
  if (!(*table= table_cache_insert_placeholder(thd, key, key_length)))
  {
Marc Alff's avatar
Marc Alff committed
2439
    mysql_mutex_unlock(&LOCK_open);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2440 2441 2442 2443 2444
    DBUG_RETURN(TRUE);
  }
  (*table)->open_placeholder= 1;
  (*table)->next= thd->open_tables;
  thd->open_tables= *table;
Marc Alff's avatar
Marc Alff committed
2445
  mysql_mutex_unlock(&LOCK_open);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2446 2447 2448 2449 2450
  DBUG_RETURN(FALSE);
}


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

kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
2454 2455 2456
    @param       thd     Thread context
    @param       table   Table list element
    @param[out]  exists  Out parameter which is set to TRUE if table
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472
                         exists and to FALSE otherwise.

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

    @note If there is no .FRM file for the table but it exists in one
          of engines (e.g. it was created on another node of NDB cluster)
          this function will fetch and create proper .FRM file for it.

    @retval  TRUE   Some error occured
    @retval  FALSE  No error. 'exists' out parameter set accordingly.
*/

bool check_if_table_exists(THD *thd, TABLE_LIST *table, bool *exists)
{
2473
  char path[FN_REFLEN + 1];
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2474 2475 2476
  int rc;
  DBUG_ENTER("check_if_table_exists");

Marc Alff's avatar
Marc Alff committed
2477
  mysql_mutex_assert_owner(&LOCK_open);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513

  *exists= TRUE;

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

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

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

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

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

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


2514 2515 2516 2517 2518
/*
  Open a table.

  SYNOPSIS
    open_table()
2519 2520 2521 2522 2523 2524 2525 2526 2527 2528
    thd                 Thread context.
    table_list          Open first table in list.
    refresh      INOUT  Pointer to memory that will be set to 1 if
                        we need to close all tables and reopen them.
                        If this is a NULL pointer, then the table is not
                        put in the thread-open-list.
    flags               Bitmap of flags to modify how open works:
                          MYSQL_LOCK_IGNORE_FLUSH - Open table even if
                          someone has done a flush or namelock on it.
                          No version number checking is done.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2529 2530
                          MYSQL_OPEN_TEMPORARY_ONLY - Open only temporary
                          table not the base table or view.
2531 2532 2533 2534

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

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

2540 2541
  RETURN
    NULL  Open failed.  If refresh is set then one should close
2542
          all other tables and retry the open.
2543 2544
    #     Success. Pointer to TABLE object for open table.
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2545 2546


bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2547
TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
2548
		  bool *refresh, uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2549 2550 2551 2552
{
  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
2553
  char	*alias= table_list->alias;
2554
  my_hash_value_type hash_value;
2555
  HASH_SEARCH_STATE state;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2556 2557 2558 2559 2560
  DBUG_ENTER("open_table");

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

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2566 2567
  if (thd->killed)
    DBUG_RETURN(0);
2568 2569 2570

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

2572 2573 2574 2575 2576 2577 2578
  /*
    Unless requested otherwise, try to resolve this table in the list
    of temporary tables of this thread. In MySQL temporary tables
    are always thread-local and "shadow" possible base tables with the
    same name. This block implements the behaviour.
    TODO: move this block into a separate function.
  */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2579
  if (!table_list->skip_temporary)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2580
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2581
    for (table= thd->temporary_tables; table ; table=table->next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2582
    {
2583 2584 2585
      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
2586
		  key_length + TMP_TABLE_KEY_EXTRA))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2587
      {
2588 2589 2590 2591 2592 2593
        /*
          We're trying to use the same temporary table twice in a query.
          Right now we don't support this because a temporary table
          is always represented by only one TABLE object in THD, and
          it can not be cloned. Emit an error for an unsupported behaviour.
        */
2594
	if (table->query_id)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2595
	{
2596 2597 2598 2599
          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));
2600
	  my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2601 2602 2603
	  DBUG_RETURN(0);
	}
	table->query_id= thd->query_id;
2604
	thd->thread_specific_used= TRUE;
monty@mysql.com's avatar
monty@mysql.com committed
2605 2606
        DBUG_PRINT("info",("Using temporary table"));
        goto reset;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2607 2608 2609 2610
      }
    }
  }

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2611 2612 2613 2614 2615 2616
  if (flags & MYSQL_OPEN_TEMPORARY_ONLY)
  {
    my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->db, table_list->table_name);
    DBUG_RETURN(0);
  }

2617 2618 2619 2620 2621 2622 2623
  /*
    The table is not temporary - if we're in pre-locked or LOCK TABLES
    mode, let's try to find the requested table in the list of pre-opened
    and locked tables. If the table is not there, return an error - we can't
    open not pre-opened tables in pre-locked/LOCK TABLES mode.
    TODO: move this block into a separate function.
  */
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2624
  if (thd->locked_tables || thd->prelocked_mode)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2625
  {						// Using table locks
2626
    TABLE *best_table= 0;
2627
    int best_distance= INT_MIN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2628 2629
    for (table=thd->open_tables; table ; table=table->next)
    {
2630 2631
      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
2632
      {
2633 2634 2635 2636
        /*
          When looking for a usable TABLE, ignore MERGE children, as they
          belong to their parent and cannot be used explicitly.
        */
2637 2638
        if (!my_strcasecmp(system_charset_info, table->alias, alias) &&
            table->query_id != thd->query_id && /* skip tables already used */
2639 2640
            !(thd->prelocked_mode && table->query_id) &&
            !table->parent)
2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655
        {
          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
          */
2656 2657
          if ((best_distance < 0 && distance > best_distance) ||
              (distance >= 0 && distance < best_distance))
2658 2659 2660
          {
            best_distance= distance;
            best_table= table;
2661
            if (best_distance == 0)
2662 2663
            {
              /*
2664 2665 2666 2667
                We have found a perfect match and can finish iterating
                through open tables list. Check for table use conflict
                between calling statement and SP/trigger is done in
                lock_tables().
2668 2669 2670 2671
              */
              break;
            }
          }
2672
        }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2673
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2674
    }
2675 2676 2677 2678 2679 2680 2681
    if (best_table)
    {
      table= best_table;
      table->query_id= thd->query_id;
      DBUG_PRINT("info",("Using locked table"));
      goto reset;
    }
2682
    /*
2683
      Is this table a view and not a base table?
2684 2685 2686 2687
      (it is work around to allow to open view with locked tables,
      real fix will be made after definition cache will be made)
    */
    {
2688
      char path[FN_REFLEN + 1];
2689
      enum legacy_db_type not_used;
2690
      build_table_filename(path, sizeof(path) - 1,
2691
                           table_list->db, table_list->table_name, reg_ext, 0);
2692
      if (mysql_frm_type(thd, path, &not_used) == FRMTYPE_VIEW)
2693
      {
2694 2695 2696 2697 2698
        /*
          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;
2699
        table= &tab;
Marc Alff's avatar
Marc Alff committed
2700
        mysql_mutex_lock(&LOCK_open);
2701
        if (!open_unireg_entry(thd, table, table_list, alias,
2702
                              key, key_length, mem_root, 0))
2703
        {
2704
          DBUG_ASSERT(table_list->view != 0);
Marc Alff's avatar
Marc Alff committed
2705
          mysql_mutex_unlock(&LOCK_open);
2706 2707
          DBUG_RETURN(0); // VIEW
        }
Marc Alff's avatar
Marc Alff committed
2708
        mysql_mutex_unlock(&LOCK_open);
2709 2710
      }
    }
2711 2712 2713 2714 2715 2716 2717 2718
    /*
      No table in the locked tables list. In case of explicit LOCK TABLES
      this can happen if a user did not include the able into the list.
      In case of pre-locked mode locked tables list is generated automatically,
      so we may only end up here if the table did not exist when
      locked tables list was created.
    */
    if (thd->prelocked_mode == PRELOCKED)
2719
      my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->db, table_list->alias);
2720 2721
    else
      my_error(ER_TABLE_NOT_LOCKED, MYF(0), alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2722 2723
    DBUG_RETURN(0);
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2724

2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740
  /*
    Non pre-locked/LOCK TABLES mode, and the table is not temporary:
    this is the normal use case.
    Now we should:
    - try to find the table in the table cache.
    - if one of the discovered TABLE instances is name-locked
      (table->s->version == 0) or some thread has started FLUSH TABLES
      (refresh_version > table->s->version), back off -- we have to wait
      until no one holds a name lock on the table.
    - if there is no such TABLE in the name cache, read the table definition
    and insert it into the cache.
    We perform all of the above under LOCK_open which currently protects
    the open cache (also known as table cache) and table definitions stored
    on disk.
  */

2741
  hash_value= my_calc_hash(&open_cache, (uchar*) key, key_length);
Marc Alff's avatar
Marc Alff committed
2742
  mysql_mutex_lock(&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2743

2744 2745 2746 2747 2748 2749 2750 2751
  /*
    If it's the first table from a list of tables used in a query,
    remember refresh_version (the version of open_cache state).
    If the version changes while we're opening the remaining tables,
    we will have to back off, close all the tables opened-so-far,
    and try to reopen them.
    Note: refresh_version is currently changed only during FLUSH TABLES.
  */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2752 2753
  if (!thd->open_tables)
    thd->version=refresh_version;
2754
  else if ((thd->version != refresh_version) &&
2755
           ! (flags & MYSQL_LOCK_IGNORE_FLUSH))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2756 2757
  {
    /* Someone did a refresh while thread was opening tables */
2758 2759
    if (refresh)
      *refresh=1;
Marc Alff's avatar
Marc Alff committed
2760
    mysql_mutex_unlock(&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2761 2762 2763
    DBUG_RETURN(0);
  }

2764 2765 2766 2767 2768 2769 2770
  /*
    In order for the back off and re-start process to work properly,
    handler tables having old versions (due to FLUSH TABLES or pending
    name-lock) MUST be closed. This is specially important if a name-lock
    is pending for any table of the handler_tables list, otherwise a
    deadlock may occur.
  */
monty@mysql.com's avatar
monty@mysql.com committed
2771
  if (thd->handler_tables)
2772
    mysql_ha_flush(thd);
2773

2774 2775 2776 2777 2778 2779 2780 2781 2782 2783
  /*
    Actually try to find the table in the open_cache.
    The cache may contain several "TABLE" instances for the same
    physical table. The instances that are currently "in use" by
    some thread have their "in_use" member != NULL.
    There is no good reason for having more than one entry in the
    hash for the same physical table, except that we use this as
    an implicit "pending locks queue" - see
    wait_for_locked_table_names for details.
  */
2784 2785 2786 2787 2788
  for (table= (TABLE*) my_hash_first_from_hash_value(&open_cache,
                                                     hash_value,
                                                     (uchar*) key,
                                                     key_length,
                                                     &state);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2789
       table && table->in_use ;
Konstantin Osipov's avatar
Konstantin Osipov committed
2790 2791
       table= (TABLE*) my_hash_next(&open_cache, (uchar*) key, key_length,
                                    &state))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2792
  {
2793 2794
    DBUG_PRINT("tcache", ("in_use table: '%s'.'%s' 0x%lx", table->s->db.str,
                          table->s->table_name.str, (long) table));
2795
    /*
2796
      Here we flush tables marked for flush.
2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811
      Normally, table->s->version contains the value of
      refresh_version from the moment when this table was
      (re-)opened and added to the cache.
      If since then we did (or just started) FLUSH TABLES
      statement, refresh_version has been increased.
      For "name-locked" TABLE instances, table->s->version is set
      to 0 (see lock_table_name for details).
      In case there is a pending FLUSH TABLES or a name lock, we
      need to back off and re-start opening tables.
      If we do not back off now, we may dead lock in case of lock
      order mismatch with some other thread:
      c1: name lock t1; -- sort of exclusive lock 
      c2: open t2;      -- sort of shared lock
      c1: name lock t2; -- blocks
      c2: open t1; -- blocks
2812
    */
2813
    if (table->needs_reopen_or_name_lock())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2814
    {
monty@mysql.com's avatar
monty@mysql.com committed
2815 2816 2817
      DBUG_PRINT("note",
                 ("Found table '%s.%s' with different refresh version",
                  table_list->db, table_list->table_name));
2818

2819
      if (flags & MYSQL_LOCK_IGNORE_FLUSH)
2820 2821 2822 2823 2824 2825
      {
        /* Force close at once after usage */
        thd->version= table->s->version;
        continue;
      }

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2826 2827 2828
      /* Avoid self-deadlocks by detecting self-dependencies. */
      if (table->open_placeholder && table->in_use == thd)
      {
Marc Alff's avatar
Marc Alff committed
2829
        mysql_mutex_unlock(&LOCK_open);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2830 2831 2832 2833
        my_error(ER_UPDATE_TABLE_USED, MYF(0), table->s->table_name.str);
        DBUG_RETURN(0);
      }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2834
      /*
2835 2836 2837 2838 2839 2840 2841
        Back off, part 1: mark the table as "unused" for the
        purpose of name-locking by setting table->db_stat to 0. Do
        that only for the tables in this thread that have an old
        table->s->version (this is an optimization (?)).
        table->db_stat == 0 signals wait_for_locked_table_names
        that the tables in question are not used any more. See
        table_is_used call for details.
2842 2843 2844 2845

        Notice that HANDLER tables were already taken care of by
        the earlier call to mysql_ha_flush() in this same critical
        section.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2846
      */
2847
      close_old_data_files(thd,thd->open_tables,0,0);
2848 2849 2850 2851 2852 2853
      /*
        Back-off part 2: try to avoid "busy waiting" on the table:
        if the table is in use by some other thread, we suspend
        and wait till the operation is complete: when any
        operation that juggles with table->s->version completes,
        it broadcasts COND_refresh condition variable.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2854 2855 2856 2857 2858 2859 2860 2861
        If 'old' table we met is in use by current thread we return
        without waiting since in this situation it's this thread
        which is responsible for broadcasting on COND_refresh
        (and this was done already in close_old_data_files()).
        Good example of such situation is when we have statement
        that needs two instances of table and FLUSH TABLES comes
        after we open first instance but before we open second
        instance.
2862
      */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2863
      if (table->in_use != thd)
2864
      {
Marc Alff's avatar
Marc Alff committed
2865
        /* wait_for_condition will unlock LOCK_open for us */
2866
        wait_for_condition(thd, &LOCK_open, &COND_refresh);
2867
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2868
      else
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2869
      {
Marc Alff's avatar
Marc Alff committed
2870
        mysql_mutex_unlock(&LOCK_open);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2871
      }
2872 2873 2874 2875
      /*
        There is a refresh in progress for this table.
        Signal the caller that it has to try again.
      */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2876 2877 2878 2879 2880 2881 2882
      if (refresh)
	*refresh=1;
      DBUG_RETURN(0);
    }
  }
  if (table)
  {
2883 2884
    DBUG_PRINT("tcache", ("unused table: '%s'.'%s' 0x%lx", table->s->db.str,
                          table->s->table_name.str, (long) table));
2885
    /* Unlink the table from "unused_tables" list. */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2886 2887 2888 2889 2890 2891 2892 2893
    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;
2894
    table->in_use= thd;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2895 2896 2897
  }
  else
  {
2898
    /* Insert a new TABLE instance into the open cache */
2899
    int error;
2900
    DBUG_PRINT("tcache", ("opening new table"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2901
    /* Free cache if too big */
2902
    while (open_cache.records > table_cache_size && unused_tables)
Konstantin Osipov's avatar
Konstantin Osipov committed
2903
      my_hash_delete(&open_cache,(uchar*) unused_tables); /* purecov: tested */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2904

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2905 2906 2907 2908 2909 2910
    if (table_list->create)
    {
      bool exists;

      if (check_if_table_exists(thd, table_list, &exists))
      {
Marc Alff's avatar
Marc Alff committed
2911
        mysql_mutex_unlock(&LOCK_open);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2912 2913 2914 2915 2916 2917 2918 2919 2920 2921
        DBUG_RETURN(NULL);
      }

      if (!exists)
      {
        /*
          Table to be created, so we need to create placeholder in table-cache.
        */
        if (!(table= table_cache_insert_placeholder(thd, key, key_length)))
        {
Marc Alff's avatar
Marc Alff committed
2922
          mysql_mutex_unlock(&LOCK_open);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2923 2924 2925 2926 2927 2928 2929 2930 2931 2932
          DBUG_RETURN(NULL);
        }
        /*
          Link placeholder to the open tables list so it will be automatically
          removed once tables are closed. Also mark it so it won't be ignored
          by other trying to take name-lock.
        */
        table->open_placeholder= 1;
        table->next= thd->open_tables;
        thd->open_tables= table;
Marc Alff's avatar
Marc Alff committed
2933
        mysql_mutex_unlock(&LOCK_open);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
2934 2935 2936 2937
        DBUG_RETURN(table);
      }
      /* Table exists. Let us try to open it. */
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2938 2939 2940

    /* make a new table */
    if (!(table=(TABLE*) my_malloc(sizeof(*table),MYF(MY_WME))))
2941
    {
Marc Alff's avatar
Marc Alff committed
2942
      mysql_mutex_unlock(&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2943
      DBUG_RETURN(NULL);
2944
    }
2945

2946 2947 2948
    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
2949
    {
2950
      my_free((uchar*)table, MYF(0));
Marc Alff's avatar
Marc Alff committed
2951
      mysql_mutex_unlock(&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2952 2953
      DBUG_RETURN(NULL);
    }
2954
    if (table_list->view || error < 0)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2955
    {
2956 2957 2958 2959 2960
      /*
        VIEW not really opened, only frm were read.
        Set 1 as a flag here
      */
      if (error < 0)
Konstantin Osipov's avatar
Konstantin Osipov committed
2961
        table_list->view= (LEX*)1;
2962

2963
      my_free((uchar*)table, MYF(0));
Marc Alff's avatar
Marc Alff committed
2964
      mysql_mutex_unlock(&LOCK_open);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2965 2966
      DBUG_RETURN(0); // VIEW
    }
2967 2968 2969
    DBUG_PRINT("info", ("inserting table '%s'.'%s' 0x%lx into the cache",
                        table->s->db.str, table->s->table_name.str,
                        (long) table));
2970 2971 2972
    if (my_hash_insert(&open_cache,(uchar*) table))
    {
      my_free(table, MYF(0));
2973
      mysql_mutex_unlock(&LOCK_open);
2974 2975
      DBUG_RETURN(NULL);
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2976 2977
  }

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

Marc Alff's avatar
Marc Alff committed
2980
  mysql_mutex_unlock(&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2981 2982 2983 2984 2985 2986 2987 2988
  if (refresh)
  {
    table->next=thd->open_tables;		/* Link into simple list */
    thd->open_tables=table;
  }
  table->reginfo.lock_type=TL_READ;		/* Assume read */

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

2991 2992
  if (thd->lex->need_correct_ident())
    table->alias_name_used= my_strcasecmp(table_alias_charset,
2993
                                          table->s->table_name.str, alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2994
  /* Fix alias if table name changes */
2995
  if (strcmp(table->alias, alias))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2996
  {
2997
    uint length=(uint) strlen(alias)+1;
2998 2999 3000
    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
3001 3002 3003 3004 3005
  }
  /* These variables are also set in reopen_table() */
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
3006 3007
  table->null_row= table->maybe_null= 0;
  table->force_index= table->force_index_order= table->force_index_group= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3008
  table->status=STATUS_NO_RECORD;
3009
  table->insert_values= 0;
3010 3011
  table->fulltext_searched= 0;
  table->file->ft_handler= 0;
3012
  table->reginfo.impossible_range= 0;
3013 3014 3015
  /* Catch wrong handling of the auto_increment_field_not_null. */
  DBUG_ASSERT(!table->auto_increment_field_not_null);
  table->auto_increment_field_not_null= FALSE;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3016
  if (table->timestamp_field)
3017
    table->timestamp_field_type= table->timestamp_field->get_auto_set_type();
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3018
  table->pos_in_table_list= table_list;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3019
  table_list->updatable= 1; // It is not derived table nor non-updatable VIEW
3020
  table->clear_column_bitmaps();
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
3021
  DBUG_ASSERT(table->key_read == 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032
  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)
  {
3033 3034
    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
3035 3036 3037 3038 3039 3040
      return table;
  }
  return(0);
}


3041 3042
/*
  Reopen an table because the definition has changed.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3043

3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056
  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.
*/

3057
bool reopen_table(TABLE *table)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3058 3059
{
  TABLE tmp;
3060
  bool error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3061 3062
  Field **field;
  uint key,part;
3063 3064
  TABLE_LIST table_list;
  THD *thd= table->in_use;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3065
  DBUG_ENTER("reopen_table");
3066 3067
  DBUG_PRINT("tcache", ("table: '%s'.'%s' 0x%lx", table->s->db.str,
                        table->s->table_name.str, (long) table));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3068

3069 3070
  DBUG_ASSERT(table->s->ref_count == 0);
  DBUG_ASSERT(!table->sort.io_cache);
3071
  DBUG_ASSERT(!table->children_attached);
3072

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3073 3074 3075
#ifdef EXTRA_DEBUG
  if (table->db_stat)
    sql_print_error("Table %s had a open data handler in reopen_table",
3076
		    table->alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3077
#endif
3078
  bzero((char*) &table_list, sizeof(TABLE_LIST));
3079 3080 3081
  table_list.db=         table->s->db.str;
  table_list.table_name= table->s->table_name.str;
  table_list.table=      table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3082

3083 3084 3085 3086 3087 3088 3089
  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,
3090
                        thd->mem_root, 0))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3091 3092
    goto end;

3093
  /* This list copies variables set by open_table */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3094 3095 3096 3097
  tmp.tablenr=		table->tablenr;
  tmp.used_fields=	table->used_fields;
  tmp.const_table=	table->const_table;
  tmp.null_row=		table->null_row;
3098
  tmp.maybe_null=	table->maybe_null;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3099
  tmp.status=		table->status;
3100

3101 3102
  tmp.s->table_map_id=  table->s->table_map_id;

3103
  /* Get state */
3104
  tmp.in_use=    	thd;
3105
  tmp.reginfo.lock_type=table->reginfo.lock_type;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3106 3107
  tmp.grant=		table->grant;

3108
  /* Replace table in open list */
3109 3110
  tmp.next=		table->next;
  tmp.prev=		table->prev;
3111

3112 3113 3114 3115 3116 3117 3118
  /* Preserve MERGE parent. */
  tmp.parent=           table->parent;
  /* Fix MERGE child list and check for unchanged union. */
  if ((table->child_l || tmp.child_l) &&
      fix_merge_after_open(table->child_l, table->child_last_l,
                           tmp.child_l, tmp.child_last_l))
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
3119
    (void) closefrm(&tmp, 1); // close file, free everything
3120 3121 3122
    goto end;
  }

3123
  delete table->triggers;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3124
  if (table->file)
Konstantin Osipov's avatar
Konstantin Osipov committed
3125
    (void) closefrm(table, 1);		// close file, free everything
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3126

3127
  *table= tmp;
3128
  table->default_column_bitmaps();
3129
  table->file->change_table_ptr(table, table->s);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3130

3131
  DBUG_ASSERT(table->alias != 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3132 3133
  for (field=table->field ; *field ; field++)
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3134
    (*field)->table= (*field)->orig_table= table;
3135
    (*field)->table_name= &table->alias;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3136
  }
3137
  for (key=0 ; key < table->s->keys ; key++)
3138
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3139
    for (part=0 ; part < table->key_info[key].usable_key_parts ; part++)
3140
    {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3141
      table->key_info[key].key_part[part].field->table= table;
3142 3143
      table->key_info[key].key_part[part].field->orig_table= table;
    }
3144
  }
3145 3146
  if (table->triggers)
    table->triggers->set_table(table);
3147 3148 3149 3150 3151
  /*
    Do not attach MERGE children here. The children might be reopened
    after the parent. Attach children after reopening all tables that
    require reopen. See for example reopen_tables().
  */
3152

3153
  broadcast_refresh();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3154 3155 3156 3157 3158 3159 3160
  error=0;

 end:
  DBUG_RETURN(error);
}


3161
/**
3162 3163
    Close all instances of a table open by this thread and replace
    them with exclusive name-locks.
3164 3165 3166 3167 3168 3169 3170 3171 3172

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

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

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

3178 3179
void close_data_files_and_morph_locks(THD *thd, const char *db,
                                      const char *table_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3180 3181
{
  TABLE *table;
3182 3183
  DBUG_ENTER("close_data_files_and_morph_locks");

Marc Alff's avatar
Marc Alff committed
3184
  mysql_mutex_assert_owner(&LOCK_open);
3185 3186 3187 3188 3189 3190 3191 3192 3193 3194

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

3196 3197 3198 3199 3200
  /*
    Note that open table list may contain a name-lock placeholder
    for target table name if we process ALTER TABLE ... RENAME.
    So loop below makes sense even if we are not under LOCK TABLES.
  */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3201 3202
  for (table=thd->open_tables; table ; table=table->next)
  {
3203 3204
    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
3205
    {
3206
      if (thd->locked_tables)
3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222
      {
        if (table->parent)
        {
          /*
            If MERGE child, need to reopen parent too. This means that
            the first child to be closed will detach all children from
            the parent and close it. OTOH in most cases a MERGE table
            won't have multiple children with the same db.table_name.
          */
          mysql_lock_remove(thd, thd->locked_tables, table->parent, TRUE);
          table->parent->open_placeholder= 1;
          close_handle_and_leave_table_as_lock(table->parent);
        }
        else
          mysql_lock_remove(thd, thd->locked_tables, table, TRUE);
      }
3223
      table->open_placeholder= 1;
3224
      close_handle_and_leave_table_as_lock(table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3225 3226
    }
  }
3227
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3228 3229 3230
}


dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3231
/**
3232
  Reattach MERGE children after reopen.
3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286

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

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

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

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


dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3287
/**
3288
    Reopen all tables with closed data files.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3289 3290 3291

    @param thd         Thread context
    @param get_locks   Should we get locks after reopening tables ?
3292 3293
    @param mark_share_as_old  Mark share as old to protect from a impending
                              global read lock.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304

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

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

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

3307
bool reopen_tables(THD *thd, bool get_locks, bool mark_share_as_old)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3308
{
3309 3310
  TABLE *table,*next,**prev;
  TABLE **tables,**tables_ptr;			// For locks
3311
  TABLE *err_tables= NULL;
3312
  bool error=0, not_used;
3313
  bool merge_table_found= FALSE;
3314 3315 3316 3317
  const uint flags= MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN |
                    MYSQL_LOCK_IGNORE_GLOBAL_READ_LOCK |
                    MYSQL_LOCK_IGNORE_FLUSH;

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3320 3321 3322
  if (!thd->open_tables)
    DBUG_RETURN(0);

Marc Alff's avatar
Marc Alff committed
3323
  mysql_mutex_assert_owner(&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3324 3325
  if (get_locks)
  {
3326 3327 3328 3329
    /*
      The ptr is checked later
      Do not handle locks of MERGE children.
    */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3330
    uint opens=0;
3331
    for (table= thd->open_tables; table ; table=table->next)
3332 3333 3334
      if (!table->parent)
        opens++;
    DBUG_PRINT("tcache", ("open tables to lock: %u", opens));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345
    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;
3346 3347 3348 3349 3350 3351
    DBUG_PRINT("tcache", ("open table: '%s'.'%s' 0x%lx  "
                          "parent: 0x%lx  db_stat: %u",
                          table->s->db.str, table->s->table_name.str,
                          (long) table, (long) table->parent, db_stat));
    if (table->child_l && !db_stat)
      merge_table_found= TRUE;
3352
    if (!tables || (!db_stat && reopen_table(table)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3353
    {
3354
      my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365
      /*
        If we could not allocate 'tables', we may close open tables
        here. If a MERGE table is affected, detach the children first.
        It is not necessary to clear the child or parent table reference
        of this table because the TABLE is freed. But we need to clear
        the child or parent references of the other belonging tables so
        that they cannot be moved into the unused_tables chain with
        these pointers set.
      */
      if (table->child_l || table->parent)
        detach_merge_children(table, TRUE);
Konstantin Osipov's avatar
Konstantin Osipov committed
3366
      my_hash_delete(&open_cache,(uchar*) table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3367 3368 3369 3370
      error=1;
    }
    else
    {
3371 3372
      DBUG_PRINT("tcache", ("opened. need lock: %d",
                            get_locks && !db_stat && !table->parent));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3373 3374
      *prev= table;
      prev= &table->next;
3375 3376
      /* Do not handle locks of MERGE children. */
      if (get_locks && !db_stat && !table->parent)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3377
	*tables_ptr++= table;			// need new lock on this
3378
      if (mark_share_as_old)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3379
      {
3380
	table->s->version=0;
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3381
	table->open_placeholder= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3382 3383 3384
      }
    }
  }
3385 3386 3387 3388 3389 3390 3391 3392 3393 3394
  *prev=0;
  /*
    When all tables are open again, we can re-attach MERGE children to
    their parents. All TABLE objects are still present.
  */
  DBUG_PRINT("tcache", ("re-attaching MERGE tables: %d", merge_table_found));
  if (!error && merge_table_found && reattach_merge(thd, &err_tables))
  {
    while (err_tables)
    {
Konstantin Osipov's avatar
Konstantin Osipov committed
3395
      my_hash_delete(&open_cache, (uchar*) err_tables);
3396 3397 3398 3399 3400
      err_tables= err_tables->next;
    }
  }
  DBUG_PRINT("tcache", ("open tables to lock: %u",
                        (uint) (tables_ptr - tables)));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3401 3402 3403
  if (tables != tables_ptr)			// Should we get back old locks
  {
    MYSQL_LOCK *lock;
3404 3405 3406 3407 3408
    /*
      We should always get these locks. Anyway, we must not go into
      wait_for_tables() as it tries to acquire LOCK_open, which is
      already locked.
    */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3409
    thd->some_tables_deleted=0;
3410
    if ((lock= mysql_lock_tables(thd, tables, (uint) (tables_ptr - tables),
3411
                                 flags, &not_used)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3412 3413 3414 3415
    {
      thd->locked_tables=mysql_lock_merge(thd->locked_tables,lock);
    }
    else
3416 3417 3418 3419 3420 3421 3422
    {
      /*
        This case should only happen if there is a bug in the reopen logic.
        Need to issue error message to have a reply for the application.
        Not exactly what happened though, but close enough.
      */
      my_error(ER_LOCK_DEADLOCK, MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3423
      error=1;
3424
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3425 3426 3427
  }
  if (get_locks && tables)
  {
3428
    my_afree((uchar*) tables);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3429
  }
3430
  broadcast_refresh();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3431 3432 3433
  DBUG_RETURN(error);
}

3434

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3435
/**
3436 3437
    Close handlers for tables in list, but leave the TABLE structure
    intact so that we can re-open these quickly.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3438 3439 3440 3441 3442 3443 3444 3445 3446

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

3449 3450
static void close_old_data_files(THD *thd, TABLE *table, bool morph_locks,
                                 bool send_refresh)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3451
{
3452
  bool found= send_refresh;
3453
  DBUG_ENTER("close_old_data_files");
3454

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3455 3456
  for (; table ; table=table->next)
  {
3457 3458 3459 3460 3461
    DBUG_PRINT("tcache", ("checking table: '%s'.'%s' 0x%lx",
                          table->s->db.str, table->s->table_name.str,
                          (long) table));
    DBUG_PRINT("tcache", ("needs refresh: %d  is open: %u",
                          table->needs_reopen_or_name_lock(), table->db_stat));
3462
    /*
3463
      Reopen marked for flush.
3464
    */
3465
    if (table->needs_reopen_or_name_lock())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3466 3467 3468 3469
    {
      found=1;
      if (table->db_stat)
      {
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3470
	if (morph_locks)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3471
	{
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3472
          /*
3473 3474
            Forward lock handling to MERGE parent. But unlock parent
            once only.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3475
          */
3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499
          TABLE *ulcktbl= table->parent ? table->parent : table;
          if (ulcktbl->lock_count)
          {
            /*
              Wake up threads waiting for table-level lock on this table
              so they won't sneak in when we will temporarily remove our
              lock on it. This will also give them a chance to close their
              instances of this table.
            */
            mysql_lock_abort(thd, ulcktbl, TRUE);
            mysql_lock_remove(thd, thd->locked_tables, ulcktbl, TRUE);
            ulcktbl->lock_count= 0;
          }
          if ((ulcktbl != table) && ulcktbl->db_stat)
          {
            /*
              Close the parent too. Note that parent can come later in
              the list of tables. It will then be noticed as closed and
              as a placeholder. When this happens, do not clear the
              placeholder flag. See the branch below ("***").
            */
            ulcktbl->open_placeholder= 1;
            close_handle_and_leave_table_as_lock(ulcktbl);
          }
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3500 3501 3502 3503 3504
          /*
            We want to protect the table from concurrent DDL operations
            (like RENAME TABLE) until we will re-open and re-lock it.
          */
	  table->open_placeholder= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3505
	}
3506
        close_handle_and_leave_table_as_lock(table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3507
      }
3508
      else if (table->open_placeholder && !morph_locks)
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3509 3510 3511 3512 3513 3514 3515
      {
        /*
          We come here only in close-for-back-off scenario. So we have to
          "close" create placeholder here to avoid deadlocks (for example,
          in case of concurrent execution of CREATE TABLE t1 SELECT * FROM t2
          and RENAME TABLE t2 TO t1). In close-for-re-open scenario we will
          probably want to let it stay.
3516 3517 3518 3519

          Note "***": We must not enter this branch if the placeholder
          flag has been set because of a former close through a child.
          See above the comment that refers to this note.
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3520 3521 3522
        */
        table->open_placeholder= 0;
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3523 3524 3525
    }
  }
  if (found)
3526
    broadcast_refresh();
3527
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3528 3529 3530 3531 3532 3533 3534 3535 3536
}


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

3537
bool table_is_used(TABLE *table, bool wait_for_name_lock)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3538
{
3539
  DBUG_ENTER("table_is_used");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3540 3541
  do
  {
3542 3543 3544 3545
    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
3546
    HASH_SEARCH_STATE state;
Konstantin Osipov's avatar
Konstantin Osipov committed
3547 3548
    for (TABLE *search= (TABLE*) my_hash_first(&open_cache, (uchar*) key,
                                               key_length, &state);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3549
	 search ;
Konstantin Osipov's avatar
Konstantin Osipov committed
3550 3551
         search= (TABLE*) my_hash_next(&open_cache, (uchar*) key,
                                       key_length, &state))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3552
    {
3553
      DBUG_PRINT("info", ("share: 0x%lx  "
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3554
                          "open_placeholder: %d  locked_by_name: %d "
3555
                          "db_stat: %u  version: %lu",
3556
                          (ulong) search->s,
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3557
                          search->open_placeholder, search->locked_by_name,
3558 3559 3560 3561 3562 3563 3564 3565 3566
                          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
3567
        (We must wait until all engines are shut down to use the table)
3568
      */
3569 3570
      if ( (search->locked_by_name && wait_for_name_lock) ||
           (search->is_name_opened() && search->needs_reopen_or_name_lock()))
3571
        DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3572 3573
    }
  } while ((table=table->next));
3574
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3575 3576 3577 3578 3579 3580 3581 3582 3583 3584
}


/* Wait until all used tables are refreshed */

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

3585
  thd_proc_info(thd, "Waiting for tables");
Marc Alff's avatar
Marc Alff committed
3586
  mysql_mutex_lock(&LOCK_open);
3587
  while (!thd->killed)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3588
  {
3589 3590
    thd->some_tables_deleted=0;
    close_old_data_files(thd,thd->open_tables,0,dropping_tables != 0);
3591
    mysql_ha_flush(thd);
3592 3593
    if (!table_is_used(thd->open_tables,1))
      break;
Marc Alff's avatar
Marc Alff committed
3594
    mysql_cond_wait(&COND_refresh, &LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3595 3596 3597 3598 3599 3600
  }
  if (thd->killed)
    result= 1;					// aborted
  else
  {
    /* Now we can open all tables without any interference */
3601
    thd_proc_info(thd, "Reopen tables");
antony@ltantony.mysql.com's avatar
antony@ltantony.mysql.com committed
3602
    thd->version= refresh_version;
3603
    result=reopen_tables(thd,0,0);
3604
  }
Marc Alff's avatar
Marc Alff committed
3605
  mysql_mutex_unlock(&LOCK_open);
3606
  thd_proc_info(thd, 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3607 3608 3609 3610
  DBUG_RETURN(result);
}


3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627
/*
  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
3628

3629 3630 3631 3632 3633
  RETURN
    #    If table existed, return table
    0	 Table was not locked
*/

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

3635
TABLE *drop_locked_tables(THD *thd,const char *db, const char *table_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3636
{
3637
  TABLE *table,*next,**prev, *found= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3638
  prev= &thd->open_tables;
3639 3640
  DBUG_ENTER("drop_locked_tables");

3641 3642 3643 3644 3645 3646 3647
  /*
    Note that we need to hold LOCK_open while changing the
    open_tables list. Another thread may work on it.
    (See: remove_table_from_cache(), mysql_wait_completed_table())
    Closing a MERGE child before the parent would be fatal if the
    other thread tries to abort the MERGE lock in between.
  */
3648
  for (table= thd->open_tables; table ; table=next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3649 3650
  {
    next=table->next;
3651 3652
    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
3653
    {
3654 3655 3656 3657 3658 3659 3660 3661 3662 3663
      /* If MERGE child, forward lock handling to parent. */
      mysql_lock_remove(thd, thd->locked_tables,
                        table->parent ? table->parent : table, TRUE);
      /*
        When closing a MERGE parent or child table, detach the children first.
        Clear child table references in case this object is opened again.
      */
      if (table->child_l || table->parent)
        detach_merge_children(table, TRUE);

3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676
      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 */
Konstantin Osipov's avatar
Konstantin Osipov committed
3677
        my_hash_delete(&open_cache,(uchar*) table);
3678
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3679 3680 3681 3682 3683 3684 3685 3686 3687
    }
    else
    {
      *prev=table;
      prev= &table->next;
    }
  }
  *prev=0;
  if (found)
3688
    broadcast_refresh();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3689 3690
  if (thd->locked_tables && thd->locked_tables->table_count == 0)
  {
3691
    my_free((uchar*) thd->locked_tables,MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3692 3693
    thd->locked_tables=0;
  }
3694
  DBUG_RETURN(found);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3695 3696 3697
}


3698 3699 3700 3701 3702
/*
  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
3703 3704 3705 3706

void abort_locked_tables(THD *thd,const char *db, const char *table_name)
{
  TABLE *table;
3707
  for (table= thd->open_tables; table ; table= table->next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3708
  {
3709 3710
    if (!strcmp(table->s->table_name.str, table_name) &&
	!strcmp(table->s->db.str, db))
3711
    {
3712 3713
      /* If MERGE child, forward lock handling to parent. */
      mysql_lock_abort(thd, table->parent ? table->parent : table, TRUE);
3714 3715
      break;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3716 3717 3718
  }
}

3719

3720
/*
3721
  Function to assign a new table map id to a table share.
3722 3723 3724

  PARAMETERS

3725
    share - Pointer to table share structure
3726

mats@mysql.com's avatar
mats@mysql.com committed
3727 3728 3729 3730 3731 3732 3733
  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).

3734 3735
  PRE-CONDITION(S)

3736
    share is non-NULL
3737 3738 3739 3740
    The LOCK_open mutex is locked

  POST-CONDITION(S)

3741 3742 3743
    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
3744 3745
    share opens have been executed while one table was open all the
    time).
3746

3747
    share->table_map_id is not ~0UL.
3748
 */
3749 3750
static ulong last_table_id= ~0UL;

3751
void assign_new_table_id(TABLE_SHARE *share)
3752 3753
{

3754
  DBUG_ENTER("assign_new_table_id");
3755 3756

  /* Preconditions */
3757
  DBUG_ASSERT(share != NULL);
Marc Alff's avatar
Marc Alff committed
3758
  mysql_mutex_assert_owner(&LOCK_open);
3759 3760

  ulong tid= ++last_table_id;                   /* get next id */
3761 3762 3763 3764
  /*
    There is one reserved number that cannot be used.  Remember to
    change this when 6-byte global table id's are introduced.
  */
3765
  if (unlikely(tid == ~0UL))
3766
    tid= ++last_table_id;
3767
  share->table_map_id= tid;
3768 3769 3770
  DBUG_PRINT("info", ("table_id=%lu", tid));

  /* Post conditions */
3771
  DBUG_ASSERT(share->table_map_id != ~0UL);
3772 3773 3774 3775

  DBUG_VOID_RETURN;
}

3776
#ifndef DBUG_OFF
3777
/* Cause a spurious statement reprepare for debug purposes. */
3778
static bool inject_reprepare(THD *thd)
3779 3780 3781 3782 3783 3784 3785 3786 3787
{
  if (thd->m_reprepare_observer && thd->stmt_arena->is_reprepared == FALSE)
  {
    thd->m_reprepare_observer->report_error(thd);
    return TRUE;
  }

  return FALSE;
}
3788
#endif
3789

3790 3791 3792 3793
/**
  Compare metadata versions of an element obtained from the table
  definition cache and its corresponding node in the parse tree.

3794
  @details If the new and the old values mismatch, invoke
3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808
  Metadata_version_observer.
  At prepared statement prepare, all TABLE_LIST version values are
  NULL and we always have a mismatch. But there is no observer set
  in THD, and therefore no error is reported. Instead, we update
  the value in the parse tree, effectively recording the original
  version.
  At prepared statement execute, an observer may be installed.  If
  there is a version mismatch, we push an error and return TRUE.

  For conventional execution (no prepared statements), the
  observer is never installed.

  @sa Execute_observer
  @sa check_prepared_statement() to see cases when an observer is installed
3809 3810
  @sa TABLE_LIST::is_table_ref_id_equal()
  @sa TABLE_SHARE::get_table_ref_id()
3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825

  @param[in]      thd         used to report errors
  @param[in,out]  tables      TABLE_LIST instance created by the parser
                              Metadata version information in this object
                              is updated upon success.
  @param[in]      table_share an element from the table definition cache

  @retval  TRUE  an error, which has been reported
  @retval  FALSE success, version in TABLE_LIST has been updated
*/

bool
check_and_update_table_version(THD *thd,
                               TABLE_LIST *tables, TABLE_SHARE *table_share)
{
3826
  if (! tables->is_table_ref_id_equal(table_share))
3827
  {
3828 3829
    if (thd->m_reprepare_observer &&
        thd->m_reprepare_observer->report_error(thd))
3830 3831 3832 3833 3834 3835
    {
      /*
        Version of the table share is different from the
        previous execution of the prepared statement, and it is
        unacceptable for this SQLCOM. Error has been reported.
      */
3836
      DBUG_ASSERT(thd->is_error());
3837 3838
      return TRUE;
    }
3839
    /* Always maintain the latest version and type */
3840
    tables->set_table_ref_id(table_share);
3841
  }
3842

3843
  DBUG_EXECUTE_IF("reprepare_each_statement", return inject_reprepare(thd););
3844

3845 3846 3847
  return FALSE;
}

3848 3849 3850 3851 3852 3853 3854
/*
  Load a table definition from file and open unireg table

  SYNOPSIS
    open_unireg_entry()
    thd			Thread handle
    entry		Store open table definition here
3855
    table_list		TABLE_LIST with db, table_name & belong_to_view
3856
    alias		Alias name
3857 3858
    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
3859
    mem_root		temporary mem_root for parsing
3860 3861
    flags               the OPEN_VIEW_NO_PARSE flag to be passed to
                        openfrm()/open_new_frm()
3862 3863 3864

  NOTES
   Extra argument for open is taken from thd->open_options
3865
   One must have a lock on LOCK_open when calling this function
3866 3867 3868 3869

  RETURN
    0	ok
    #	Error
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3870
*/
3871 3872 3873

static int open_unireg_entry(THD *thd, TABLE *entry, TABLE_LIST *table_list,
                             const char *alias,
3874
                             char *cache_key, uint cache_key_length,
3875
                             MEM_ROOT *mem_root, uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3876
{
3877
  int error;
3878
  TABLE_SHARE *share;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3879
  uint discover_retry_count= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3880 3881
  DBUG_ENTER("open_unireg_entry");

Marc Alff's avatar
Marc Alff committed
3882
  mysql_mutex_assert_owner(&LOCK_open);
3883 3884 3885
retry:
  if (!(share= get_table_share_with_create(thd, table_list, cache_key,
                                           cache_key_length, 
3886 3887 3888
                                           OPEN_VIEW |
                                           table_list->i_s_requested_object,
                                           &error)))
3889 3890 3891 3892
    DBUG_RETURN(1);

  if (share->is_view)
  {
3893 3894 3895 3896 3897 3898 3899 3900 3901 3902
    /*
      If parent_l of the table_list is non null then a merge table
      has this view as child table, which is not supported.
    */
    if (table_list->parent_l)
    {
      my_error(ER_WRONG_MRG_TABLE, MYF(0));
      goto err;
    }

3903 3904 3905 3906
    /*
      This table is a view. Validate its metadata version: in particular,
      that it was a view when the statement was prepared.
    */
3907 3908
    if (check_and_update_table_version(thd, table_list, share))
      goto err;
3909 3910 3911
    if (table_list->i_s_requested_object &  OPEN_TABLE_ONLY)
      goto err;

3912 3913 3914 3915
    /* Open view */
    error= (int) open_new_frm(thd, share, alias,
                              (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
                                      HA_GET_INDEX | HA_TRY_READ_ONLY),
3916 3917
                              READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD |
                              (flags & OPEN_VIEW_NO_PARSE),
3918
                              thd->open_options, entry, table_list,
3919
                              mem_root);
3920 3921 3922 3923
    if (error)
      goto err;
    /* TODO: Don't free this */
    release_table_share(share, RELEASE_NORMAL);
3924
    DBUG_RETURN((flags & OPEN_VIEW_NO_PARSE)? -1 : 0);
3925
  }
3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939
  else if (table_list->view)
  {
    /*
      We're trying to open a table for what was a view.
      This can only happen during (re-)execution.
      At prepared statement prepare the view has been opened and
      merged into the statement parse tree. After that, someone
      performed a DDL and replaced the view with a base table.
      Don't try to open the table inside a prepared statement,
      invalidate it instead.

      Note, the assert below is known to fail inside stored
      procedures (Bug#27011).
    */
3940
    DBUG_ASSERT(thd->m_reprepare_observer);
3941 3942 3943 3944 3945
    check_and_update_table_version(thd, table_list, share);
    /* Always an error. */
    DBUG_ASSERT(thd->is_error());
    goto err;
  }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3946

3947 3948 3949
  if (table_list->i_s_requested_object &  OPEN_VIEW_ONLY)
    goto err;

3950 3951 3952 3953 3954 3955 3956
  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),
3957
                                       thd->open_options, entry, FALSE)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3958
  {
3959
    if (error == 7)                             // Table def changed
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3960
    {
3961 3962 3963 3964
      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
3965
      /*
3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976
        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
3977
      */
3978 3979
      if (ha_create_table_from_engine(thd, table_list->db,
                                      table_list->table_name))
monty@mysql.com's avatar
monty@mysql.com committed
3980
        goto err;
3981 3982 3983 3984 3985 3986
      /*
        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
3987
        goto err;
3988 3989 3990
      /* Free share and wait until it's released by all threads */
      release_table_share(share, RELEASE_WAIT_FOR_DROP);
      if (!thd->killed)
3991
      {
Marc Alff's avatar
Marc Alff committed
3992
        thd->warning_info->clear_warning_info(thd->query_id);
3993 3994
        thd->clear_error();                 // Clear error message
        goto retry;
3995
      }
3996
      DBUG_RETURN(1);
3997
    }
3998
    if (!entry->s || !entry->s->crashed)
3999
      goto err;
4000
     // Code below is for repairing a crashed file
4001
     if ((error= lock_table_name(thd, table_list, TRUE)))
4002 4003 4004 4005 4006 4007 4008 4009 4010
     {
       if (error < 0)
 	goto err;
       if (wait_for_locked_table_names(thd, table_list))
       {
 	unlock_table_name(thd, table_list);
 	goto err;
       }
     }
Marc Alff's avatar
Marc Alff committed
4011
     mysql_mutex_unlock(&LOCK_open);
4012 4013 4014 4015 4016 4017 4018 4019
     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,
4020
                               entry, FALSE) || ! entry->file ||
4021
        (entry->file->is_crashed() && entry->file->ha_check_and_repair(thd)))
4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033
     {
       /* 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
Marc Alff's avatar
Marc Alff committed
4034
     mysql_mutex_lock(&LOCK_open);
4035 4036 4037 4038 4039 4040
     unlock_table_name(thd, table_list);
 
     if (error)
       goto err;
     break;
   }
4041

4042 4043 4044 4045
  if (Table_triggers_list::check_n_load(thd, share->db.str,
                                        share->table_name.str, entry, 0))
  {
    closefrm(entry, 0);
4046
    goto err;
4047
  }
4048

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4049 4050 4051 4052 4053 4054 4055 4056 4057 4058
  /*
    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;
4059 4060
      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
4061
      {
4062
        /* this DELETE FROM is needed even with row-based binlogging */
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4063
        end = strxmov(strmov(query, "DELETE FROM `"),
4064
                      share->db.str,"`.`",share->table_name.str,"`", NullS);
4065
        int errcode= query_error_code(thd, TRUE);
4066 4067 4068 4069 4070 4071 4072
        if (thd->binlog_query(THD::STMT_QUERY_TYPE,
                              query, (ulong)(end-query),
                              FALSE, FALSE, errcode))
        {
          my_free(query, MYF(0));
          goto err;
        }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4073 4074 4075 4076 4077 4078 4079 4080 4081
        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).
        */
4082 4083 4084
        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);
4085
        delete entry->triggers;
4086
        closefrm(entry, 0);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4087 4088 4089
        goto err;
      }
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4090 4091
  }
  DBUG_RETURN(0);
4092

4093
err:
4094
  release_table_share(share, RELEASE_NORMAL);
4095
  DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4096 4097
}

4098

4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287
/**
  @brief Add list of MERGE children to a TABLE_LIST list.

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

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

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

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

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

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

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

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

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

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

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

  DBUG_RETURN(0);
}


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

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

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

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

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

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

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

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

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

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

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

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

  DBUG_RETURN(0);
}


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

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

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

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

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

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

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

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

  /*
    In a open_tables() loop it can happen that not all tables have their
    children attached yet. Also this is called for every child and the
    parent from close_thread_tables().
  */
  if ((first_detach= parent->children_attached))
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
4288
    (void) parent->file->extra(HA_EXTRA_DETACH_CHILDREN);
4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432
    parent->children_attached= FALSE;
    DBUG_PRINT("myrg", ("detached parent: '%s'.'%s' 0x%lx", parent->s->db.str,
                        parent->s->table_name.str, (long) parent));
  }
  else
    DBUG_PRINT("myrg", ("parent is already detached"));

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

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

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

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

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

  DBUG_VOID_RETURN;
}


/**
  @brief Fix MERGE children after open.

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

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

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

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

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

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

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

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

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

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

  DBUG_RETURN(mismatch);
}


4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454
/*
  Return a appropriate read lock type given a table object.

  @param thd Thread context
  @param table TABLE object for table to be locked

  @remark Due to a statement-based replication limitation, statements such as
          INSERT INTO .. SELECT FROM .. and CREATE TABLE .. SELECT FROM need
          to grab a TL_READ_NO_INSERT lock on the source table in order to
          prevent the replication of a concurrent statement that modifies the
          source table. If such a statement gets applied on the slave before
          the INSERT .. SELECT statement finishes, data on the master could
          differ from data on the slave and end-up with a discrepancy between
          the binary log and table state. Furthermore, this does not apply to
          I_S and log tables as it's always unsafe to replicate such tables
          under statement-based replication as the table on the slave might
          contain other data (ie: general_log is enabled on the slave). The
          statement will be marked as unsafe for SBR in decide_logging_format().
*/

thr_lock_type read_lock_type_for_table(THD *thd, TABLE *table)
{
4455
  bool log_on= mysql_bin_log.is_open() && (thd->variables.option_bits & OPTION_BIN_LOG);
4456 4457
  ulong binlog_format= thd->variables.binlog_format;
  if ((log_on == FALSE) || (binlog_format == BINLOG_FORMAT_ROW) ||
Marc Alff's avatar
Marc Alff committed
4458
      (table->s->table_category == TABLE_CATEGORY_LOG) ||
4459 4460 4461 4462 4463 4464 4465
      (table->s->table_category == TABLE_CATEGORY_PERFORMANCE))
    return TL_READ;
  else
    return TL_READ_NO_INSERT;
}


igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4466 4467 4468 4469 4470 4471
/*
  Open all tables in list

  SYNOPSIS
    open_tables()
    thd - thread handler
4472
    start - list of tables in/out
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4473
    counter - number of opened tables will be return using this parameter
4474 4475 4476
    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
4477

4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488
  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.

4489 4490 4491 4492 4493
    If any table has a trigger and start->trg_event_map is non-zero
    the final lock will end up in thd->locked_tables, otherwise, the
    lock will be placed in thd->lock. See also comments in
    st_lex::set_trg_event_type_for_tables().

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4494 4495 4496 4497 4498
  RETURN
    0  - OK
    -1 - error
*/

4499
int open_tables(THD *thd, TABLE_LIST **start, uint *counter, uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4500
{
4501
  TABLE_LIST *tables= NULL;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4502 4503
  bool refresh;
  int result=0;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4504
  MEM_ROOT new_frm_mem;
4505 4506
  /* Also used for indicating that prelocking is need */
  TABLE_LIST **query_tables_last_own;
4507 4508
  bool safe_to_ignore_table;

4509
  DBUG_ENTER("open_tables");
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4510 4511 4512 4513
  /*
    temporary mem_root for new .frm parsing.
    TODO: variables for size
  */
4514
  init_sql_alloc(&new_frm_mem, 8024, 8024);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4515

4516
  thd->current_tablenr= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4517
 restart:
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4518
  *counter= 0;
4519
  query_tables_last_own= 0;
4520
  thd_proc_info(thd, "Opening tables");
4521 4522 4523 4524 4525 4526 4527

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

  */
4528 4529

  if (!thd->prelocked_mode && !thd->lex->requires_prelocking() &&
4530
      thd->lex->uses_stored_routines())
4531
  {
4532
    bool first_no_prelocking, need_prelocking;
4533
    TABLE_LIST **save_query_tables_last= thd->lex->query_tables_last;
4534 4535

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

4538
    if (sp_cache_routines_and_add_tables(thd, thd->lex, first_no_prelocking))
4539
    {
4540 4541 4542 4543 4544 4545
      /*
        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;
4546 4547
      goto err;
    }
4548
    else if (need_prelocking)
4549 4550 4551 4552 4553 4554
    {
      query_tables_last_own= save_query_tables_last;
      *start= thd->lex->query_tables;
    }
  }

4555 4556 4557 4558
  /*
    For every table in the list of tables to open, try to find or open
    a table.
  */
4559
  for (tables= *start; tables ;tables= tables->next_global)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4560
  {
4561
    safe_to_ignore_table= FALSE;
4562

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4563 4564 4565
    /*
      Ignore placeholders for derived tables. After derived tables
      processing, link to created temporary table will be put here.
4566 4567
      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
4568 4569
     */
    if (tables->derived)
4570 4571 4572
    {
      if (tables->view)
        goto process_view_routines;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4573
      continue;
4574
    }
4575 4576 4577 4578 4579 4580
    /*
      If this TABLE_LIST object is a placeholder for an information_schema
      table, create a temporary table to represent the information_schema
      table in the query. Do not fill it yet - will be filled during
      execution.
    */
4581 4582
    if (tables->schema_table)
    {
4583 4584 4585 4586 4587 4588 4589 4590 4591 4592
      /*
        If this information_schema table is merged into a mergeable
        view, ignore it for now -- it will be filled when its respective
        TABLE_LIST is processed. This code works only during re-execution.
      */
      if (tables->view)
        goto process_view_routines;
      if (!mysql_schema_table(thd, thd->lex, tables) &&
          !check_and_update_table_version(thd, tables, tables->table->s))
      {
4593
        continue;
4594
      }
4595 4596
      DBUG_RETURN(-1);
    }
4597 4598
    DBUG_PRINT("tcache", ("opening table: '%s'.'%s'  item: 0x%lx",
                          tables->db, tables->table_name, (long) tables));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4599
    (*counter)++;
4600 4601 4602 4603 4604

    /*
      Not a placeholder: must be a base table or a view, and the table is
      not opened yet. Try to open the table.
    */
4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623
    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);
    }
4624 4625 4626 4627
    else
      DBUG_PRINT("tcache", ("referenced table: '%s'.'%s' 0x%lx",
                            tables->db, tables->table_name,
                            (long) tables->table));
4628 4629

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

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4633 4634
      if (tables->view)
      {
4635
        /* VIEW placeholder */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4636
	(*counter)--;
4637

4638
        /*
4639 4640 4641 4642 4643
          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
4644 4645 4646
          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.
4647
        */
4648
        if (query_tables_last_own == &(tables->next_global) &&
4649 4650
            tables->view->query_tables)
          query_tables_last_own= tables->view->query_tables_last;
4651
        /*
4652 4653
          Let us free memory used by 'sroutines' hash here since we never
          call destructor for this LEX.
4654
        */
Konstantin Osipov's avatar
Konstantin Osipov committed
4655
        my_hash_free(&tables->view->sroutines);
4656
	goto process_view_routines;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4657 4658
      }

4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671
      /*
        If in a MERGE table open, we need to remove the children list
        from statement table list before restarting. Otherwise the list
        will be inserted another time.
      */
      if (tables->parent_l)
      {
        TABLE_LIST *parent_l= tables->parent_l;
        /* The parent table should be correctly open at this point. */
        DBUG_ASSERT(parent_l->table);
        parent_l->next_global= *parent_l->table->child_last_l;
      }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4672 4673
      if (refresh)				// Refresh in progress
      {
4674
        /*
4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686
          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.
4687 4688 4689
        */
        if (query_tables_last_own)
          thd->lex->mark_as_requiring_prelocking(query_tables_last_own);
4690
        close_tables_for_reopen(thd, start);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4691 4692
	goto restart;
      }
4693 4694 4695 4696 4697 4698 4699 4700

      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
4701 4702 4703
      result= -1;				// Fatal error
      break;
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4704
    else
4705 4706 4707 4708 4709 4710 4711 4712 4713 4714
    {
      /*
        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() &&
4715
          tables->trg_event_map && tables->table->triggers &&
4716 4717 4718
          tables->lock_type >= TL_WRITE_ALLOW_WRITE)
      {
        if (!query_tables_last_own)
4719 4720
          query_tables_last_own= thd->lex->query_tables_last;
        if (sp_cache_routines_and_add_tables_for_triggers(thd, thd->lex,
4721
                                                          tables))
4722
        {
4723 4724 4725 4726 4727 4728
          /*
            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;
4729 4730
          goto err;
        }
4731
      }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4732
      free_root(&new_frm_mem, MYF(MY_KEEP_PREALLOC));
4733
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4734

4735
    if (tables->lock_type != TL_UNLOCK && ! thd->locked_tables)
4736 4737 4738
    {
      if (tables->lock_type == TL_WRITE_DEFAULT)
        tables->table->reginfo.lock_type= thd->update_lock_default;
4739 4740 4741
      else if (tables->lock_type == TL_READ_DEFAULT)
        tables->table->reginfo.lock_type=
          read_lock_type_for_table(thd, tables->table);
4742
      else
4743 4744
        tables->table->reginfo.lock_type= tables->lock_type;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4745
    tables->table->grant= tables->grant;
4746

4747
    /* Check and update metadata version of a base table. */
4748 4749 4750 4751 4752 4753
    if (check_and_update_table_version(thd, tables, tables->table->s))
    {
      result= -1;
      goto err;
    }

4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771
    /* Attach MERGE children if not locked already. */
    DBUG_PRINT("tcache", ("is parent: %d  is child: %d",
                          test(tables->table->child_l),
                          test(tables->parent_l)));
    DBUG_PRINT("tcache", ("in lock tables: %d  in prelock mode: %d",
                          test(thd->locked_tables), test(thd->prelocked_mode)));
    if (((!thd->locked_tables && !thd->prelocked_mode) ||
         tables->table->s->tmp_table) &&
        ((tables->table->child_l &&
          add_merge_table_list(tables)) ||
         (tables->parent_l &&
          (&tables->next_global == tables->parent_l->table->child_last_l) &&
          attach_merge_children(tables))))
    {
      result= -1;
      goto err;
    }

4772 4773 4774 4775 4776 4777 4778
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() &&
4779
        tables->view->uses_stored_routines())
4780 4781 4782 4783
    {
      /* We have at least one table in TL here. */
      if (!query_tables_last_own)
        query_tables_last_own= thd->lex->query_tables_last;
4784
      if (sp_cache_routines_and_add_tables_for_view(thd, thd->lex, tables))
4785
      {
4786 4787
        /*
          Serious error during reading stored routines from mysql.proc table.
4788
          Something is wrong with the table or its contents, and an error has
4789 4790 4791
          been emitted; we must abort.
        */
        result= -1;
4792 4793
        goto err;
      }
4794
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4795
  }
4796 4797

 err:
4798
  thd_proc_info(thd, 0);
4799
  free_root(&new_frm_mem, MYF(0));              // Free pre-alloced block
4800 4801 4802 4803

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

4804 4805 4806 4807 4808 4809 4810 4811
  if (result && tables)
  {
    /*
      Some functions determine success as (tables->table != NULL).
      tables->table is in thd->open_tables. It won't go lost. If the
      error happens on a MERGE child, clear the parents TABLE reference.
    */
    if (tables->parent_l)
4812 4813 4814
    {
      if (tables->parent_l->next_global == tables->parent_l->table->child_l)
        tables->parent_l->next_global= *tables->parent_l->table->child_last_l;
4815
      tables->parent_l->table= NULL;
4816
    }
4817 4818 4819
    tables->table= NULL;
  }
  DBUG_PRINT("tcache", ("returning: %d", result));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4820 4821 4822 4823
  DBUG_RETURN(result);
}


4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846
/*
  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)
  {
4847
    my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),table->alias);
4848 4849
    DBUG_RETURN(1);
  }
serg@serg.mylan's avatar
serg@serg.mylan committed
4850
  if ((error=table->file->start_stmt(thd, lock_type)))
4851 4852 4853 4854 4855 4856 4857 4858
  {
    table->file->print_error(error,MYF(0));
    DBUG_RETURN(1);
  }
  DBUG_RETURN(0);
}


4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915
/**
  @brief Open and lock one table

  @param[in]    thd             thread handle
  @param[in]    table_l         table to open is first table in this list
  @param[in]    lock_type       lock to use for table

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

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

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

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

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

TABLE *open_n_lock_single_table(THD *thd, TABLE_LIST *table_l,
                                thr_lock_type lock_type)
{
  TABLE_LIST *save_next_global;
  DBUG_ENTER("open_n_lock_single_table");

  /* Remember old 'next' pointer. */
  save_next_global= table_l->next_global;
  /* Break list. */
  table_l->next_global= NULL;

  /* Set requested lock type. */
  table_l->lock_type= lock_type;
  /* Allow to open real tables only. */
  table_l->required_type= FRMTYPE_TABLE;

  /* Open the table. */
  if (simple_open_n_lock_tables(thd, table_l))
    table_l->table= NULL; /* Just to be sure. */

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

  DBUG_RETURN(table_l->table);
}


4916 4917 4918 4919 4920 4921 4922 4923
/*
  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
4924
    lock_flags          Flags passed to mysql_lock_table
4925

4926
  NOTE
4927
    This function doesn't do anything like SP/SF/views/triggers analysis done 
Staale Smedseng's avatar
Staale Smedseng committed
4928
    in open_table()/lock_tables(). It is intended for opening of only one
4929
    concrete table. And used only in special contexts.
4930

4931 4932 4933 4934 4935 4936 4937 4938 4939
  RETURN VALUES
    table		Opened table
    0			Error
  
    If ok, the following are also set:
      table_list->lock_type 	lock_type
      table_list->table		table
*/

4940 4941
TABLE *open_ltable(THD *thd, TABLE_LIST *table_list, thr_lock_type lock_type,
                   uint lock_flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4942 4943 4944 4945 4946
{
  TABLE *table;
  bool refresh;
  DBUG_ENTER("open_ltable");

Staale Smedseng's avatar
Staale Smedseng committed
4947 4948 4949
  /* should not be used in a prelocked_mode context, see NOTE above */
  DBUG_ASSERT(!thd->prelocked_mode);

4950
  thd_proc_info(thd, "Opening table");
4951
  thd->current_tablenr= 0;
4952 4953
  /* open_ltable can be used only for BASIC TABLEs */
  table_list->required_type= FRMTYPE_TABLE;
4954
  while (!(table= open_table(thd, table_list, thd->mem_root, &refresh, 0)) &&
4955
         refresh)
4956
    ;
4957

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4958 4959
  if (table)
  {
4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970
    if (table->child_l)
    {
      /* A MERGE table must not come here. */
      /* purecov: begin tested */
      my_error(ER_WRONG_OBJECT, MYF(0), table->s->db.str,
               table->s->table_name.str, "BASE TABLE");
      table= 0;
      goto end;
      /* purecov: end */
    }

4971 4972
    table_list->lock_type= lock_type;
    table_list->table=	   table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4973 4974 4975
    table->grant= table_list->grant;
    if (thd->locked_tables)
    {
4976 4977 4978 4979 4980
      if (check_lock_and_start_stmt(thd, table, lock_type))
	table= 0;
    }
    else
    {
4981
      DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
4982
      if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)
4983 4984
	if (! (thd->lock= mysql_lock_tables(thd, &table_list->table, 1,
                                            lock_flags, &refresh)))
4985
	  table= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4986 4987
    }
  }
4988 4989

 end:
4990
  thd_proc_info(thd, 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4991 4992 4993
  DBUG_RETURN(table);
}

4994

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4995
/*
4996
  Open all tables in list, locks them and optionally process derived tables.
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4997 4998

  SYNOPSIS
4999
    open_and_lock_tables_derived()
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5000 5001
    thd		- thread handler
    tables	- list of tables for open&locking
5002
    derived     - if to handle derived tables
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5003 5004

  RETURN
5005 5006
    FALSE - ok
    TRUE  - error
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5007 5008

  NOTE
5009
    The lock will automaticaly be freed by close_thread_tables()
5010 5011 5012 5013 5014 5015 5016

  NOTE
    There are two convenience functions:
    - simple_open_n_lock_tables(thd, tables)  without derived handling
    - open_and_lock_tables(thd, tables)       with derived handling
    Both inline functions call open_and_lock_tables_derived() with
    the third argument set appropriately.
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5017 5018
*/

5019
int open_and_lock_tables_derived(THD *thd, TABLE_LIST *tables, bool derived)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5020 5021
{
  uint counter;
5022
  bool need_reopen;
5023 5024
  DBUG_ENTER("open_and_lock_tables_derived");
  DBUG_PRINT("enter", ("derived handling: %d", derived));
5025 5026 5027 5028 5029

  for ( ; ; ) 
  {
    if (open_tables(thd, &tables, &counter, 0))
      DBUG_RETURN(-1);
5030 5031 5032 5033 5034 5035 5036

    DBUG_EXECUTE_IF("sleep_open_and_lock_after_open", {
      const char *old_proc_info= thd->proc_info;
      thd->proc_info= "DBUG sleep";
      my_sleep(6000000);
      thd->proc_info= old_proc_info;});

5037 5038 5039 5040
    if (!lock_tables(thd, tables, counter, &need_reopen))
      break;
    if (!need_reopen)
      DBUG_RETURN(-1);
5041
    close_tables_for_reopen(thd, &tables);
5042
  }
5043 5044 5045 5046
  if (derived &&
      (mysql_handle_derived(thd->lex, &mysql_derived_prepare) ||
       (thd->fill_derived_tables() &&
        mysql_handle_derived(thd->lex, &mysql_derived_filling))))
5047
    DBUG_RETURN(TRUE); /* purecov: inspected */
monty@mysql.com's avatar
monty@mysql.com committed
5048
  DBUG_RETURN(0);
monty@mysql.com's avatar
monty@mysql.com committed
5049 5050 5051
}


5052 5053 5054 5055 5056 5057
/*
  Open all tables in list and process derived tables

  SYNOPSIS
    open_normal_and_derived_tables
    thd		- thread handler
5058
    tables	- list of tables for open
5059 5060 5061
    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.
5062 5063 5064 5065 5066 5067 5068 5069 5070 5071

  RETURN
    FALSE - ok
    TRUE  - error

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

5072
bool open_normal_and_derived_tables(THD *thd, TABLE_LIST *tables, uint flags)
5073 5074 5075
{
  uint counter;
  DBUG_ENTER("open_normal_and_derived_tables");
monty@mysql.com's avatar
monty@mysql.com committed
5076
  DBUG_ASSERT(!thd->fill_derived_tables());
5077
  if (open_tables(thd, &tables, &counter, flags) ||
monty@mysql.com's avatar
monty@mysql.com committed
5078 5079 5080
      mysql_handle_derived(thd->lex, &mysql_derived_prepare))
    DBUG_RETURN(TRUE); /* purecov: inspected */
  DBUG_RETURN(0);
5081 5082 5083
}


5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099
/*
  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)
5100
    if (!table->placeholder())
5101 5102 5103 5104
      table->table->query_id= 0;
}


5105 5106
/**
   Decide on logging format to use for the statement.
5107

5108 5109 5110 5111
   Compute the capabilities vector for the involved storage engines
   and mask out the flags for the binary log. Right now, the binlog
   flags only include the capabilities of the storage engines, so this
   is safe.
5112

5113 5114
   We now have three alternatives that prevent the statement from
   being loggable:
5115

5116 5117 5118
   1. If there are no capabilities left (all flags are clear) it is
      not possible to log the statement at all, so we roll back the
      statement and report an error.
5119

5120 5121
   2. Statement mode is set, but the capabilities indicate that
      statement format is not possible.
5122

5123 5124
   3. Row mode is set, but the capabilities indicate that row
      format is not possible.
5125

5126 5127 5128 5129 5130 5131
   4. Statement is unsafe, but the capabilities indicate that row
      format is not possible.

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

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

5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143
   2. If statement-based logging is not possible, row-based logging is
      used.

   3. Otherwise, statement-based logging is used.

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

int decide_logging_format(THD *thd, TABLE_LIST *tables)
{
5144 5145 5146 5147 5148 5149 5150
  /*
    In SBR mode, we are only proceeding if we are binlogging this
    statement, ie, the filtering rules won't later filter this out.

    This check here is needed to prevent some spurious error to be
    raised in some cases (See BUG#42829).
   */
5151
  if (mysql_bin_log.is_open() && (thd->variables.option_bits & OPTION_BIN_LOG) &&
5152 5153
      (thd->variables.binlog_format != BINLOG_FORMAT_STMT ||
       binlog_filter->db_ok(thd->db)))
5154
  {
Mats Kindahl's avatar
Mats Kindahl committed
5155 5156 5157 5158 5159 5160 5161 5162 5163
    /*
      Compute the starting vectors for the computations by creating a
      set with all the capabilities bits set and one with no
      capabilities bits set.
     */
    handler::Table_flags flags_some_set= 0;
    handler::Table_flags flags_all_set=
      HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE;

5164 5165
    my_bool multi_engine= FALSE;
    void* prev_ht= NULL;
5166
    for (TABLE_LIST *table= tables; table; table= table->next_global)
5167
    {
Marc Alff's avatar
Marc Alff committed
5168
      TABLE_CATEGORY category;
5169 5170
      if (table->placeholder())
        continue;
Marc Alff's avatar
Marc Alff committed
5171 5172 5173
      category= table->table->s->table_category;
      if ((category == TABLE_CATEGORY_LOG) ||
          (category == TABLE_CATEGORY_PERFORMANCE))
5174 5175
        thd->lex->set_stmt_unsafe();
      if (table->lock_type >= TL_WRITE_ALLOW_WRITE)
5176
      {
5177
        ulonglong const flags= table->table->file->ha_table_flags();
5178
        DBUG_PRINT("info", ("table: %s; ha_table_flags: %s%s",
5179
                            table->table_name,
5180 5181
                            FLAGSTR(flags, HA_BINLOG_STMT_CAPABLE),
                            FLAGSTR(flags, HA_BINLOG_ROW_CAPABLE)));
5182 5183 5184 5185 5186
        if (prev_ht && prev_ht != table->table->file->ht)
          multi_engine= TRUE;
        prev_ht= table->table->file->ht;
        flags_all_set &= flags;
        flags_some_set |= flags;
5187
      }
5188 5189 5190 5191 5192 5193 5194 5195
    }

    DBUG_PRINT("info", ("flags_all_set: %s%s",
                        FLAGSTR(flags_all_set, HA_BINLOG_STMT_CAPABLE),
                        FLAGSTR(flags_all_set, HA_BINLOG_ROW_CAPABLE)));
    DBUG_PRINT("info", ("flags_some_set: %s%s",
                        FLAGSTR(flags_some_set, HA_BINLOG_STMT_CAPABLE),
                        FLAGSTR(flags_some_set, HA_BINLOG_ROW_CAPABLE)));
5196
    DBUG_PRINT("info", ("thd->variables.binlog_format: %u",
5197
                        thd->variables.binlog_format));
5198 5199
    DBUG_PRINT("info", ("multi_engine: %s",
                        multi_engine ? "TRUE" : "FALSE"));
5200 5201

    int error= 0;
5202
    if (flags_all_set == 0)
5203
    {
5204 5205 5206
      my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
               "Statement cannot be logged to the binary log in"
               " row-based nor statement-based format");
5207 5208
    }
    else if (thd->variables.binlog_format == BINLOG_FORMAT_STMT &&
5209
             (flags_all_set & HA_BINLOG_STMT_CAPABLE) == 0)
5210
    {
5211 5212 5213
      my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
                "Statement-based format required for this statement,"
                " but not allowed by this combination of engines");
5214 5215 5216
    }
    else if ((thd->variables.binlog_format == BINLOG_FORMAT_ROW ||
              thd->lex->is_stmt_unsafe()) &&
5217
             (flags_all_set & HA_BINLOG_ROW_CAPABLE) == 0)
5218
    {
5219 5220 5221
      my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
                "Row-based format required for this statement,"
                " but not allowed by this combination of engines");
5222 5223
    }

5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239
    /*
      If more than one engine is involved in the statement and at
      least one is doing it's own logging (is *self-logging*), the
      statement cannot be logged atomically, so we generate an error
      rather than allowing the binlog to become corrupt.
     */
    if (multi_engine &&
        (flags_some_set & HA_HAS_OWN_BINLOGGING))
    {
      error= ER_BINLOG_LOGGING_IMPOSSIBLE;
      my_error(error, MYF(0),
               "Statement cannot be written atomically since more"
               " than one engine involved and at least one engine"
               " is self-logging");
    }

5240 5241 5242
    DBUG_PRINT("info", ("error: %d", error));

    if (error)
5243
      return -1;
5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255

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

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

      Observe that point to cannot be decided before the tables
      involved in a statement has been checked, i.e., we cannot put
      this code in reset_current_stmt_binlog_row_based(), it has to be
      here.
5256
    */
5257
    if (thd->lex->is_stmt_unsafe() ||
5258
        (flags_all_set & HA_BINLOG_STMT_CAPABLE) == 0)
5259 5260 5261 5262
    {
      thd->set_current_stmt_binlog_row_based_if_mixed();
    }
  }
5263

5264 5265 5266
  return 0;
}

5267 5268 5269 5270 5271 5272 5273
/*
  Lock all tables in list

  SYNOPSIS
    lock_tables()
    thd			Thread handler
    tables		Tables to lock
5274 5275 5276 5277 5278 5279
    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).
5280

5281 5282 5283 5284 5285
  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.

5286 5287 5288 5289
    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.

5290 5291 5292 5293 5294
  RETURN VALUES
   0	ok
   -1	Error
*/

5295
int lock_tables(THD *thd, TABLE_LIST *tables, uint count, bool *need_reopen)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5296
{
5297
  TABLE_LIST *table;
5298 5299 5300 5301 5302 5303 5304

  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());
5305 5306
  *need_reopen= FALSE;

5307
  if (!tables && !thd->lex->requires_prelocking())
5308
    DBUG_RETURN(decide_logging_format(thd, tables));
5309

5310 5311 5312 5313 5314 5315 5316 5317 5318 5319
  /*
    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
5320
  {
5321
    DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5322
    TABLE **start,**ptr;
5323
    uint lock_flag= MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN;
5324

5325
    if (!(ptr=start=(TABLE**) thd->alloc(sizeof(TABLE*)*count)))
5326
      DBUG_RETURN(-1);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5327
    for (table= tables; table; table= table->next_global)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5328
    {
5329
      if (!table->placeholder())
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5330 5331
	*(ptr++)= table->table;
    }
5332 5333 5334 5335 5336

    /* We have to emulate LOCK TABLES if we are statement needs prelocking. */
    if (thd->lex->requires_prelocking())
    {
      thd->in_lock_tables=1;
5337
      thd->variables.option_bits|= OPTION_TABLE_LOCK;
5338
      /*
5339 5340 5341 5342
        A query that modifies autoinc column in sub-statement can make the 
        master and slave inconsistent.
        We can solve these problems in mixed mode by switching to binlogging 
        if at least one updated table is used by sub-statement
5343
      */
5344
      if (thd->variables.binlog_format != BINLOG_FORMAT_ROW && tables && 
5345
          has_write_table_with_auto_increment(thd->lex->first_not_own_table()))
5346
      {
5347
        thd->lex->set_stmt_unsafe();
5348
      }
5349 5350
    }

5351 5352
    DEBUG_SYNC(thd, "before_lock_tables_takes_lock");

5353
    if (! (thd->lock= mysql_lock_tables(thd, start, (uint) (ptr - start),
5354
                                        lock_flag, need_reopen)))
5355 5356 5357
    {
      if (thd->lex->requires_prelocking())
      {
5358
        thd->variables.option_bits&= ~(OPTION_TABLE_LOCK);
5359 5360 5361 5362
        thd->in_lock_tables=0;
      }
      DBUG_RETURN(-1);
    }
5363

5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381
    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;

5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392
      /*
        When open_and_lock_tables() is called for a single table out of
        a table list, the 'next_global' chain is temporarily broken. We
        may not find 'first_not_own' before the end of the "list".
        Look for example at those places where open_n_lock_single_table()
        is called. That function implements the temporary breaking of
        a table list for opening a single table.
      */
      for (table= tables;
           table && table != first_not_own;
           table= table->next_global)
5393
      {
5394
        if (!table->placeholder())
5395 5396 5397 5398 5399 5400
        {
          table->table->query_id= thd->query_id;
          if (check_lock_and_start_stmt(thd, table->table, table->lock_type))
          {
            mysql_unlock_tables(thd, thd->locked_tables);
            thd->locked_tables= 0;
5401
            thd->variables.option_bits&= ~(OPTION_TABLE_LOCK);
5402 5403 5404 5405 5406 5407 5408 5409 5410
            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);
5411
      DBUG_PRINT("info",("prelocked_mode= PRELOCKED"));
5412 5413
      thd->prelocked_mode= PRELOCKED;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5414
  }
5415 5416
  else
  {
5417
    TABLE_LIST *first_not_own= thd->lex->first_not_own_table();
5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428
    /*
      When open_and_lock_tables() is called for a single table out of
      a table list, the 'next_global' chain is temporarily broken. We
      may not find 'first_not_own' before the end of the "list".
      Look for example at those places where open_n_lock_single_table()
      is called. That function implements the temporary breaking of
      a table list for opening a single table.
    */
    for (table= tables;
         table && table != first_not_own;
         table= table->next_global)
5429
    {
5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441
      if (table->placeholder())
        continue;

      /*
        In a stored function or trigger we should ensure that we won't change
        a table that is already used by the calling statement.
      */
      if (thd->prelocked_mode &&
          table->lock_type >= TL_WRITE_ALLOW_WRITE)
      {
        for (TABLE* opentab= thd->open_tables; opentab; opentab= opentab->next)
        {
Staale Smedseng's avatar
Staale Smedseng committed
5442 5443
          if (table->table->s == opentab->s && opentab->query_id &&
              table->table->query_id != opentab->query_id)
5444 5445
          {
            my_error(ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG, MYF(0),
Staale Smedseng's avatar
Staale Smedseng committed
5446
                     table->table->s->table_name.str);
5447 5448 5449 5450 5451 5452
            DBUG_RETURN(-1);
          }
        }
      }

      if (check_lock_and_start_stmt(thd, table->table, table->lock_type))
5453
      {
5454
	DBUG_RETURN(-1);
5455 5456
      }
    }
5457 5458 5459 5460 5461 5462 5463 5464
    /*
      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);
5465
      DBUG_PRINT("info", ("thd->prelocked_mode= PRELOCKED_UNDER_LOCK_TABLES"));
5466 5467
      thd->prelocked_mode= PRELOCKED_UNDER_LOCK_TABLES;
    }
5468
  }
5469 5470

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

5473

5474 5475 5476 5477 5478 5479
/*
  Prepare statement for reopening of tables and recalculation of set of
  prelocked tables.

  SYNOPSIS
    close_tables_for_reopen()
5480 5481
      thd    in     Thread context
      tables in/out List of tables which we were trying to open and lock
5482 5483 5484

*/

5485
void close_tables_for_reopen(THD *thd, TABLE_LIST **tables)
5486
{
5487 5488 5489 5490 5491 5492
  /*
    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;
5493 5494
  thd->lex->chop_off_not_own_tables();
  sp_remove_not_own_routines(thd->lex);
5495 5496
  for (TABLE_LIST *tmp= *tables; tmp; tmp= tmp->next_global)
    tmp->table= 0;
5497 5498 5499 5500
  close_thread_tables(thd);
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
5501
/*
5502
  Open a single table without table caching and don't set it in open_list
5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518

  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
5519 5520 5521 5522 5523 5524
*/

TABLE *open_temporary_table(THD *thd, const char *path, const char *db,
			    const char *table_name, bool link_in_list)
{
  TABLE *tmp_table;
5525
  TABLE_SHARE *share;
5526 5527 5528
  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
5529
  DBUG_ENTER("open_temporary_table");
5530 5531 5532 5533 5534
  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));
5535

5536 5537 5538 5539 5540 5541 5542 5543
  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
5544 5545
    DBUG_RETURN(0);				/* purecov: inspected */

5546 5547 5548 5549 5550
  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);

5551
  init_tmp_table_share(thd, share, saved_cache_key, key_length,
5552 5553 5554 5555 5556 5557 5558 5559
                       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,
5560
                            tmp_table, FALSE))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5561
  {
5562 5563
    /* No need to lock share->mutex as this is not needed for tmp tables */
    free_table_share(share);
5564
    my_free((char*) tmp_table,MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5565 5566 5567
    DBUG_RETURN(0);
  }

5568
  tmp_table->reginfo.lock_type= TL_WRITE;	 // Simulate locked
5569
  share->tmp_table= (tmp_table->file->has_transactions() ? 
5570
                     TRANSACTIONAL_TMP_TABLE : NON_TRANSACTIONAL_TMP_TABLE);
5571

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5572 5573
  if (link_in_list)
  {
5574 5575 5576 5577
    /* growing temp list at the head */
    tmp_table->next= thd->temporary_tables;
    if (tmp_table->next)
      tmp_table->next->prev= tmp_table;
5578
    thd->temporary_tables= tmp_table;
5579
    thd->temporary_tables->prev= 0;
5580 5581
    if (thd->slave_thread)
      slave_open_temp_tables++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5582
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5583
  tmp_table->pos_in_table_list= 0;
5584 5585
  DBUG_PRINT("tmptable", ("opened table: '%s'.'%s' 0x%lx", tmp_table->s->db.str,
                          tmp_table->s->table_name.str, (long) tmp_table));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5586 5587 5588 5589
  DBUG_RETURN(tmp_table);
}


5590
bool rm_temporary_table(handlerton *base, char *path)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5591 5592
{
  bool error=0;
5593 5594
  handler *file;
  char *ext;
5595 5596
  DBUG_ENTER("rm_temporary_table");

5597
  strmov(ext= strend(path), reg_ext);
Marc Alff's avatar
Marc Alff committed
5598
  if (mysql_file_delete(key_file_frm, path, MYF(0)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5599
    error=1; /* purecov: inspected */
5600 5601
  *ext= 0;				// remove extension
  file= get_new_handler((TABLE_SHARE*) 0, current_thd->mem_root, base);
5602
  if (file && file->ha_delete_table(path))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5603
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5604
    error=1;
5605
    sql_print_warning("Could not remove temporary table: '%s', error: %d",
serg@serg.mylan's avatar
serg@serg.mylan committed
5606
                      path, my_errno);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5607
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5608
  delete file;
5609
  DBUG_RETURN(error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5610 5611 5612 5613
}


/*****************************************************************************
5614 5615 5616 5617 5618 5619
* 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
5620 5621
******************************************************************************/

5622
/* Special Field pointers as return values of find_field_in_XXX functions. */
5623 5624
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
5625

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

5628 5629
static void update_field_dependencies(THD *thd, Field *field, TABLE *table)
{
5630 5631
  DBUG_ENTER("update_field_dependencies");
  if (thd->mark_used_columns != MARK_COLUMNS_NONE)
5632
  {
5633 5634 5635 5636 5637 5638 5639
    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).
    */
      
5640
    table->covering_keys.intersect(field->part_of_key);
5641 5642 5643
    table->merge_keys.merge(field->part_of_key);

    if (thd->mark_used_columns == MARK_COLUMNS_READ)
5644
    {
5645 5646
      current_bitmap= table->read_set;
      other_bitmap=   table->write_set;
5647 5648
    }
    else
5649 5650 5651 5652 5653
    {
      current_bitmap= table->write_set;
      other_bitmap=   table->read_set;
    }

5654 5655 5656 5657 5658 5659 5660
    /* 
       The test-and-set mechanism in the bitmap is not reliable during
       multi-UPDATE statements under MARK_COLUMNS_READ mode
       (thd->mark_used_columns == MARK_COLUMNS_READ), as this bitmap contains
       only those columns that are used in the SET clause. I.e they are being
       set here. See multi_update::prepare()
    */
5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678
    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)
5679
    field->flags|= GET_FIXED_FIELDS_FLAG;
5680
  DBUG_VOID_RETURN;
5681 5682
}

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5683 5684

/*
5685
  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
5686 5687

  SYNOPSIS
5688
    find_field_in_view()
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5689
    thd				thread handler
5690
    table_list			view to search for 'name'
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5691 5692
    name			name of field
    length			length of name
5693
    item_name                   name of item if it will be created (VIEW)
5694 5695
    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
5696
    register_tree_change        TRUE if ref is not stack variable and we
5697
                                need register changes in item tree
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5698 5699 5700 5701

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

5705 5706
static Field *
find_field_in_view(THD *thd, TABLE_LIST *table_list,
5707 5708
                   const char *name, uint length,
                   const char *item_name, Item **ref,
5709
                   bool register_tree_change)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5710
{
5711 5712 5713 5714 5715 5716
  DBUG_ENTER("find_field_in_view");
  DBUG_PRINT("enter",
             ("view: '%s', field name: '%s', item name: '%s', ref 0x%lx",
              table_list->alias, name, item_name, (ulong) ref));
  Field_iterator_view field_it;
  field_it.set(table_list);
gshchepa/uchum@gleb.loc's avatar
gshchepa/uchum@gleb.loc committed
5717
  Query_arena *arena= 0, backup;  
5718
  
5719 5720 5721
  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
5722
  {
5723
    if (!my_strcasecmp(system_charset_info, field_it.name(), name))
5724
    {
5725
      // in PS use own arena or data will be freed after prepare
5726 5727
      if (register_tree_change &&
          thd->stmt_arena->is_stmt_prepare_or_first_stmt_execute())
5728
        arena= thd->activate_stmt_arena_if_needed(&backup);
5729 5730 5731 5732
      /*
        create_item() may, or may not create a new Item, depending on
        the column reference. See create_view_field() for details.
      */
5733
      Item *item= field_it.create_item(thd);
gshchepa/uchum@gleb.loc's avatar
gshchepa/uchum@gleb.loc committed
5734
      if (arena)
5735 5736
        thd->restore_active_arena(arena, &backup);
      
5737 5738 5739 5740 5741 5742
      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.
5743
       We need to set alias on both ref itself and on ref real item.
5744 5745
      */
      if (*ref && !(*ref)->is_autogenerated_name)
5746
      {
5747 5748
        item->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
5749 5750 5751
        item->real_item()->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
      }
5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779
      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

5780 5781 5782 5783 5784 5785
  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.

5786
  RETURN
5787 5788 5789
    NULL        if the field was not found
    WRONG_GRANT if no access rights to the found field
    #           Pointer to the found Field
5790 5791 5792 5793
*/

static Field *
find_field_in_natural_join(THD *thd, TABLE_LIST *table_ref, const char *name,
5794
                           uint length, Item **ref, bool register_tree_change,
5795
                           TABLE_LIST **actual_table)
5796
{
5797 5798
  List_iterator_fast<Natural_join_column>
    field_it(*(table_ref->join_columns));
5799
  Natural_join_column *nj_col, *curr_nj_col;
5800
  Field *found_field;
5801
  Query_arena *arena, backup;
5802
  DBUG_ENTER("find_field_in_natural_join");
5803
  DBUG_PRINT("enter", ("field name: '%s', ref 0x%lx",
5804 5805
		       name, (ulong) ref));
  DBUG_ASSERT(table_ref->is_natural_join && table_ref->join_columns);
5806
  DBUG_ASSERT(*actual_table == NULL);
5807

5808
  LINT_INIT(arena);
5809
  LINT_INIT(found_field);
5810

5811 5812
  for (nj_col= NULL, curr_nj_col= field_it++; curr_nj_col; 
       curr_nj_col= field_it++)
5813
  {
5814 5815 5816 5817 5818 5819 5820 5821 5822
    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
5823
  }
5824 5825
  if (!nj_col)
    DBUG_RETURN(NULL);
5826 5827 5828

  if (nj_col->view_field)
  {
monty@mysql.com's avatar
monty@mysql.com committed
5829
    Item *item;
5830
    LINT_INIT(arena);
5831 5832
    if (register_tree_change)
      arena= thd->activate_stmt_arena_if_needed(&backup);
5833 5834 5835 5836
    /*
      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
5837
    item= nj_col->create_item(thd);
5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850
    /*
     *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);
    }
5851 5852 5853
    if (register_tree_change && arena)
      thd->restore_active_arena(arena, &backup);

5854 5855 5856 5857
    if (!item)
      DBUG_RETURN(NULL);
    DBUG_ASSERT(nj_col->table_field == NULL);
    if (nj_col->table_ref->schema_table_reformed)
5858
    {
5859 5860 5861 5862 5863 5864
      /*
        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);
5865
    }
5866 5867 5868 5869 5870 5871 5872 5873 5874 5875
    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);
5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888 5889 5890
    /*
      This fix_fields is not necessary (initially this item is fixed by
      the Item_field constructor; after reopen_tables the Item_func_eq
      calls fix_fields on that item), it's just a check during table
      reopening for columns that was dropped by the concurrent connection.
    */
    if (!nj_col->table_field->fixed &&
        nj_col->table_field->fix_fields(thd, (Item **)&nj_col->table_field))
    {
      DBUG_PRINT("info", ("column '%s' was dropped by the concurrent connection",
                          nj_col->table_field->name));
      DBUG_RETURN(NULL);
    }
    DBUG_ASSERT(nj_col->table_ref->table == nj_col->table_field->field->table);
    found_field= nj_col->table_field->field;
5891 5892 5893 5894 5895 5896
    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
5897 5898
}

5899

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5900
/*
5901
  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
5902 5903

  SYNOPSIS
5904
    find_field_in_table()
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5905
    thd				thread handler
5906
    table			table where to search for the field
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5907 5908 5909
    name			name of field
    length			length of name
    allow_rowid			do allow finding of "_rowid" field?
5910 5911
    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
5912 5913

  RETURN
5914 5915
    0	field is not found
    #	pointer to field
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5916 5917
*/

5918 5919
Field *
find_field_in_table(THD *thd, TABLE *table, const char *name, uint length,
5920
                    bool allow_rowid, uint *cached_field_index_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5921
{
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5922 5923
  Field **field_ptr, *field;
  uint cached_field_index= *cached_field_index_ptr;
5924 5925
  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
5926 5927

  /* We assume here that table->field < NO_CACHED_FIELD_INDEX = UINT_MAX */
5928
  if (cached_field_index < table->s->fields &&
5929
      !my_strcasecmp(system_charset_info,
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5930 5931
                     table->field[cached_field_index]->field_name, name))
    field_ptr= table->field + cached_field_index;
5932
  else if (table->s->name_hash.records)
5933
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
5934 5935
    field_ptr= (Field**) my_hash_search(&table->s->name_hash, (uchar*) name,
                                        length);
5936 5937 5938 5939 5940 5941 5942 5943 5944
    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
5945 5946 5947
  else
  {
    if (!(field_ptr= table->field))
5948
      DBUG_RETURN((Field *)0);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5949 5950 5951 5952 5953 5954
    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
5955
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5956 5957
    *cached_field_index_ptr= field_ptr - table->field;
    field= *field_ptr;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5958 5959 5960
  }
  else
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5961 5962
    if (!allow_rowid ||
        my_strcasecmp(system_charset_info, name, "_rowid") ||
5963
        table->s->rowid_field_offset == 0)
5964
      DBUG_RETURN((Field*) 0);
5965
    field= table->field[table->s->rowid_field_offset-1];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5966 5967
  }

5968 5969 5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980 5981
  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
5982
    length		   [in]  field length of name
5983 5984
    item_name              [in]  name of item if it will be created (VIEW)
    db_name                [in]  optional database name that qualifies the
5985
    table_name             [in]  optional table name that qualifies the field
5986 5987
    ref		       [in/out] if 'name' is resolved to a view field, ref
                                 is set to point to the found view field
5988
    check_privileges       [in]  check privileges
5989 5990 5991 5992 5993 5994 5995 5996 5997
    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
5998 5999 6000 6001 6002 6003 6004 6005 6006 6007 6008 6009
  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.

6010 6011 6012 6013 6014 6015 6016 6017
  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,
6018 6019 6020
                        const char *name, uint length,
                        const char *item_name, const char *db_name,
                        const char *table_name, Item **ref,
6021 6022
                        bool check_privileges, bool allow_rowid,
                        uint *cached_field_index_ptr,
6023 6024 6025 6026
                        bool register_tree_change, TABLE_LIST **actual_table)
{
  Field *fld;
  DBUG_ENTER("find_field_in_table_ref");
6027 6028 6029
  DBUG_ASSERT(table_list->alias);
  DBUG_ASSERT(name);
  DBUG_ASSERT(item_name);
6030 6031 6032 6033 6034 6035
  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
6036 6037
    are the same as the table reference we are going to search for the field.

6038 6039 6040 6041
    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
6042 6043 6044 6045 6046 6047

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

6048 6049
    TODO: Ensure that table_name, db_name and tables->db always points to
          something !
6050
  */
6051 6052
  if (/* Exclude nested joins. */
      (!table_list->nested_join ||
timour@mysql.com's avatar
timour@mysql.com committed
6053 6054 6055 6056 6057 6058
       /* Include merge views and information schema tables. */
       table_list->field_translation) &&
      /*
        Test if the field qualifiers match the table reference we plan
        to search.
      */
6059 6060
      table_name && table_name[0] &&
      (my_strcasecmp(table_alias_charset, table_list->alias, table_name) ||
6061
       (db_name && db_name[0] && table_list->db && table_list->db[0] &&
6062 6063 6064
        (table_list->schema_table ?
         my_strcasecmp(system_charset_info, db_name, table_list->db) :
         strcmp(db_name, table_list->db)))))
6065 6066
    DBUG_RETURN(0);

6067
  *actual_table= NULL;
timour@mysql.com's avatar
timour@mysql.com committed
6068

6069 6070
  if (table_list->field_translation)
  {
timour@mysql.com's avatar
timour@mysql.com committed
6071
    /* 'table_list' is a view or an information schema table. */
6072
    if ((fld= find_field_in_view(thd, table_list, name, length, item_name, ref,
6073
                                 register_tree_change)))
6074 6075
      *actual_table= table_list;
  }
6076
  else if (!table_list->nested_join)
6077
  {
6078 6079
    /* 'table_list' is a stored table. */
    DBUG_ASSERT(table_list->table);
timour@mysql.com's avatar
timour@mysql.com committed
6080
    if ((fld= find_field_in_table(thd, table_list->table, name, length,
6081 6082
                                  allow_rowid,
                                  cached_field_index_ptr)))
timour@mysql.com's avatar
timour@mysql.com committed
6083 6084 6085
      *actual_table= table_list;
  }
  else
6086
  {
timour@mysql.com's avatar
timour@mysql.com committed
6087
    /*
timour@mysql.com's avatar
timour@mysql.com committed
6088 6089 6090 6091 6092
      '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
6093
    */
6094 6095 6096 6097 6098 6099
    if (table_name && table_name[0])
    {
      List_iterator<TABLE_LIST> it(table_list->nested_join->join_list);
      TABLE_LIST *table;
      while ((table= it++))
      {
6100 6101
        if ((fld= find_field_in_table_ref(thd, table, name, length, item_name,
                                          db_name, table_name, ref,
6102 6103
                                          check_privileges, allow_rowid,
                                          cached_field_index_ptr,
6104 6105 6106 6107 6108 6109 6110
                                          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
6111 6112 6113
      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.
6114 6115
    */
    fld= find_field_in_natural_join(thd, table_list, name, length, ref,
6116
                                    register_tree_change, actual_table);
6117
  }
6118

6119 6120
  if (fld)
  {
6121
#ifndef NO_EMBEDDED_ACCESS_CHECKS
6122 6123 6124 6125 6126
    /* 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
6127
#endif
6128
      if (thd->mark_used_columns != MARK_COLUMNS_NONE)
6129
      {
6130
        /*
6131 6132 6133
          Get rw_set correct for this field so that the handler
          knows that this field is involved in the query and gets
          retrieved/updated
6134
         */
6135 6136 6137 6138 6139 6140
        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;
6141 6142 6143
          else
          {
            if (thd->mark_used_columns == MARK_COLUMNS_READ)
6144
              it->walk(&Item::register_field_in_read_map, 1, (uchar *) 0);
6145
          }
6146 6147 6148 6149
        }
        else
          field_to_set= fld;
        if (field_to_set)
6150 6151 6152 6153 6154 6155 6156
        {
          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);
        }
6157 6158
      }
  }
6159
  DBUG_RETURN(fld);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6160 6161
}

6162

6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181
/*
  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)
6182
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
6183 6184
    field_ptr= (Field**)my_hash_search(&table->s->name_hash,(uchar*) name,
                                       strlen(name));
6185 6186 6187 6188 6189 6190 6191 6192 6193
    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));
    }
  }
6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208
  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;
}


6209 6210 6211 6212 6213
/*
  Find field in table list.

  SYNOPSIS
    find_field_in_tables()
6214 6215 6216 6217 6218 6219
    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
6220
                          point to the found view field
6221
    report_error	  Degree of error reporting:
6222 6223
                          - IGNORE_ERRORS then do not report any error
                          - IGNORE_EXCEPT_NON_UNIQUE report only non-unique
6224
                            fields, suppress all other errors
6225 6226 6227 6228
                          - REPORT_EXCEPT_NON_UNIQUE report all other errors
                            except when non-unique fields were found
                          - REPORT_ALL_ERRORS
    check_privileges      need to check privileges
6229 6230
    register_tree_change  TRUE if ref is not a stack variable and we
                          to need register changes in item tree
6231 6232

  RETURN VALUES
6233 6234 6235
    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.
6236 6237 6238 6239 6240
    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
6241
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6242 6243

Field *
6244 6245
find_field_in_tables(THD *thd, Item_ident *item,
                     TABLE_LIST *first_table, TABLE_LIST *last_table,
6246
		     Item **ref, find_item_error_report_type report_error,
6247
                     bool check_privileges, bool register_tree_change)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6248 6249
{
  Field *found=0;
6250 6251 6252
  const char *db= item->db_name;
  const char *table_name= item->table_name;
  const char *name= item->field_name;
6253
  uint length=(uint) strlen(name);
6254
  char name_buff[NAME_LEN+1];
6255 6256
  TABLE_LIST *cur_table= first_table;
  TABLE_LIST *actual_table;
6257 6258 6259 6260 6261 6262 6263 6264 6265
  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
6266

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6267 6268 6269
  if (item->cached_table)
  {
    /*
6270 6271
      This shortcut is used by prepared statements. We assume that
      TABLE_LIST *first_table is not changed during query execution (which
6272
      is true for all queries except RENAME but luckily RENAME doesn't
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6273
      use fields...) so we can rely on reusing pointer to its member.
timour@mysql.com's avatar
timour@mysql.com committed
6274
      With this optimization we also miss case when addition of one more
6275
      field makes some prepared query ambiguous and so erroneous, but we
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6276 6277
      accept this trade off.
    */
6278 6279 6280 6281 6282 6283 6284 6285
    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,
6286
                                 TRUE, &(item->cached_field_index));
6287
    else
6288
      found= find_field_in_table_ref(thd, table_ref, name, length, item->name,
6289 6290
                                     NULL, NULL, ref, check_privileges,
                                     TRUE, &(item->cached_field_index),
6291 6292
                                     register_tree_change,
                                     &actual_table);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6293 6294 6295
    if (found)
    {
      if (found == WRONG_GRANT)
6296
	return (Field*) 0;
6297 6298 6299 6300 6301 6302

      /*
        Only views fields should be marked as dependent, not an underlying
        fields.
      */
      if (!table_ref->belong_to_view)
6303 6304
      {
        SELECT_LEX *current_sel= thd->lex->current_select;
6305
        SELECT_LEX *last_select= table_ref->select_lex;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6306 6307
        /*
          If the field was an outer referencee, mark all selects using this
6308
          sub query as dependent on the outer query
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6309
        */
6310
        if (current_sel != last_select)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6311
          mark_select_range_as_dependent(thd, last_select, current_sel,
6312 6313
                                         found, *ref, item);
      }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6314 6315 6316 6317
      return found;
    }
  }

6318 6319 6320
  if (db && lower_case_table_names)
  {
    /*
timour@mysql.com's avatar
timour@mysql.com committed
6321
      convert database to lower case for comparison.
6322 6323 6324 6325
      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
6326
    my_casedn_str(files_charset_info, name_buff);
6327 6328
    db= name_buff;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6329

6330 6331 6332 6333 6334
  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
6335
  {
6336 6337
    Field *cur_field= find_field_in_table_ref(thd, cur_table, name, length,
                                              item->name, db, table_name, ref,
6338 6339 6340
                                              (thd->lex->sql_command ==
                                               SQLCOM_SHOW_FIELDS)
                                              ? false : check_privileges,
6341
                                              allow_rowid,
6342 6343 6344 6345
                                              &(item->cached_field_index),
                                              register_tree_change,
                                              &actual_table);
    if (cur_field)
6346
    {
6347
      if (cur_field == WRONG_GRANT)
6348 6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361 6362 6363 6364
      {
        if (thd->lex->sql_command != SQLCOM_SHOW_FIELDS)
          return (Field*) 0;

        thd->clear_error();
        cur_field= find_field_in_table_ref(thd, cur_table, name, length,
                                           item->name, db, table_name, ref,
                                           false,
                                           allow_rowid,
                                           &(item->cached_field_index),
                                           register_tree_change,
                                           &actual_table);
        if (cur_field)
        {
          Field *nf=new Field_null(NULL,0,Field::NONE,
                                   cur_field->field_name,
                                   &my_charset_bin);
6365
          nf->init(cur_table->table);
6366 6367 6368
          cur_field= nf;
        }
      }
6369 6370 6371 6372 6373 6374 6375 6376

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

6377 6378 6379 6380 6381
      DBUG_ASSERT(thd->where);
      /*
        If we found a fully qualified field we return it directly as it can't
        have duplicates.
       */
6382
      if (db)
6383 6384
        return cur_field;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
6385 6386
      if (found)
      {
6387 6388
        if (report_error == REPORT_ALL_ERRORS ||
            report_error == IGNORE_EXCEPT_NON_UNIQUE)
6389
          my_error(ER_NON_UNIQ_ERROR, MYF(0),
6390
                   table_name ? item->full_name() : name, thd->where);
6391
        return (Field*) 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6392
      }
6393
      found= cur_field;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6394 6395
    }
  }
6396

bk@work.mysql.com's avatar
bk@work.mysql.com committed
6397 6398
  if (found)
    return found;
6399 6400 6401 6402 6403 6404 6405 6406

  /*
    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.
  */
6407
  if (table_name && (cur_table == first_table) &&
6408 6409 6410
      (report_error == REPORT_ALL_ERRORS ||
       report_error == REPORT_EXCEPT_NON_UNIQUE))
  {
6411
    char buff[NAME_LEN*2 + 2];
6412 6413 6414 6415 6416 6417 6418
    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);
  }
6419
  else
6420
  {
6421 6422 6423 6424 6425
    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;
6426
  }
6427
  return found;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6428 6429
}

6430 6431 6432

/*
  Find Item in list of items (find_field_in_tables analog)
6433 6434 6435 6436

  TODO
    is it better return only counter?

6437 6438
  SYNOPSIS
    find_item_in_list()
6439 6440 6441
    find			Item to find
    items			List of items
    counter			To return number of found item
6442
    report_error
6443 6444 6445 6446 6447
      REPORT_ALL_ERRORS		report errors, return 0 if error
      REPORT_EXCEPT_NOT_FOUND	Do not report 'not found' error and
				return not_found_item, report other errors,
				return 0
      IGNORE_ERRORS		Do not report errors, return 0 if error
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6448 6449 6450 6451 6452 6453 6454
    resolution                  Set to the resolution type if the item is found 
                                (it says whether the item is resolved 
                                 against an alias name,
                                 or as a field name without alias,
                                 or as a field hidden by alias,
                                 or ignoring alias)
                                
6455
  RETURN VALUES
6456 6457 6458 6459 6460
    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
6461
                        found field
6462 6463
*/

6464
/* Special Item pointer to serve as a return value from find_item_in_list(). */
6465
Item **not_found_item= (Item**) 0x1;
6466 6467


bk@work.mysql.com's avatar
bk@work.mysql.com committed
6468
Item **
6469
find_item_in_list(Item *find, List<Item> &items, uint *counter,
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6470 6471
                  find_item_error_report_type report_error,
                  enum_resolution_type *resolution)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6472 6473
{
  List_iterator<Item> li(items);
6474
  Item **found=0, **found_unaliased= 0, *item;
6475
  const char *db_name=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6476 6477
  const char *field_name=0;
  const char *table_name=0;
6478
  bool found_unaliased_non_uniq= 0;
6479 6480 6481 6482 6483
  /*
    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;
Staale Smedseng's avatar
Staale Smedseng committed
6484
  uint unaliased_counter= 0;
6485

igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6486
  *resolution= NOT_RESOLVED;
6487

6488 6489 6490
  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
6491 6492 6493
  {
    field_name= ((Item_ident*) find)->field_name;
    table_name= ((Item_ident*) find)->table_name;
6494
    db_name=    ((Item_ident*) find)->db_name;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6495 6496
  }

6497
  for (uint i= 0; (item=li++); i++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6498
  {
6499
    if (field_name && item->real_item()->type() == Item::FIELD_ITEM)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6500
    {
6501
      Item_ident *item_field= (Item_ident*) item;
6502

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6503 6504 6505 6506 6507 6508
      /*
	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
      */ 
6509 6510 6511 6512
      if (!item_field->name)
        continue;

      if (table_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6513
      {
6514 6515 6516
        /*
          If table name is specified we should find field 'field_name' in
          table 'table_name'. According to SQL-standard we should ignore
6517 6518 6519 6520 6521
          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.
6522

6523
          We use strcmp for table names and database names as these may be
6524 6525
          case sensitive. In cases where they are not case sensitive, they
          are always in lower case.
6526 6527

	  item_field->field_name and item_field->table_name can be 0x0 if
6528
	  item is not fix_field()'ed yet.
6529
        */
6530 6531
        if (item_field->field_name && item_field->table_name &&
	    !my_strcasecmp(system_charset_info, item_field->field_name,
6532
                           field_name) &&
6533 6534
            !my_strcasecmp(table_alias_charset, item_field->table_name, 
                           table_name) &&
6535 6536 6537
            (!db_name || (item_field->db_name &&
                          !strcmp(item_field->db_name, db_name))))
        {
6538
          if (found_unaliased)
6539
          {
6540 6541 6542 6543 6544 6545 6546
            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.
            */
6547
            if (report_error != IGNORE_ERRORS)
6548 6549
              my_error(ER_NON_UNIQ_ERROR, MYF(0),
                       find->full_name(), current_thd->where);
6550 6551
            return (Item**) 0;
          }
6552 6553
          found_unaliased= li.ref();
          unaliased_counter= i;
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6554
          *resolution= RESOLVED_IGNORING_ALIAS;
6555 6556
          if (db_name)
            break;                              // Perfect match
6557 6558
        }
      }
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6559
      else
6560
      {
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6561 6562 6563 6564 6565
        int fname_cmp= my_strcasecmp(system_charset_info,
                                     item_field->field_name,
                                     field_name);
        if (!my_strcasecmp(system_charset_info,
                           item_field->name,field_name))
6566
        {
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6567 6568 6569 6570 6571 6572 6573 6574 6575 6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 6586
          /*
            If table name was not given we should scan through aliases
            and non-aliased fields first. We are also checking unaliased
            name of the field in then next  else-if, to be able to find
            instantly field (hidden by alias) if no suitable alias or
            non-aliased field was found.
          */
          if (found)
          {
            if ((*found)->eq(item, 0))
              continue;                           // Same field twice
            if (report_error != IGNORE_ERRORS)
              my_error(ER_NON_UNIQ_ERROR, MYF(0),
                       find->full_name(), current_thd->where);
            return (Item**) 0;
          }
          found= li.ref();
          *counter= i;
          *resolution= fname_cmp ? RESOLVED_AGAINST_ALIAS:
	                           RESOLVED_WITH_NO_ALIAS;
6587
        }
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6588
        else if (!fname_cmp)
6589
        {
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6590 6591 6592 6593 6594 6595 6596 6597 6598 6599 6600 6601
          /*
            We will use non-aliased field or react on such ambiguities only if
            we won't be able to find aliased field.
            Again if we have ambiguity with field outside of select list
            we should prefer fields from select list.
          */
          if (found_unaliased)
          {
            if ((*found_unaliased)->eq(item, 0))
              continue;                           // Same field twice
            found_unaliased_non_uniq= 1;
          }
6602 6603 6604
          found_unaliased= li.ref();
          unaliased_counter= i;
        }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6605 6606
      }
    }
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6607 6608 6609 6610 6611 6612 6613 6614 6615 6616 6617 6618 6619 6620 6621 6622 6623
    else if (!table_name)
    { 
      if (is_ref_by_name && find->name && item->name &&
	  !my_strcasecmp(system_charset_info,item->name,find->name))
      {
        found= li.ref();
        *counter= i;
        *resolution= RESOLVED_AGAINST_ALIAS;
        break;
      }
      else if (find->eq(item,0))
      {
        found= li.ref();
        *counter= i;
        *resolution= RESOLVED_IGNORING_ALIAS;
        break;
      }
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
    }
    else if (table_name && item->type() == Item::REF_ITEM &&
             ((Item_ref *)item)->ref_type() == Item_ref::VIEW_REF)
    {
      /*
        TODO:Here we process prefixed view references only. What we should 
        really do is process all types of Item_refs. But this will currently 
        lead to a clash with the way references to outer SELECTs (from the 
        HAVING clause) are handled in e.g. :
        SELECT 1 FROM t1 AS t1_o GROUP BY a
          HAVING (SELECT t1_o.a FROM t1 AS t1_i GROUP BY t1_i.a LIMIT 1).
        Processing all Item_refs here will cause t1_o.a to resolve to itself.
        We still need to process the special case of Item_direct_view_ref 
        because in the context of views they have the same meaning as 
        Item_field for tables.
      */
      Item_ident *item_ref= (Item_ident *) item;
      if (item_ref->name && item_ref->table_name &&
          !my_strcasecmp(system_charset_info, item_ref->name, field_name) &&
          !my_strcasecmp(table_alias_charset, item_ref->table_name,
                         table_name) &&
          (!db_name || (item_ref->db_name && 
                        !strcmp (item_ref->db_name, db_name))))
      {
        found= li.ref();
        *counter= i;
        *resolution= RESOLVED_IGNORING_ALIAS;
        break;
      }
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6654
  }
6655 6656 6657 6658 6659
  if (!found)
  {
    if (found_unaliased_non_uniq)
    {
      if (report_error != IGNORE_ERRORS)
6660 6661
        my_error(ER_NON_UNIQ_ERROR, MYF(0),
                 find->full_name(), current_thd->where);
6662 6663 6664 6665 6666 6667
      return (Item **) 0;
    }
    if (found_unaliased)
    {
      found= found_unaliased;
      *counter= unaliased_counter;
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6668
      *resolution= RESOLVED_BEHIND_ALIAS;
6669 6670
    }
  }
6671 6672
  if (found)
    return found;
6673
  if (report_error != REPORT_EXCEPT_NOT_FOUND)
6674 6675
  {
    if (report_error == REPORT_ALL_ERRORS)
6676 6677
      my_error(ER_BAD_FIELD_ERROR, MYF(0),
               find->full_name(), current_thd->where);
6678 6679 6680 6681
    return (Item **) 0;
  }
  else
    return (Item **) not_found_item;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
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

/*
  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;
6712
    if (!my_strcasecmp(system_charset_info, find, curr_str->ptr()))
6713 6714 6715 6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731 6732 6733
      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
6734 6735
    FALSE  if all OK
    TRUE   otherwise
6736 6737 6738 6739 6740 6741
*/

static bool
set_new_item_local_context(THD *thd, Item_ident *item, TABLE_LIST *table_ref)
{
  Name_resolution_context *context;
6742
  if (!(context= new (thd->mem_root) Name_resolution_context))
6743 6744
    return TRUE;
  context->init();
6745 6746
  context->first_name_resolution_table=
    context->last_name_resolution_table= table_ref;
6747 6748 6749 6750 6751 6752 6753 6754 6755 6756 6757 6758 6759 6760 6761 6762 6763 6764 6765 6766 6767 6768 6769 6770 6771 6772 6773 6774 6775 6776 6777 6778
  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
6779 6780
    TRUE   error when some common column is non-unique, or out of memory
    FALSE  OK
6781 6782 6783 6784 6785 6786 6787 6788 6789 6790
*/

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
6791 6792 6793 6794 6795 6796 6797 6798 6799 6800 6801
  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;
6802 6803

  DBUG_ENTER("mark_common_columns");
6804
  DBUG_PRINT("info", ("operand_1: %s  operand_2: %s",
6805 6806
                      table_ref_1->alias, table_ref_2->alias));

6807
  *found_using_fields= 0;
konstantin@mysql.com's avatar
konstantin@mysql.com committed
6808
  arena= thd->activate_stmt_arena_if_needed(&backup);
6809 6810 6811

  for (it_1.set(table_ref_1); !it_1.end_of_fields(); it_1.next())
  {
6812
    bool found= FALSE;
konstantin@mysql.com's avatar
konstantin@mysql.com committed
6813
    const char *field_name_1;
6814 6815
    /* true if field_name_1 is a member of using_fields */
    bool is_using_column_1;
6816
    if (!(nj_col_1= it_1.get_or_create_column_ref(thd, leaf_1)))
6817 6818
      goto err;
    field_name_1= nj_col_1->name();
6819 6820 6821 6822 6823
    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));
6824

6825 6826 6827 6828 6829 6830 6831
    /*
      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.
    */
6832 6833 6834 6835
    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;
6836
      const char *cur_field_name_2;
6837
      if (!(cur_nj_col_2= it_2.get_or_create_column_ref(thd, leaf_2)))
6838
        goto err;
6839
      cur_field_name_2= cur_nj_col_2->name();
6840 6841 6842 6843
      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));
6844

timour@mysql.com's avatar
timour@mysql.com committed
6845 6846 6847 6848 6849 6850
      /*
        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).
6851 6852 6853 6854
        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
6855
      */
6856 6857
      if (!my_strcasecmp(system_charset_info, field_name_1, cur_field_name_2))
      {
6858 6859 6860
        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)))
6861 6862 6863 6864 6865 6866 6867 6868
        {
          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
6869 6870 6871 6872 6873 6874 6875 6876 6877
    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;
    }
6878
    if (!found)
6879
      continue;                                 // No matching field
6880 6881 6882 6883 6884 6885

    /*
      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.
    */
6886
    if (nj_col_2 && (!using_fields ||is_using_column_1))
6887 6888 6889 6890 6891 6892
    {
      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;
6893 6894 6895 6896 6897
      Item_func_eq *eq_cond;

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

6898
      /*
6899
        The following assert checks that the two created items are of
6900 6901 6902 6903 6904 6905 6906 6907 6908 6909 6910 6911 6912 6913 6914 6915 6916 6917 6918 6919 6920 6921 6922 6923
        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.
      */
6924 6925
      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))
6926 6927
        goto err;

6928 6929
      if (!(eq_cond= new Item_func_eq(item_ident_1, item_ident_2)))
        goto err;                               /* Out of memory. */
6930 6931 6932 6933 6934 6935

      /*
        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.
       */
6936 6937 6938
      add_join_on((table_ref_1->outer_join & JOIN_TYPE_RIGHT ?
                   table_ref_1 : table_ref_2),
                  eq_cond);
6939 6940

      nj_col_1->is_common= nj_col_2->is_common= TRUE;
6941 6942 6943 6944 6945 6946 6947
      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()));
6948 6949 6950

      if (field_1)
      {
6951
        TABLE *table_1= nj_col_1->table_ref->table;
6952
        /* Mark field_1 used for table cache. */
6953
        bitmap_set_bit(table_1->read_set, field_1->field_index);
6954
        table_1->covering_keys.intersect(field_1->part_of_key);
6955
        table_1->merge_keys.merge(field_1->part_of_key);
6956 6957 6958
      }
      if (field_2)
      {
6959
        TABLE *table_2= nj_col_2->table_ref->table;
6960
        /* Mark field_2 used for table cache. */
6961
        bitmap_set_bit(table_2->read_set, field_2->field_index);
6962
        table_2->covering_keys.intersect(field_2->part_of_key);
6963
        table_2->merge_keys.merge(field_2->part_of_key);
6964 6965 6966 6967 6968 6969
      }

      if (using_fields != NULL)
        ++(*found_using_fields);
    }
  }
timour@mysql.com's avatar
timour@mysql.com committed
6970 6971
  if (leaf_1)
    leaf_1->is_join_columns_complete= TRUE;
6972 6973 6974 6975 6976 6977 6978 6979 6980 6981 6982 6983

  /*
    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
6984
    thd->restore_active_arena(arena, &backup);
6985 6986 6987 6988 6989 6990 6991 6992 6993 6994 6995 6996 6997 6998 6999 7000 7001 7002 7003 7004 7005 7006 7007 7008 7009 7010 7011 7012 7013 7014 7015 7016 7017 7018 7019 7020
  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
7021 7022
    TRUE    error: Some common column is ambiguous
    FALSE   OK
7023 7024 7025 7026 7027 7028 7029 7030 7031 7032 7033 7034 7035
*/

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;
7036
  List<Natural_join_column> *non_join_columns;
7037 7038
  DBUG_ENTER("store_natural_using_join_columns");

7039 7040
  DBUG_ASSERT(!natural_using_join->join_columns);

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

7043 7044
  if (!(non_join_columns= new List<Natural_join_column>) ||
      !(natural_using_join->join_columns= new List<Natural_join_column>))
7045 7046 7047 7048 7049
    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())
  {
7050
    nj_col_1= it_1.get_natural_column_ref();
7051 7052 7053 7054 7055 7056 7057 7058 7059 7060 7061 7062 7063 7064 7065 7066 7067 7068 7069 7070 7071
    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++))
    {
7072
      const char *using_field_name_ptr= using_field_name->c_ptr();
7073 7074 7075
      List_iterator_fast<Natural_join_column>
        it(*(natural_using_join->join_columns));
      Natural_join_column *common_field;
7076 7077

      for (;;)
7078
      {
7079 7080 7081 7082 7083 7084 7085
        /* 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;
        }
7086 7087
        if (!my_strcasecmp(system_charset_info,
                           common_field->name(), using_field_name_ptr))
7088
          break;                                // Found match
7089 7090 7091 7092 7093 7094 7095
      }
    }
  }

  /* 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())
  {
7096
    nj_col_2= it_2.get_natural_column_ref();
7097 7098 7099
    if (!nj_col_2->is_common)
      non_join_columns->push_back(nj_col_2);
    else
7100
    {
7101 7102
      /* Reset the common columns for the next call to mark_common_columns. */
      nj_col_2->is_common= FALSE;
7103
    }
7104 7105 7106 7107 7108 7109 7110 7111 7112 7113
  }

  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
7114
    thd->restore_active_arena(arena, &backup);
7115 7116 7117
  DBUG_RETURN(result);
}

7118

7119 7120 7121 7122 7123 7124 7125 7126 7127 7128 7129 7130 7131 7132 7133 7134 7135 7136 7137 7138 7139 7140 7141 7142 7143 7144
/*
  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
7145 7146
    TRUE   Error
    FALSE  OK
7147 7148 7149 7150 7151 7152 7153
*/

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
7154 7155 7156
  Query_arena *arena, backup;
  bool result= TRUE;

7157
  DBUG_ENTER("store_top_level_join_columns");
7158

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

7161 7162 7163 7164
  /* 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
7165 7166 7167 7168
    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;
7169

timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
7170
    while (same_level_left_neighbor)
7171
    {
timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
7172 7173
      TABLE_LIST *cur_table_ref= same_level_left_neighbor;
      same_level_left_neighbor= nested_it++;
7174 7175 7176 7177
      /*
        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
7178 7179 7180 7181 7182
        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
7183 7184
        swapped in the first loop.
      */
timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
7185
      if (same_level_left_neighbor &&
7186 7187 7188 7189
          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
7190
        swap_variables(TABLE_LIST*, same_level_left_neighbor, cur_table_ref);
7191 7192
      }

timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
7193 7194 7195 7196 7197 7198 7199 7200 7201
      /*
        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;

7202 7203
      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
7204
                                       real_left_neighbor, real_right_neighbor))
timour@mysql.com's avatar
timour@mysql.com committed
7205
        goto err;
timour/timka@lamia.home's avatar
timour/timka@lamia.home committed
7206
      same_level_right_neighbor= cur_table_ref;
7207 7208 7209 7210 7211 7212 7213 7214 7215 7216 7217 7218 7219 7220 7221 7222 7223 7224 7225 7226 7227 7228 7229 7230 7231 7232 7233 7234 7235 7236
    }
  }

  /*
    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
7237
      goto err;
7238 7239 7240 7241 7242 7243 7244 7245 7246 7247 7248

    /*
      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
7249
      goto err;
7250 7251 7252 7253 7254 7255 7256 7257 7258

    /*
      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
7259 7260 7261 7262 7263
    /* 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. */

7264 7265 7266
    /* Change this table reference to become a leaf for name resolution. */
    if (left_neighbor)
    {
7267
      TABLE_LIST *last_leaf_on_the_left;
7268 7269 7270 7271 7272
      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)
    {
7273
      TABLE_LIST *first_leaf_on_the_right;
7274 7275 7276 7277 7278 7279
      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
7280 7281 7282 7283
  result= FALSE; /* All is OK. */

err:
  if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7284
    thd->restore_active_arena(arena, &backup);
timour@mysql.com's avatar
timour@mysql.com committed
7285
  DBUG_RETURN(result);
7286 7287 7288 7289 7290 7291 7292 7293 7294 7295 7296 7297 7298 7299 7300 7301 7302 7303 7304 7305 7306 7307 7308 7309
}


/*
  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
7310 7311
    TRUE   Error
    FALSE  OK
7312
*/
7313 7314
static bool setup_natural_join_row_types(THD *thd,
                                         List<TABLE_LIST> *from_clause,
7315 7316 7317 7318 7319 7320 7321 7322 7323
                                         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. */
7324
  TABLE_LIST *left_neighbor;
7325 7326
  /* Table reference to the right of the current. */
  TABLE_LIST *right_neighbor= NULL;
7327 7328 7329 7330
  bool save_first_natural_join_processing=
    context->select_lex->first_natural_join_processing;

  context->select_lex->first_natural_join_processing= FALSE;
7331

7332 7333
  /* Note that tables in the list are in reversed order */
  for (left_neighbor= table_ref_it++; left_neighbor ; )
7334 7335 7336
  {
    table_ref= left_neighbor;
    left_neighbor= table_ref_it++;
7337 7338 7339 7340 7341 7342
    /* 
      Do not redo work if already done:
      1) for stored procedures,
      2) for multitable update after lock failure and table reopening.
    */
    if (save_first_natural_join_processing)
7343
    {
7344
      context->select_lex->first_natural_join_processing= FALSE;
7345 7346 7347 7348 7349 7350 7351 7352 7353
      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;
      }
7354 7355 7356 7357 7358 7359 7360
    }
    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
7361
    right_neighbor points to the left-most top-level table reference in the
7362 7363 7364 7365 7366 7367 7368 7369 7370 7371
    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
7372
/****************************************************************************
7373
** Expand all '*' in given fields
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7374 7375
****************************************************************************/

7376 7377 7378
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
7379
{
7380
  if (!wild_num)
7381
    return(0);
7382

7383
  Item *item;
7384
  List_iterator<Item> it(fields);
serg@serg.mylan's avatar
serg@serg.mylan committed
7385
  Query_arena *arena, backup;
7386
  DBUG_ENTER("setup_wild");
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7387 7388

  /*
7389 7390
    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
7391
  */
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7392
  arena= thd->activate_stmt_arena_if_needed(&backup);
7393

7394
  thd->lex->current_select->cur_pos_in_select_list= 0;
monty@mysql.com's avatar
monty@mysql.com committed
7395
  while (wild_num && (item= it++))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7396
  {
7397 7398
    if (item->type() == Item::FIELD_ITEM &&
        ((Item_field*) item)->field_name &&
7399 7400
	((Item_field*) item)->field_name[0] == '*' &&
	!((Item_field*) item)->field)
7401
    {
7402
      uint elem= fields.elements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7403
      bool any_privileges= ((Item_field *) item)->any_privileges;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7404 7405 7406 7407 7408 7409 7410 7411 7412
      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.
        */
7413 7414
        it.replace(new Item_int("Not_used", (longlong) 1,
                                MY_INT64_NUM_DECIMAL_DIGITS));
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7415
      }
7416 7417
      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
7418
                             ((Item_field*) item)->table_name, &it,
7419
                             any_privileges))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7420 7421
      {
	if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7422
	  thd->restore_active_arena(arena, &backup);
7423
	DBUG_RETURN(-1);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7424
      }
7425
      if (sum_func_list)
7426 7427 7428 7429 7430 7431 7432 7433
      {
	/*
	  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;
      }
7434
      wild_num--;
7435
    }
7436 7437
    else
      thd->lex->current_select->cur_pos_in_select_list++;
7438
  }
7439
  thd->lex->current_select->cur_pos_in_select_list= UNDEF_POS;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7440 7441 7442 7443 7444
  if (arena)
  {
    /* make * substituting permanent */
    SELECT_LEX *select_lex= thd->lex->current_select;
    select_lex->with_wild= 0;
7445 7446 7447 7448 7449 7450 7451
    /*   
      The assignment below is translated to memcpy() call (at least on some
      platforms). memcpy() expects that source and destination areas do not
      overlap. That problem was detected by valgrind. 
    */
    if (&select_lex->item_list != &fields)
      select_lex->item_list= fields;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7452

konstantin@mysql.com's avatar
konstantin@mysql.com committed
7453
    thd->restore_active_arena(arena, &backup);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7454
  }
7455
  DBUG_RETURN(0);
7456 7457
}

7458 7459 7460 7461
/****************************************************************************
** Check that all given fields exists and fill struct with current data
****************************************************************************/

7462
bool setup_fields(THD *thd, Item **ref_pointer_array,
7463
                  List<Item> &fields, enum_mark_columns mark_used_columns,
7464
                  List<Item> *sum_func_list, bool allow_sum_func)
7465 7466
{
  reg2 Item *item;
7467
  enum_mark_columns save_mark_used_columns= thd->mark_used_columns;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7468
  nesting_map save_allow_sum_func= thd->lex->allow_sum_func;
7469
  List_iterator<Item> it(fields);
7470
  bool save_is_item_list_lookup;
7471 7472
  DBUG_ENTER("setup_fields");

7473 7474
  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
7475 7476
  if (allow_sum_func)
    thd->lex->allow_sum_func|= 1 << thd->lex->current_select->nest_level;
7477
  thd->where= THD::DEFAULT_WHERE;
7478 7479
  save_is_item_list_lookup= thd->lex->current_select->is_item_list_lookup;
  thd->lex->current_select->is_item_list_lookup= 0;
7480

7481 7482 7483 7484 7485 7486 7487 7488 7489 7490 7491 7492 7493 7494
  /*
    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);

7495 7496 7497 7498 7499 7500 7501 7502 7503 7504 7505 7506 7507 7508 7509 7510
  /*
    We call set_entry() there (before fix_fields() of the whole list of field
    items) because:
    1) the list of field items has same order as in the query, and the
       Item_func_get_user_var item may go before the Item_func_set_user_var:
          SELECT @a, @a := 10 FROM t;
    2) The entry->update_query_id value controls constantness of
       Item_func_get_user_var items, so in presence of Item_func_set_user_var
       items we have to refresh their entries before fixing of
       Item_func_get_user_var items.
  */
  List_iterator<Item_func_set_user_var> li(thd->lex->set_var_list);
  Item_func_set_user_var *var;
  while ((var= li++))
    var->set_entry(thd, FALSE);

7511
  Item **ref= ref_pointer_array;
7512
  thd->lex->current_select->cur_pos_in_select_list= 0;
7513
  while ((item= it++))
7514
  {
7515
    if ((!item->fixed && item->fix_fields(thd, it.ref())) ||
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7516
	(item= *(it.ref()))->check_cols(1))
7517
    {
7518
      thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7519
      thd->lex->allow_sum_func= save_allow_sum_func;
7520 7521
      thd->mark_used_columns= save_mark_used_columns;
      DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
7522
      DBUG_RETURN(TRUE); /* purecov: inspected */
7523
    }
7524 7525
    if (ref)
      *(ref++)= item;
7526 7527
    if (item->with_sum_func && item->type() != Item::SUM_FUNC_ITEM &&
	sum_func_list)
7528
      item->split_sum_func(thd, ref_pointer_array, *sum_func_list);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7529
    thd->used_tables|= item->used_tables();
7530
    thd->lex->current_select->cur_pos_in_select_list++;
7531
  }
7532
  thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
7533 7534
  thd->lex->current_select->cur_pos_in_select_list= UNDEF_POS;

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7535
  thd->lex->allow_sum_func= save_allow_sum_func;
7536 7537
  thd->mark_used_columns= save_mark_used_columns;
  DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
7538
  DBUG_RETURN(test(thd->is_error()));
7539
}
7540

7541

7542 7543 7544 7545 7546 7547 7548 7549 7550 7551 7552 7553 7554 7555 7556
/*
  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)
  {
7557 7558 7559 7560 7561 7562
    if (table->merge_underlying_list)
    {
      DBUG_ASSERT(table->view &&
                  table->effective_algorithm == VIEW_ALGORITHM_MERGE);
      list= make_leaves_list(list, table->merge_underlying_list);
    }
7563 7564 7565 7566 7567 7568 7569 7570 7571
    else
    {
      *list= table;
      list= &table->next_leaf;
    }
  }
  return list;
}

7572
/*
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7573 7574 7575 7576
  prepare tables

  SYNOPSIS
    setup_tables()
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7577
    thd		  Thread handler
7578
    context       name resolution contest to setup table list there
7579 7580 7581
    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
7582 7583
    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
7584

monty@mysql.com's avatar
monty@mysql.com committed
7585 7586
  NOTE
    Check also that the 'used keys' and 'ignored keys' exists and set up the
7587 7588 7589 7590
    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.
7591

monty@mysql.com's avatar
monty@mysql.com committed
7592 7593
    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
7594

monty@mysql.com's avatar
monty@mysql.com committed
7595
  RETURN
7596
    FALSE ok;  In this case *map will includes the chosen index
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7597
    TRUE  error
7598 7599
*/

7600
bool setup_tables(THD *thd, Name_resolution_context *context,
7601
                  List<TABLE_LIST> *from_clause, TABLE_LIST *tables,
7602
                  TABLE_LIST **leaves, bool select_insert)
7603
{
monty@mysql.com's avatar
monty@mysql.com committed
7604
  uint tablenr= 0;
7605
  DBUG_ENTER("setup_tables");
7606

7607 7608
  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
7609 7610
  /*
    this is used for INSERT ... SELECT.
7611
    For select we setup tables except first (and its underlying tables)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7612 7613 7614 7615
  */
  TABLE_LIST *first_select_table= (select_insert ?
                                   tables->next_local:
                                   0);
7616 7617 7618
  if (!(*leaves))
    make_leaves_list(leaves, tables);

7619 7620
  TABLE_LIST *table_list;
  for (table_list= *leaves;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7621
       table_list;
7622
       table_list= table_list->next_leaf, tablenr++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7623
  {
7624
    TABLE *table= table_list->table;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7625
    table->pos_in_table_list= table_list;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7626
    if (first_select_table &&
7627
        table_list->top_table() == first_select_table)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7628 7629 7630 7631 7632
    {
      /* new counting for SELECT of INSERT ... SELECT command */
      first_select_table= 0;
      tablenr= 0;
    }
7633
    setup_table_map(table, table_list, tablenr);
7634 7635
    if (table_list->process_index_hints(table))
      DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7636 7637 7638 7639
  }
  if (tablenr > MAX_TABLES)
  {
    my_error(ER_TOO_MANY_TABLES,MYF(0),MAX_TABLES);
7640
    DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7641
  }
7642
  for (table_list= tables;
7643 7644
       table_list;
       table_list= table_list->next_local)
7645
  {
7646
    if (table_list->merge_underlying_list)
7647
    {
7648 7649
      DBUG_ASSERT(table_list->view &&
                  table_list->effective_algorithm == VIEW_ALGORITHM_MERGE);
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7650
      Query_arena *arena= thd->stmt_arena, backup;
7651 7652 7653 7654
      bool res;
      if (arena->is_conventional())
        arena= 0;                                   // For easier test
      else
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7655
        thd->set_n_backup_active_arena(arena, &backup);
7656
      res= table_list->setup_underlying(thd);
7657
      if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7658
        thd->restore_active_arena(arena, &backup);
7659 7660 7661
      if (res)
        DBUG_RETURN(1);
    }
7662
  }
7663 7664 7665 7666 7667

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

7668
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7669
}
7670

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

7672 7673 7674 7675 7676 7677 7678 7679 7680 7681 7682 7683 7684 7685 7686 7687 7688 7689 7690 7691 7692 7693 7694 7695 7696 7697 7698
/*
  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
7699
                                   TABLE_LIST **leaves,
7700
                                   bool select_insert,
7701
                                   ulong want_access_first,
7702 7703
                                   ulong want_access)
{
monty@mysql.com's avatar
monty@mysql.com committed
7704
  TABLE_LIST *leaves_tmp= NULL;
7705
  bool first_table= true;
7706

monty@mysql.com's avatar
monty@mysql.com committed
7707 7708
  if (setup_tables(thd, context, from_clause, tables,
                   &leaves_tmp, select_insert))
7709 7710
    return TRUE;

7711 7712
  if (leaves)
    *leaves= leaves_tmp;
7713 7714

  for (; leaves_tmp; leaves_tmp= leaves_tmp->next_leaf)
monty@mysql.com's avatar
monty@mysql.com committed
7715
  {
7716
    if (leaves_tmp->belong_to_view && 
7717
        check_single_table_access(thd, first_table ? want_access_first :
7718
                                  want_access, leaves_tmp, FALSE))
7719 7720 7721 7722
    {
      tables->hide_view_error(thd);
      return TRUE;
    }
7723
    first_table= 0;
monty@mysql.com's avatar
monty@mysql.com committed
7724
  }
7725 7726 7727 7728
  return FALSE;
}


7729 7730 7731 7732 7733 7734 7735 7736 7737 7738 7739 7740 7741 7742 7743
/*
   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,
7744
                               List<String> *index_list)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7745
{
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
7746
  List_iterator_fast<String> it(*index_list);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7747 7748
  String *name;
  uint pos;
7749 7750

  map->clear_all();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7751 7752
  while ((name=it++))
  {
7753 7754 7755
    if (table->s->keynames.type_names == 0 ||
        (pos= find_type(&table->s->keynames, name->ptr(),
                        name->length(), 1)) <=
7756
        0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7757
    {
7758
      my_error(ER_KEY_DOES_NOT_EXITS, MYF(0), name->c_ptr(),
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7759
	       table->pos_in_table_list->alias);
7760
      map->set_all();
7761
      return 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7762
    }
7763
    map->set_bit(pos-1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7764
  }
7765
  return 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7766 7767
}

7768

7769 7770 7771 7772 7773 7774
/*
  Drops in all fields instead of current '*' field

  SYNOPSIS
    insert_fields()
    thd			Thread handler
7775
    context             Context for name resolution
7776 7777 7778 7779 7780 7781 7782
    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
7783
    0	ok     'it' is updated to point at last inserted
monty@mysql.com's avatar
monty@mysql.com committed
7784
    1	error.  Error message is generated but not sent to client
7785
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7786

sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
7787
bool
7788
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
7789
	      const char *table_name, List_iterator<Item> *it,
7790
              bool any_privileges)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7791
{
7792 7793
  Field_iterator_table_ref field_iterator;
  bool found;
monty@mysql.com's avatar
monty@mysql.com committed
7794
  char name_buff[NAME_LEN+1];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7795
  DBUG_ENTER("insert_fields");
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7796
  DBUG_PRINT("arena", ("stmt arena: 0x%lx", (ulong)thd->stmt_arena));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7797

7798 7799
  if (db_name && lower_case_table_names)
  {
monty@mysql.com's avatar
monty@mysql.com committed
7800 7801 7802 7803 7804
    /*
      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
7805
    strmake(name_buff, db_name, sizeof(name_buff)-1);
monty@mysql.com's avatar
monty@mysql.com committed
7806
    my_casedn_str(files_charset_info, name_buff);
monty@mysql.com's avatar
monty@mysql.com committed
7807
    db_name= name_buff;
7808 7809
  }

7810
  found= FALSE;
7811 7812 7813 7814 7815 7816 7817 7818

  /*
    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);
7819
       tables;
7820 7821 7822
       tables= (table_name ? tables->next_local :
                tables->next_name_resolution_table)
       )
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7823
  {
7824 7825 7826
    Field *field;
    TABLE *table= tables->table;

7827 7828
    DBUG_ASSERT(tables->is_leaf_for_name_resolution());

7829 7830
    if ((table_name && my_strcasecmp(table_alias_charset, table_name,
                                    tables->alias)) ||
7831 7832
        (db_name && strcmp(tables->db,db_name)))
      continue;
7833

hf@deer.(none)'s avatar
hf@deer.(none) committed
7834
#ifndef NO_EMBEDDED_ACCESS_CHECKS
7835 7836 7837 7838 7839 7840 7841 7842 7843 7844 7845 7846 7847 7848 7849 7850 7851 7852 7853 7854 7855 7856 7857 7858 7859 7860
    /* 
       Ensure that we have access rights to all fields to be inserted. Under
       some circumstances, this check may be skipped.

       - If any_privileges is true, skip the check.

       - If the SELECT privilege has been found as fulfilled already for both
         the TABLE and TABLE_LIST objects (and both of these exist, of
         course), the check is skipped.

       - If the SELECT privilege has been found fulfilled for the TABLE object
         and the TABLE_LIST represents a derived table other than a view (see
         below), the check is skipped.

       - If the TABLE_LIST object represents a view, we may skip checking if
         the SELECT privilege has been found fulfilled for it, regardless of
         the TABLE object.

       - If there is no TABLE object, the test is skipped if either 
         * the TABLE_LIST does not represent a view, or
         * the SELECT privilege has been found fulfilled.         

       A TABLE_LIST that is not a view may be a subquery, an
       information_schema table, or a nested table reference. See the comment
       for TABLE_LIST.
    */
7861
    if (!((table && !tables->view && (table->grant.privilege & SELECT_ACL)) ||
Staale Smedseng's avatar
Staale Smedseng committed
7862
          (tables->view && (tables->grant.privilege & SELECT_ACL))) &&
7863 7864 7865
        !any_privileges)
    {
      field_iterator.set(tables);
7866
      if (check_grant_all_columns(thd, SELECT_ACL, &field_iterator))
7867 7868
        DBUG_RETURN(TRUE);
    }
hf@deer.(none)'s avatar
hf@deer.(none) committed
7869
#endif
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7870

7871 7872 7873 7874 7875 7876 7877 7878 7879 7880 7881 7882 7883 7884 7885 7886 7887 7888 7889 7890 7891
    /*
      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);
7892 7893 7894 7895
      DBUG_ASSERT(item->fixed);
      /* cache the table for the Item_fields inserted by expanding stars */
      if (item->type() == Item::FIELD_ITEM && tables->cacheable_table)
        ((Item_field *)item)->cached_table= tables;
7896 7897

      if (!found)
7898
      {
7899
        found= TRUE;
7900
        it->replace(item); /* Replace '*' with the first found item. */
7901
      }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7902
      else
7903 7904 7905 7906 7907 7908 7909
        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,
7910 7911 7912
        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.
7913 7914
      */
      if (any_privileges)
7915
      {
7916
        DBUG_ASSERT((tables->field_translation == NULL && table) ||
7917 7918 7919
                    tables->is_natural_join);
        DBUG_ASSERT(item->type() == Item::FIELD_ITEM);
        Item_field *fld= (Item_field*) item;
7920
        const char *field_table_name= field_iterator.get_table_name();
7921

7922 7923 7924
        if (!tables->schema_table && 
            !(fld->have_privileges=
              (get_column_grant(thd, field_iterator.grant(),
7925
                                field_iterator.get_db_name(),
7926
                                field_table_name, fld->field_name) &
7927 7928
               VIEW_ANY_ACL)))
        {
7929
          my_error(ER_TABLEACCESS_DENIED_ERROR, MYF(0), "ANY",
7930 7931
                   thd->security_ctx->priv_user,
                   thd->security_ctx->host_or_ip,
7932
                   field_table_name);
7933 7934
          DBUG_RETURN(TRUE);
        }
7935
      }
7936
#endif
7937

7938
      if ((field= field_iterator.field()))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7939
      {
7940 7941
        /* Mark fields as used to allow storage engine to optimze access */
        bitmap_set_bit(field->table->read_set, field->field_index);
7942
        if (table)
7943
        {
7944
          table->covering_keys.intersect(field->part_of_key);
7945 7946
          table->merge_keys.merge(field->part_of_key);
        }
7947
        if (tables->is_natural_join)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
7948
        {
7949 7950
          TABLE *field_table;
          /*
7951
            In this case we are sure that the column ref will not be created
7952
            because it was already created and stored with the natural join.
7953
          */
7954
          Natural_join_column *nj_col;
timour@mysql.com's avatar
timour@mysql.com committed
7955
          if (!(nj_col= field_iterator.get_natural_column_ref()))
7956
            DBUG_RETURN(TRUE);
timour@mysql.com's avatar
timour@mysql.com committed
7957
          DBUG_ASSERT(nj_col->table_field);
7958 7959
          field_table= nj_col->table_ref->table;
          if (field_table)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7960
          {
7961
            thd->used_tables|= field_table->map;
7962
            field_table->covering_keys.intersect(field->part_of_key);
7963
            field_table->merge_keys.merge(field->part_of_key);
7964
            field_table->used_fields++;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7965
          }
7966
        }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7967
      }
7968 7969
      else
        thd->used_tables|= item->used_tables();
7970
      thd->lex->current_select->cur_pos_in_select_list++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7971
    }
7972 7973 7974 7975 7976 7977 7978 7979
    /*
      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
7980
  }
7981
  if (found)
7982
    DBUG_RETURN(FALSE);
7983

7984
  /*
7985 7986 7987
    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.
7988
  */
7989
  if (!table_name)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7990
    my_message(ER_NO_TABLES_USED, ER(ER_NO_TABLES_USED), MYF(0));
7991 7992
  else
    my_error(ER_BAD_TABLE_ERROR, MYF(0), table_name);
7993 7994

  DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7995 7996 7997 7998
}


/*
7999
  Fix all conditions and outer join expressions.
8000 8001 8002 8003

  SYNOPSIS
    setup_conds()
    thd     thread handler
8004 8005 8006 8007 8008 8009 8010 8011 8012 8013
    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
8014 8015
*/

8016 8017
int setup_conds(THD *thd, TABLE_LIST *tables, TABLE_LIST *leaves,
                COND **conds)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8018
{
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
8019
  SELECT_LEX *select_lex= thd->lex->current_select;
pem@mysql.comhem.se's avatar
pem@mysql.comhem.se committed
8020
  TABLE_LIST *table= NULL;	// For HP compilers
8021 8022 8023 8024 8025 8026 8027 8028 8029 8030
  /*
    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();
8031 8032
  bool save_is_item_list_lookup= select_lex->is_item_list_lookup;
  select_lex->is_item_list_lookup= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8033
  DBUG_ENTER("setup_conds");
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
8034

8035 8036
  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
8037
  select_lex->cond_count= 0;
8038
  select_lex->between_count= 0;
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
8039
  select_lex->max_equal_elems= 0;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8040

8041 8042 8043 8044 8045 8046
  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
8047 8048 8049
  if (*conds)
  {
    thd->where="where clause";
8050
    if ((!(*conds)->fixed && (*conds)->fix_fields(thd, conds)) ||
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
8051
	(*conds)->check_cols(1))
8052
      goto err_no_arena;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8053 8054
  }

8055 8056 8057 8058
  /*
    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
8059
  for (table= leaves; table; table= table->next_leaf)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8060
  {
8061 8062
    TABLE_LIST *embedded; /* The table at the current level of nesting. */
    TABLE_LIST *embedding= table; /* The parent nested table reference. */
8063
    do
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8064
    {
8065 8066
      embedded= embedding;
      if (embedded->on_expr)
8067
      {
8068 8069
        /* Make a join an a expression */
        thd->where="on clause";
8070 8071
        if ((!embedded->on_expr->fixed &&
            embedded->on_expr->fix_fields(thd, &embedded->on_expr)) ||
8072
	    embedded->on_expr->check_cols(1))
8073
	  goto err_no_arena;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
8074
        select_lex->cond_count++;
8075
      }
8076
      embedding= embedded->embedding;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8077
    }
8078 8079
    while (embedding &&
           embedding->nested_join->join_list.head() == embedded);
8080 8081 8082 8083

    /* process CHECK OPTION */
    if (it_is_update)
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
8084
      TABLE_LIST *view= table->top_table();
8085 8086 8087 8088 8089 8090 8091
      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
8092
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
8093

konstantin@mysql.com's avatar
konstantin@mysql.com committed
8094
  if (!thd->stmt_arena->is_conventional())
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
8095 8096 8097 8098 8099 8100 8101 8102 8103
  {
    /*
      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;
  }
8104
  thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
8105
  DBUG_RETURN(test(thd->is_error()));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
8106

8107
err_no_arena:
8108
  select_lex->is_item_list_lookup= save_is_item_list_lookup;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
8109
  DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8110 8111 8112 8113 8114 8115 8116 8117
}


/******************************************************************************
** 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
8118 8119 8120 8121 8122 8123 8124 8125 8126 8127 8128

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

8129 8130 8131 8132 8133
  NOTE
    fill_record() may set table->auto_increment_field_not_null and a
    caller should make sure that it is reset after their last call to this
    function.

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
8134 8135 8136 8137 8138
  RETURN
    FALSE   OK
    TRUE    error occured
*/

8139
static bool
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
8140 8141
fill_record(THD * thd, List<Item> &fields, List<Item> &values,
            bool ignore_errors)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8142
{
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
8143
  List_iterator_fast<Item> f(fields),v(values);
8144
  Item *value, *fld;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8145
  Item_field *field;
8146
  TABLE *table= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8147 8148
  DBUG_ENTER("fill_record");

8149 8150 8151 8152 8153 8154 8155 8156 8157 8158 8159 8160 8161 8162 8163 8164 8165 8166 8167 8168
  /*
    Reset the table->auto_increment_field_not_null as it is valid for
    only one row.
  */
  if (fields.elements)
  {
    /*
      On INSERT or UPDATE fields are checked to be from the same table,
      thus we safely can take table from the first field.
    */
    fld= (Item_field*)f++;
    if (!(field= fld->filed_for_view_update()))
    {
      my_error(ER_NONUPDATEABLE_COLUMN, MYF(0), fld->name);
      goto err;
    }
    table= field->field->table;
    table->auto_increment_field_not_null= FALSE;
    f.rewind();
  }
8169
  while ((fld= f++))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8170
  {
8171 8172 8173
    if (!(field= fld->filed_for_view_update()))
    {
      my_error(ER_NONUPDATEABLE_COLUMN, MYF(0), fld->name);
8174
      goto err;
8175
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8176
    value=v++;
8177
    Field *rfield= field->field;
8178
    table= rfield->table;
8179
    if (rfield == table->next_number_field)
8180
      table->auto_increment_field_not_null= TRUE;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
8181
    if ((value->save_in_field(rfield, 0) < 0) && !ignore_errors)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
8182 8183
    {
      my_message(ER_UNKNOWN_ERROR, ER(ER_UNKNOWN_ERROR), MYF(0));
8184
      goto err;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
8185
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8186
  }
8187
  DBUG_RETURN(thd->is_error());
8188 8189 8190 8191
err:
  if (table)
    table->auto_increment_field_not_null= FALSE;
  DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8192 8193 8194
}


8195 8196 8197 8198 8199 8200 8201 8202 8203 8204 8205 8206 8207 8208 8209 8210 8211 8212 8213 8214 8215 8216 8217 8218 8219 8220 8221 8222 8223 8224
/*
  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) ||
8225 8226
          (triggers && triggers->process_triggers(thd, event,
                                                 TRG_ACTION_BEFORE, TRUE)));
8227 8228 8229
}


bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
8230 8231 8232 8233 8234 8235 8236 8237 8238 8239
/*
  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

8240 8241 8242 8243 8244
  NOTE
    fill_record() may set table->auto_increment_field_not_null and a
    caller should make sure that it is reset after their last call to this
    function.

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
8245 8246 8247 8248 8249 8250 8251
  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
8252
{
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
8253
  List_iterator_fast<Item> v(values);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8254
  Item *value;
8255
  TABLE *table= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8256 8257 8258
  DBUG_ENTER("fill_record");

  Field *field;
8259 8260 8261 8262 8263 8264 8265 8266 8267 8268 8269 8270 8271
  /*
    Reset the table->auto_increment_field_not_null as it is valid for
    only one row.
  */
  if (*ptr)
  {
    /*
      On INSERT or UPDATE fields are checked to be from the same table,
      thus we safely can take table from the first field.
    */
    table= (*ptr)->table;
    table->auto_increment_field_not_null= FALSE;
  }
8272
  while ((field = *ptr++) && ! thd->is_error())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8273 8274
  {
    value=v++;
8275
    table= field->table;
8276
    if (field == table->next_number_field)
8277
      table->auto_increment_field_not_null= TRUE;
8278
    if (value->save_in_field(field, 0) < 0)
8279
      goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8280
  }
8281
  DBUG_RETURN(thd->is_error());
8282 8283 8284 8285 8286

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


8290 8291 8292 8293 8294 8295 8296 8297 8298 8299 8300 8301 8302 8303 8304 8305 8306 8307 8308 8309 8310 8311 8312 8313 8314 8315 8316 8317 8318 8319
/*
  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) ||
8320 8321
          (triggers && triggers->process_triggers(thd, event,
                                                 TRG_ACTION_BEFORE, TRUE)));
8322 8323 8324
}


8325
my_bool mysql_rm_tmp_tables(void)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8326
{
8327
  uint i, idx;
8328
  char	filePath[FN_REFLEN], *tmpdir, filePathCopy[FN_REFLEN];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8329 8330
  MY_DIR *dirp;
  FILEINFO *file;
8331
  TABLE_SHARE share;
8332
  THD *thd;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8333 8334
  DBUG_ENTER("mysql_rm_tmp_tables");

8335 8336
  if (!(thd= new THD))
    DBUG_RETURN(1);
8337
  thd->thread_stack= (char*) &thd;
8338 8339
  thd->store_globals();

8340 8341 8342
  for (i=0; i<=mysql_tmpdir_list.max; i++)
  {
    tmpdir=mysql_tmpdir_list.list[i];
8343
    /* See if the directory exists */
8344 8345
    if (!(dirp = my_dir(tmpdir,MYF(MY_WME | MY_DONT_SORT))))
      continue;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8346

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

8349 8350 8351
    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
8352

8353 8354 8355 8356
      /* 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
8357

8358 8359
      if (!bcmp((uchar*) file->name, (uchar*) tmp_file_prefix,
                tmp_file_prefix_length))
8360
      {
8361 8362 8363 8364 8365
        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);
8366
        if (!bcmp((uchar*) reg_ext, (uchar*) ext, ext_len))
8367
        {
8368 8369 8370 8371
          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;
8372
          init_tmp_table_share(thd, &share, "", 0, "", filePathCopy);
8373 8374
          if (!open_table_def(thd, &share, 0) &&
              ((handler_file= get_new_handler(&share, thd->mem_root,
antony@ppcg5.local's avatar
antony@ppcg5.local committed
8375
                                              share.db_type()))))
8376
          {
8377
            handler_file->ha_delete_table(filePathCopy);
8378 8379 8380
            delete handler_file;
          }
          free_table_share(&share);
8381
        }
8382 8383 8384 8385 8386
        /*
          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)).
        */
Marc Alff's avatar
Marc Alff committed
8387
        (void) mysql_file_delete(key_file_misc, filePath, MYF(0));
8388
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8389
    }
8390
    my_dirend(dirp);
8391
  }
8392 8393 8394
  delete thd;
  my_pthread_setspecific_ptr(THR_THD,  0);
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8395 8396 8397 8398 8399 8400 8401 8402 8403
}



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

/*
8404 8405 8406 8407 8408 8409 8410 8411 8412 8413
  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
8414 8415
*/

8416
void remove_db_from_cache(const char *db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8417 8418 8419
{
  for (uint idx=0 ; idx < open_cache.records ; idx++)
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
8420
    TABLE *table=(TABLE*) my_hash_element(&open_cache,idx);
8421
    if (!strcmp(table->s->db.str, db))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8422
    {
8423
      table->s->version= 0L;			/* Free when thread is ready */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8424 8425 8426 8427
      if (!table->in_use)
	relink_unused(table);
    }
  }
8428
  while (unused_tables && !unused_tables->s->version)
Konstantin Osipov's avatar
Konstantin Osipov committed
8429
    my_hash_delete(&open_cache,(uchar*) unused_tables);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8430 8431 8432 8433
}


/*
8434 8435 8436 8437 8438
  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
8439 8440 8441 8442
*/

void flush_tables()
{
Marc Alff's avatar
Marc Alff committed
8443
  mysql_mutex_lock(&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8444
  while (unused_tables)
Konstantin Osipov's avatar
Konstantin Osipov committed
8445
    my_hash_delete(&open_cache,(uchar*) unused_tables);
Marc Alff's avatar
Marc Alff committed
8446
  mysql_mutex_unlock(&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8447 8448 8449 8450
}


/*
8451 8452 8453 8454 8455
  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
8456 8457 8458
  PREREQUISITES
    Lock on LOCK_open()

8459 8460 8461 8462
  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
8463 8464
*/

8465
bool remove_table_from_cache(THD *thd, const char *db, const char *table_name,
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8466
                             uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8467 8468 8469 8470
{
  char key[MAX_DBKEY_LENGTH];
  uint key_length;
  TABLE *table;
8471 8472
  TABLE_SHARE *share;
  bool result= 0, signalled= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8473
  DBUG_ENTER("remove_table_from_cache");
8474
  DBUG_PRINT("enter", ("table: '%s'.'%s'  flags: %u", db, table_name, flags));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8475 8476

  key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
8477
  for (;;)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8478
  {
8479
    HASH_SEARCH_STATE state;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8480 8481
    result= signalled= 0;

Konstantin Osipov's avatar
Konstantin Osipov committed
8482 8483
    for (table= (TABLE*) my_hash_first(&open_cache, (uchar*) key, key_length,
                                       &state);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8484
         table;
Konstantin Osipov's avatar
Konstantin Osipov committed
8485 8486
         table= (TABLE*) my_hash_next(&open_cache, (uchar*) key, key_length,
                                      &state))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8487
    {
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8488
      THD *in_use;
8489 8490
      DBUG_PRINT("tcache", ("found table: '%s'.'%s' 0x%lx", table->s->db.str,
                            table->s->table_name.str, (long) table));
8491

8492
      table->s->version=0L;		/* Free when thread is ready */
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8493
      if (!(in_use=table->in_use))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8494
      {
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8495 8496
        DBUG_PRINT("info",("Table was not in use"));
        relink_unused(table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8497
      }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8498
      else if (in_use != thd)
8499
      {
8500
        DBUG_PRINT("info", ("Table was in use by other thread"));
8501 8502 8503 8504 8505 8506
        /*
          Mark that table is going to be deleted from cache. This will
          force threads that are in mysql_lock_tables() (but not yet
          in thr_multi_lock()) to abort it's locks, close all tables and retry
        */
        in_use->some_tables_deleted= 1;
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
8507
        if (table->is_name_opened())
monty@mysql.com's avatar
monty@mysql.com committed
8508 8509
        {
          DBUG_PRINT("info", ("Found another active instance of the table"));
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8510
  	  result=1;
monty@mysql.com's avatar
monty@mysql.com committed
8511
        }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8512 8513 8514 8515
        /* Kill delayed insert threads */
        if ((in_use->system_thread & SYSTEM_THREAD_DELAYED_INSERT) &&
            ! in_use->killed)
        {
8516
	  in_use->killed= THD::KILL_CONNECTION;
Marc Alff's avatar
Marc Alff committed
8517
          mysql_mutex_lock(&in_use->mysys_var->mutex);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8518 8519
	  if (in_use->mysys_var->current_cond)
	  {
Marc Alff's avatar
Marc Alff committed
8520
            mysql_mutex_lock(in_use->mysys_var->current_mutex);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8521
            signalled= 1;
Marc Alff's avatar
Marc Alff committed
8522 8523
            mysql_cond_broadcast(in_use->mysys_var->current_cond);
            mysql_mutex_unlock(in_use->mysys_var->current_mutex);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8524
	  }
Marc Alff's avatar
Marc Alff committed
8525
          mysql_mutex_unlock(&in_use->mysys_var->mutex);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8526 8527 8528
        }
        /*
	  Now we must abort all tables locks used by this thread
8529 8530 8531 8532 8533 8534
	  as the thread may be waiting to get a lock for another table.
          Note that we need to hold LOCK_open while going through the
          list. So that the other thread cannot change it. The other
          thread must also hold LOCK_open whenever changing the
          open_tables list. Aborting the MERGE lock after a child was
          closed and before the parent is closed would be fatal.
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8535 8536 8537 8538 8539
        */
        for (TABLE *thd_table= in_use->open_tables;
	     thd_table ;
	     thd_table= thd_table->next)
        {
8540 8541
          /* Do not handle locks of MERGE children. */
	  if (thd_table->db_stat && !thd_table->parent)	// If table is open
8542
	    signalled|= mysql_lock_abort_for_thread(thd, thd_table);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8543
        }
8544
      }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8545
      else
8546 8547 8548
      {
        DBUG_PRINT("info", ("Table was in use by current thread. db_stat: %u",
                            table->db_stat));
8549
        result= result || (flags & RTFC_OWNED_BY_THD_FLAG);
8550
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8551
    }
8552
    while (unused_tables && !unused_tables->s->version)
Konstantin Osipov's avatar
Konstantin Osipov committed
8553
      my_hash_delete(&open_cache,(uchar*) unused_tables);
8554 8555 8556

    DBUG_PRINT("info", ("Removing table from table_def_cache"));
    /* Remove table from table definition cache if it's not in use */
Konstantin Osipov's avatar
Konstantin Osipov committed
8557 8558
    if ((share= (TABLE_SHARE*) my_hash_search(&table_def_cache,(uchar*) key,
                                              key_length)))
8559 8560 8561 8562 8563 8564
    {
      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)
      {
Marc Alff's avatar
Marc Alff committed
8565
        mysql_mutex_lock(&share->mutex);
Konstantin Osipov's avatar
Konstantin Osipov committed
8566
        my_hash_delete(&table_def_cache, (uchar*) share);
8567 8568 8569
      }
    }

8570
    if (result && (flags & RTFC_WAIT_OTHER_THREAD_FLAG))
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8571
    {
monty@mysql.com's avatar
monty@mysql.com committed
8572 8573 8574 8575
      /*
        Signal any thread waiting for tables to be freed to
        reopen their tables
      */
8576
      broadcast_refresh();
monty@mysql.com's avatar
monty@mysql.com committed
8577
      DBUG_PRINT("info", ("Waiting for refresh signal"));
8578
      if (!(flags & RTFC_CHECK_KILLED_FLAG) || !thd->killed)
8579
      {
monty@mysql.com's avatar
monty@mysql.com committed
8580
        dropping_tables++;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8581
        if (likely(signalled))
Marc Alff's avatar
Marc Alff committed
8582
          mysql_cond_wait(&COND_refresh, &LOCK_open);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8583 8584
        else
        {
monty@mysql.com's avatar
monty@mysql.com committed
8585
          struct timespec abstime;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8586 8587 8588 8589 8590 8591 8592 8593 8594 8595
          /*
            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
8596
          set_timespec(abstime, 10);
Marc Alff's avatar
Marc Alff committed
8597
          mysql_cond_timedwait(&COND_refresh, &LOCK_open, &abstime);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8598
        }
monty@mysql.com's avatar
monty@mysql.com committed
8599 8600
        dropping_tables--;
        continue;
8601
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8602
    }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
8603
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8604 8605 8606 8607
  }
  DBUG_RETURN(result);
}

8608

8609
int setup_ftfuncs(SELECT_LEX *select_lex)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8610
{
8611 8612
  List_iterator<Item_func_match> li(*(select_lex->ftfunc_list)),
                                 lj(*(select_lex->ftfunc_list));
8613
  Item_func_match *ftf, *ftf2;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8614 8615

  while ((ftf=li++))
8616
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8617 8618
    if (ftf->fix_index())
      return 1;
8619 8620
    lj.rewind();
    while ((ftf2=lj++) != ftf)
8621
    {
8622
      if (ftf->eq(ftf2,1) && !ftf2->master)
8623 8624 8625
        ftf2->master=ftf;
    }
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8626 8627 8628

  return 0;
}
8629

8630

8631
int init_ftfuncs(THD *thd, SELECT_LEX *select_lex, bool no_order)
8632
{
8633
  if (select_lex->ftfunc_list->elements)
8634
  {
8635
    List_iterator<Item_func_match> li(*(select_lex->ftfunc_list));
8636 8637
    Item_func_match *ifm;
    DBUG_PRINT("info",("Performing FULLTEXT search"));
8638
    thd_proc_info(thd, "FULLTEXT initialization");
8639

8640 8641 8642
    while ((ifm=li++))
      ifm->init_search(no_order);
  }
8643 8644
  return 0;
}
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8645 8646 8647 8648 8649 8650 8651


/*
  open new .frm format table

  SYNOPSIS
    open_new_frm()
8652
    THD		  thread handler
8653
    path	  path to .frm file (without extension)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8654
    alias	  alias for table
8655 8656
    db            database
    table_name    name of table
8657
    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
8658 8659 8660 8661 8662 8663 8664
		  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
*/
8665

Sergey Glukhov's avatar
Sergey Glukhov committed
8666
bool
8667
open_new_frm(THD *thd, TABLE_SHARE *share, const char *alias,
8668
             uint db_stat, uint prgflag,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8669 8670 8671 8672
	     uint ha_open_flags, TABLE *outparam, TABLE_LIST *table_desc,
	     MEM_ROOT *mem_root)
{
  LEX_STRING pathstr;
8673
  File_parser *parser;
8674
  char path[FN_REFLEN];
8675 8676
  DBUG_ENTER("open_new_frm");

8677 8678 8679 8680
  /* Create path with extension */
  pathstr.length= (uint) (strxmov(path, share->normalized_path.str, reg_ext,
                                  NullS)- path);
  pathstr.str=    path;
8681

8682
  if ((parser= sql_parse_prepare(&pathstr, mem_root, 1)))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8683
  {
8684
    if (is_equal(&view_type, parser->type()))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8685
    {
8686
      if (table_desc == 0 || table_desc->required_type == FRMTYPE_TABLE)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8687
      {
8688 8689
        my_error(ER_WRONG_OBJECT, MYF(0), share->db.str, share->table_name.str,
                 "BASE TABLE");
8690
        goto err;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8691
      }
8692 8693
      if (mysql_make_view(thd, parser, table_desc,
                          (prgflag & OPEN_VIEW_NO_PARSE)))
8694
        goto err;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8695 8696 8697 8698
    }
    else
    {
      /* only VIEWs are supported now */
8699
      my_error(ER_FRM_UNKNOWN_TYPE, MYF(0), share->path.str,  parser->type()->str);
8700
      goto err;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8701
    }
8702
    DBUG_RETURN(0);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
8703
  }
monty@mysql.com's avatar
monty@mysql.com committed
8704
 
8705 8706 8707
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
8708
}
8709 8710 8711 8712 8713 8714


bool is_equal(const LEX_STRING *a, const LEX_STRING *b)
{
  return a->length == b->length && !strncmp(a->str, b->str, a->length);
}
8715 8716 8717 8718 8719 8720 8721


/*
  SYNOPSIS
    abort_and_upgrade_lock()
    lpt                           Parameter passing struct
    All parameters passed through the ALTER_PARTITION_PARAM_TYPE object
8722 8723
  RETURN VALUE
    0
8724 8725 8726 8727 8728 8729 8730 8731 8732 8733 8734 8735 8736
  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
*/

8737
int abort_and_upgrade_lock(ALTER_PARTITION_PARAM_TYPE *lpt)
8738 8739 8740 8741 8742
{
  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;
Marc Alff's avatar
Marc Alff committed
8743
  mysql_mutex_lock(&LOCK_open);
8744 8745 8746
  /* If MERGE child, forward lock handling to parent. */
  mysql_lock_abort(lpt->thd, lpt->table->parent ? lpt->table->parent :
                   lpt->table, TRUE);
Konstantin Osipov's avatar
Konstantin Osipov committed
8747
  (void) remove_table_from_cache(lpt->thd, lpt->db, lpt->table_name, flags);
Marc Alff's avatar
Marc Alff committed
8748
  mysql_mutex_unlock(&LOCK_open);
8749
  DBUG_RETURN(0);
8750 8751 8752 8753 8754 8755 8756 8757 8758 8759 8760 8761 8762 8763 8764 8765 8766
}


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

8767
/* purecov: begin deadcode */
8768 8769
void close_open_tables_and_downgrade(ALTER_PARTITION_PARAM_TYPE *lpt)
{
Marc Alff's avatar
Marc Alff committed
8770
  mysql_mutex_lock(&LOCK_open);
8771 8772
  remove_table_from_cache(lpt->thd, lpt->db, lpt->table_name,
                          RTFC_WAIT_OTHER_THREAD_FLAG);
Marc Alff's avatar
Marc Alff committed
8773
  mysql_mutex_unlock(&LOCK_open);
8774 8775 8776
  /* If MERGE child, forward lock handling to parent. */
  mysql_lock_downgrade_write(lpt->thd, lpt->table->parent ? lpt->table->parent :
                             lpt->table, lpt->old_lock_type);
8777
}
8778
/* purecov: end */
8779 8780 8781 8782 8783 8784 8785 8786 8787 8788 8789 8790 8791 8792 8793 8794 8795 8796 8797 8798 8799 8800 8801 8802 8803 8804 8805 8806 8807 8808 8809 8810 8811


/*
  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;
Marc Alff's avatar
Marc Alff committed
8812
  mysql_mutex_lock(&LOCK_open);
8813
  HASH_SEARCH_STATE state;
Konstantin Osipov's avatar
Konstantin Osipov committed
8814 8815
  for (table= (TABLE*) my_hash_first(&open_cache,(uchar*) key,key_length,
                                     &state) ;
8816
       table;
Konstantin Osipov's avatar
Konstantin Osipov committed
8817 8818
       table= (TABLE*) my_hash_next(&open_cache,(uchar*) key,key_length,
                                    &state))
8819 8820 8821 8822 8823 8824 8825 8826 8827 8828 8829 8830 8831 8832
  {
    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;
Marc Alff's avatar
Marc Alff committed
8833
        mysql_mutex_lock(&in_use->mysys_var->mutex);
8834 8835
        if (in_use->mysys_var->current_cond)
        {
Marc Alff's avatar
Marc Alff committed
8836 8837 8838
          mysql_mutex_lock(in_use->mysys_var->current_mutex);
          mysql_cond_broadcast(in_use->mysys_var->current_cond);
          mysql_mutex_unlock(in_use->mysys_var->current_mutex);
8839
        }
Marc Alff's avatar
Marc Alff committed
8840
        mysql_mutex_unlock(&in_use->mysys_var->mutex);
8841 8842 8843
      }
      /*
        Now we must abort all tables locks used by this thread
8844 8845 8846 8847 8848 8849
        as the thread may be waiting to get a lock for another table.
        Note that we need to hold LOCK_open while going through the
        list. So that the other thread cannot change it. The other
        thread must also hold LOCK_open whenever changing the
        open_tables list. Aborting the MERGE lock after a child was
        closed and before the parent is closed would be fatal.
8850 8851 8852 8853 8854
      */
      for (TABLE *thd_table= in_use->open_tables;
           thd_table ;
           thd_table= thd_table->next)
      {
8855 8856
        /* Do not handle locks of MERGE children. */
        if (thd_table->db_stat && !thd_table->parent) // If table is open
8857 8858 8859 8860 8861 8862 8863 8864 8865
          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.
8866
    If MERGE child, forward lock handling to parent.
8867
  */
8868 8869
  mysql_lock_abort(lpt->thd, my_table->parent ? my_table->parent : my_table,
                   FALSE);
Marc Alff's avatar
Marc Alff committed
8870
  mysql_mutex_unlock(&LOCK_open);
8871 8872 8873
  DBUG_VOID_RETURN;
}

8874 8875

/*
8876
  Check if one (or more) write tables have auto_increment columns.
8877

8878 8879 8880 8881
  @param[in] tables Table list

  @retval 0 if at least one write tables has an auto_increment column
  @retval 1 otherwise
8882 8883 8884 8885 8886 8887 8888 8889

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

static bool
8890
has_write_table_with_auto_increment(TABLE_LIST *tables)
8891 8892 8893 8894
{
  for (TABLE_LIST *table= tables; table; table= table->next_global)
  {
    /* we must do preliminary checks as table->table may be NULL */
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
8895
    if (!table->placeholder() &&
8896 8897
        table->table->found_next_number_field &&
        (table->lock_type >= TL_WRITE_ALLOW_WRITE))
8898
      return 1;
8899
  }
8900

8901 8902
  return 0;
}
8903 8904 8905 8906 8907 8908 8909 8910 8911 8912 8913 8914 8915 8916 8917 8918 8919 8920 8921 8922 8923 8924 8925 8926 8927 8928 8929 8930 8931 8932 8933 8934 8935 8936 8937 8938 8939 8940 8941 8942 8943 8944 8945


/*
  Open and lock system tables for read.

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

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

  RETURN
    FALSE   Success
    TRUE    Error
*/

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

  thd->reset_n_backup_open_tables_state(backup);

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

8946
    DBUG_ASSERT(table->s->table_category == TABLE_CATEGORY_SYSTEM);
8947 8948 8949 8950 8951 8952 8953 8954 8955 8956 8957 8958 8959 8960 8961 8962 8963 8964 8965 8966 8967 8968 8969 8970 8971 8972 8973 8974 8975 8976 8977 8978 8979 8980 8981 8982 8983 8984 8985 8986 8987 8988 8989 8990 8991 8992 8993 8994 8995 8996 8997 8998 8999 9000 9001 9002 9003 9004 9005 9006 9007 9008 9009 9010 9011 9012

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

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

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

error:
  close_system_tables(thd, backup);

  DBUG_RETURN(TRUE);
}


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

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

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


/*
  Open and lock one system table for update.

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

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

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

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

9013
  TABLE *table= open_ltable(thd, one_table, one_table->lock_type, 0);
9014 9015
  if (table)
  {
9016
    DBUG_ASSERT(table->s->table_category == TABLE_CATEGORY_SYSTEM);
9017 9018 9019 9020 9021
    table->use_all_columns();
  }

  DBUG_RETURN(table);
}
9022 9023

/**
Marc Alff's avatar
Marc Alff committed
9024
  Open a log table.
9025 9026 9027 9028
  Opening such tables is performed internally in the server
  implementation, and is a 'nested' open, since some tables
  might be already opened by the current thread.
  The thread context before this call is saved, and is restored
Marc Alff's avatar
Marc Alff committed
9029
  when calling close_log_table().
9030
  @param thd The current thread
Marc Alff's avatar
Marc Alff committed
9031
  @param one_table Log table to open
9032 9033 9034
  @param backup [out] Temporary storage used to save the thread context
*/
TABLE *
Marc Alff's avatar
Marc Alff committed
9035
open_log_table(THD *thd, TABLE_LIST *one_table, Open_tables_state *backup)
9036
{
9037 9038 9039 9040 9041 9042 9043
  uint flags= ( MYSQL_LOCK_IGNORE_GLOBAL_READ_LOCK |
                MYSQL_LOCK_IGNORE_GLOBAL_READ_ONLY |
                MYSQL_LOCK_IGNORE_FLUSH |
                MYSQL_LOCK_PERF_SCHEMA);
  TABLE *table;
  /* Save value that is changed in mysql_lock_tables() */
  ulonglong save_utime_after_lock= thd->utime_after_lock;
Marc Alff's avatar
Marc Alff committed
9044
  DBUG_ENTER("open_log_table");
9045 9046 9047

  thd->reset_n_backup_open_tables_state(backup);

9048
  if ((table= open_ltable(thd, one_table, one_table->lock_type, flags)))
9049
  {
Marc Alff's avatar
Marc Alff committed
9050
    DBUG_ASSERT(table->s->table_category == TABLE_CATEGORY_LOG);
9051
    /* Make sure all columns get assigned to a default value */
9052
    table->use_all_columns();
9053
    table->no_replicate= 1;
9054 9055 9056 9057 9058
    /*
      Don't set automatic timestamps as we may want to use time of logging,
      not from query start
    */
    table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
9059
  }
9060
  else
9061 9062 9063 9064 9065 9066 9067 9068 9069
  {
    /*
      If error in mysql_lock_tables(), open_ltable doesn't close the
      table. Thread kill during mysql_lock_tables() is such error. But
      open tables cannot be accepted when restoring the open tables
      state.
    */
    if (thd->killed)
      close_thread_tables(thd);
9070
    thd->restore_backup_open_tables_state(backup);
9071
  }
9072

9073
  thd->utime_after_lock= save_utime_after_lock;
9074 9075
  DBUG_RETURN(table);
}
9076 9077

/**
Marc Alff's avatar
Marc Alff committed
9078 9079
  Close a log table.
  The last table opened by open_log_table()
9080 9081 9082 9083
  is closed, then the thread context is restored.
  @param thd The current thread
  @param backup [in] the context to restore.
*/
Marc Alff's avatar
Marc Alff committed
9084
void close_log_table(THD *thd, Open_tables_state *backup)
9085 9086 9087
{
  bool found_old_table;

9088
  /*
Marc Alff's avatar
Marc Alff committed
9089
    If open_log_table() fails,
9090 9091 9092
    this function should not be called.
  */
  DBUG_ASSERT(thd->lock != NULL);
9093

9094 9095 9096 9097 9098 9099 9100 9101 9102 9103 9104 9105 9106
  /*
    Note:
    We do not create explicitly a separate transaction for the
    performance table I/O, but borrow the current transaction.
    lock + unlock will autocommit the change done in the
    performance schema table: this is the expected result.
    The current transaction should not be affected by this code.
    TODO: Note that if a transactional engine is used for log tables,
    this code will need to be revised, as a separate transaction
    might be needed.
  */
  mysql_unlock_tables(thd, thd->lock);
  thd->lock= 0;
9107

Marc Alff's avatar
Marc Alff committed
9108
  mysql_mutex_lock(&LOCK_open);
9109 9110

  found_old_table= false;
9111 9112 9113 9114 9115 9116 9117
  /*
    Note that we need to hold LOCK_open while changing the
    open_tables list. Another thread may work on it.
    (See: remove_table_from_cache(), mysql_wait_completed_table())
    Closing a MERGE child before the parent would be fatal if the
    other thread tries to abort the MERGE lock in between.
  */
9118 9119 9120 9121 9122 9123
  while (thd->open_tables)
    found_old_table|= close_thread_table(thd, &thd->open_tables);

  if (found_old_table)
    broadcast_refresh();

Marc Alff's avatar
Marc Alff committed
9124
  mysql_mutex_unlock(&LOCK_open);
9125 9126 9127 9128

  thd->restore_backup_open_tables_state(backup);
}

9129 9130 9131
/**
  @} (end of group Data_Dictionary)
*/