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

unknown's avatar
unknown committed
3 4 5 6
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
7

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

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


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

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

TABLE *unused_tables;				/* Used by mysql_test */
HASH open_cache;				/* Used by mysql_test */

unknown's avatar
VIEW  
unknown committed
35 36 37
static int open_unireg_entry(THD *thd, TABLE *entry, const char *db,
			     const char *name, const char *alias,
			     TABLE_LIST *table_list, MEM_ROOT *mem_root);
unknown's avatar
unknown committed
38 39
static void free_cache_entry(TABLE *entry);
static void mysql_rm_tmp_tables(void);
40 41 42 43 44
static bool open_new_frm(THD *thd, const char *path, const char *alias,
                         const char *db, const char *table_name,
                         uint db_stat, uint prgflag,
                         uint ha_open_flags, TABLE *outparam,
                         TABLE_LIST *table_desc, MEM_ROOT *mem_root);
unknown's avatar
unknown committed
45

46 47
extern "C" byte *table_cache_key(const byte *record,uint *length,
				 my_bool not_used __attribute__((unused)))
unknown's avatar
unknown committed
48 49
{
  TABLE *entry=(TABLE*) record;
50 51
  *length= entry->s->key_length;
  return (byte*) entry->s->table_cache_key;
unknown's avatar
unknown committed
52 53
}

unknown's avatar
unknown committed
54
bool table_cache_init(void)
unknown's avatar
unknown committed
55 56
{
  mysql_rm_tmp_tables();
unknown's avatar
unknown committed
57 58 59
  return hash_init(&open_cache, &my_charset_bin, table_cache_size+16,
		   0, 0,table_cache_key,
		   (hash_free_key) free_cache_entry, 0) != 0;
unknown's avatar
unknown committed
60 61 62 63 64
}

void table_cache_free(void)
{
  DBUG_ENTER("table_cache_free");
unknown's avatar
unknown committed
65
  close_cached_tables((THD*) 0,0,(TABLE_LIST*) 0);
unknown's avatar
unknown committed
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
  if (!open_cache.records)			// Safety first
    hash_free(&open_cache);
  DBUG_VOID_RETURN;
}

uint cached_tables(void)
{
  return open_cache.records;
}

#ifdef EXTRA_DEBUG
static void check_unused(void)
{
  uint count=0,idx=0;
  TABLE *cur_link,*start_link;

  if ((start_link=cur_link=unused_tables))
  {
    do
    {
      if (cur_link != cur_link->next->prev || cur_link != cur_link->prev->next)
      {
	DBUG_PRINT("error",("Unused_links aren't linked properly")); /* purecov: inspected */
	return; /* purecov: inspected */
      }
    } while (count++ < open_cache.records &&
	     (cur_link=cur_link->next) != start_link);
    if (cur_link != start_link)
    {
      DBUG_PRINT("error",("Unused_links aren't connected")); /* purecov: inspected */
    }
  }
  for (idx=0 ; idx < open_cache.records ; idx++)
  {
    TABLE *entry=(TABLE*) hash_element(&open_cache,idx);
    if (!entry->in_use)
      count--;
  }
  if (count != 0)
  {
106
    DBUG_PRINT("error",("Unused_links doesn't match open_cache: diff: %d", /* purecov: inspected */
unknown's avatar
unknown committed
107 108 109 110 111 112 113
			count)); /* purecov: inspected */
  }
}
#else
#define check_unused()
#endif

unknown's avatar
unknown committed
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
/*
  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.
*/

132
OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *db, const char *wild)
133 134
{
  int result = 0;
135
  OPEN_TABLE_LIST **start_list, *open_list;
136 137
  TABLE_LIST table_list;
  DBUG_ENTER("list_open_tables");
138

139 140
  VOID(pthread_mutex_lock(&LOCK_open));
  bzero((char*) &table_list,sizeof(table_list));
141 142
  start_list= &open_list;
  open_list=0;
143

144
  for (uint idx=0 ; result == 0 && idx < open_cache.records; idx++)
145
  {
146
    OPEN_TABLE_LIST *table;
147
    TABLE *entry=(TABLE*) hash_element(&open_cache,idx);
148
    TABLE_SHARE *share= entry->s;
149

150
    DBUG_ASSERT(share->table_name != 0);
151
    if ((!share->table_name))			// To be removed
152
      continue;					// Shouldn't happen
153 154 155
    if (db && my_strcasecmp(system_charset_info, db, share->db))
      continue;
    if (wild && wild_compare(share->table_name,wild,0))
156
      continue;
157

158
    /* Check if user has SELECT privilege for any column in the table */
159 160
    table_list.db=        (char*) share->db;
    table_list.table_name= (char*) share->table_name;
161
    table_list.grant.privilege=0;
unknown's avatar
unknown committed
162

unknown's avatar
unknown committed
163
    if (check_table_access(thd,SELECT_ACL | EXTRA_ACL,&table_list,1))
164 165 166
      continue;
    /* need to check if we haven't already listed it */
    for (table= open_list  ; table ; table=table->next)
167
    {
168 169
      if (!strcmp(table->table,share->table_name) &&
	  !strcmp(table->db,entry->s->db))
170 171 172 173 174 175 176
      {
	if (entry->in_use)
	  table->in_use++;
	if (entry->locked_by_name)
	  table->locked++;
	break;
      }
177
    }
178
    if (table)
179
      continue;
180
    if (!(*start_list = (OPEN_TABLE_LIST *)
181
	  sql_alloc(sizeof(**start_list)+share->key_length)))
182
    {
183
      open_list=0;				// Out of memory
184
      break;
185
    }
186 187
    strmov((*start_list)->table=
	   strmov(((*start_list)->db= (char*) ((*start_list)+1)),
188 189
		  entry->s->db)+1,
	   entry->s->table_name);
190 191 192
    (*start_list)->in_use= entry->in_use ? 1 : 0;
    (*start_list)->locked= entry->locked_by_name ? 1 : 0;
    start_list= &(*start_list)->next;
193
    *start_list=0;
194 195
  }
  VOID(pthread_mutex_unlock(&LOCK_open));
196
  DBUG_RETURN(open_list);
197
}
unknown's avatar
unknown committed
198 199 200 201 202 203 204 205 206

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


void intern_close_table(TABLE *table)
{						// Free all structures
  free_io_cache(table);
207
  delete table->triggers;
unknown's avatar
unknown committed
208 209 210 211
  if (table->file)
    VOID(closefrm(table));			// close file
}

212 213 214 215 216 217 218 219 220 221
/*
  Remove table from the open table cache

  SYNOPSIS
    free_cache_entry()
    table		Table to remove

  NOTE
    We need to have a lock on LOCK_open when calling this
*/
unknown's avatar
unknown committed
222 223 224 225

static void free_cache_entry(TABLE *table)
{
  DBUG_ENTER("free_cache_entry");
226
  safe_mutex_assert_owner(&LOCK_open);
unknown's avatar
unknown committed
227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244

  intern_close_table(table);
  if (!table->in_use)
  {
    table->next->prev=table->prev;		/* remove from used chain */
    table->prev->next=table->next;
    if (table == unused_tables)
    {
      unused_tables=unused_tables->next;
      if (table == unused_tables)
	unused_tables=0;
    }
    check_unused();				// consisty check
  }
  my_free((gptr) table,MYF(0));
  DBUG_VOID_RETURN;
}

245
/* Free resources allocated by filesort() and read_record() */
unknown's avatar
unknown committed
246 247 248

void free_io_cache(TABLE *table)
{
249
  DBUG_ENTER("free_io_cache");
unknown's avatar
unknown committed
250
  if (table->sort.io_cache)
unknown's avatar
unknown committed
251
  {
unknown's avatar
unknown committed
252 253 254
    close_cached_file(table->sort.io_cache);
    my_free((gptr) table->sort.io_cache,MYF(0));
    table->sort.io_cache=0;
unknown's avatar
unknown committed
255
  }
256
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
257 258
}

259 260 261 262 263 264
/*
  Close all tables which aren't in use by any thread

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

unknown's avatar
unknown committed
266 267
bool close_cached_tables(THD *thd, bool if_wait_for_refresh,
			 TABLE_LIST *tables)
unknown's avatar
unknown committed
268 269 270
{
  bool result=0;
  DBUG_ENTER("close_cached_tables");
271
  DBUG_ASSERT(thd || (!if_wait_for_refresh && !tables));
unknown's avatar
unknown committed
272 273

  VOID(pthread_mutex_lock(&LOCK_open));
unknown's avatar
unknown committed
274
  if (!tables)
unknown's avatar
unknown committed
275
  {
unknown's avatar
unknown committed
276 277
    while (unused_tables)
    {
unknown's avatar
unknown committed
278
#ifdef EXTRA_DEBUG
unknown's avatar
unknown committed
279 280
      if (hash_delete(&open_cache,(byte*) unused_tables))
	printf("Warning: Couldn't delete open table from hash\n");
unknown's avatar
unknown committed
281
#else
unknown's avatar
unknown committed
282
      VOID(hash_delete(&open_cache,(byte*) unused_tables));
unknown's avatar
unknown committed
283
#endif
unknown's avatar
unknown committed
284 285
    }
    refresh_version++;				// Force close of open tables
unknown's avatar
unknown committed
286
  }
unknown's avatar
unknown committed
287
  else
unknown's avatar
unknown committed
288
  {
unknown's avatar
unknown committed
289
    bool found=0;
unknown's avatar
VIEW  
unknown committed
290
    for (TABLE_LIST *table= tables; table; table= table->next_local)
unknown's avatar
unknown committed
291
    {
292
      if (remove_table_from_cache(thd, table->db, table->table_name,
unknown's avatar
unknown committed
293
                                  RTFC_OWNED_BY_THD_FLAG))
unknown's avatar
unknown committed
294 295 296 297
	found=1;
    }
    if (!found)
      if_wait_for_refresh=0;			// Nothing to wait for
unknown's avatar
unknown committed
298
  }
unknown's avatar
unknown committed
299
#ifndef EMBEDDED_LIBRARY
300 301
  if (!tables)
    kill_delayed_threads();
unknown's avatar
unknown committed
302
#endif
unknown's avatar
unknown committed
303 304 305 306 307 308 309 310 311 312
  if (if_wait_for_refresh)
  {
    /*
      If there is any table that has a lower refresh_version, wait until
      this is closed (or this thread is killed) before returning
    */
    thd->mysys_var->current_mutex= &LOCK_open;
    thd->mysys_var->current_cond= &COND_refresh;
    thd->proc_info="Flushing tables";

unknown's avatar
unknown committed
313
    close_old_data_files(thd,thd->open_tables,1,1);
314 315
    mysql_ha_flush(thd, tables, MYSQL_HA_REOPEN_ON_USAGE | MYSQL_HA_FLUSH_ALL,
                   TRUE);
unknown's avatar
unknown committed
316 317
    bool found=1;
    /* Wait until all threads has closed all the tables we had locked */
318
    DBUG_PRINT("info",
unknown's avatar
unknown committed
319
	       ("Waiting for other threads to close their open tables"));
unknown's avatar
unknown committed
320 321 322 323 324 325
    while (found && ! thd->killed)
    {
      found=0;
      for (uint idx=0 ; idx < open_cache.records ; idx++)
      {
	TABLE *table=(TABLE*) hash_element(&open_cache,idx);
326
	if ((table->s->version) < refresh_version && table->db_stat)
unknown's avatar
unknown committed
327 328
	{
	  found=1;
unknown's avatar
unknown committed
329
          DBUG_PRINT("signal", ("Waiting for COND_refresh"));
unknown's avatar
unknown committed
330 331 332 333 334 335 336 337 338 339 340 341 342
	  pthread_cond_wait(&COND_refresh,&LOCK_open);
	  break;
	}
      }
    }
    /*
      No other thread has the locked tables open; reopen them and get the
      old locks. This should always succeed (unless some external process
      has removed the tables)
    */
    thd->in_lock_tables=1;
    result=reopen_tables(thd,1,1);
    thd->in_lock_tables=0;
343
    /* Set version for table */
unknown's avatar
VIEW  
unknown committed
344
    for (TABLE *table=thd->open_tables; table ; table= table->next)
345
      table->s->version= refresh_version;
unknown's avatar
unknown committed
346 347 348 349 350 351 352 353 354 355 356 357 358 359
  }
  VOID(pthread_mutex_unlock(&LOCK_open));
  if (if_wait_for_refresh)
  {
    pthread_mutex_lock(&thd->mysys_var->mutex);
    thd->mysys_var->current_mutex= 0;
    thd->mysys_var->current_cond= 0;
    thd->proc_info=0;
    pthread_mutex_unlock(&thd->mysys_var->mutex);
  }
  DBUG_RETURN(result);
}


360
/*
361 362 363 364 365 366 367 368 369 370 371
  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.
372 373 374 375 376 377 378 379 380

  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.
381 382 383 384 385 386 387 388 389 390 391 392 393
*/

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


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

395 396 397 398 399 400 401
  SYNOPSIS
    close_thread_tables()
    thd			Thread handler
    lock_in_use		Set to 1 (0 = default) if caller has a lock on
			LOCK_open
    skip_derived	Set to 1 (0 = default) if we should not free derived
			tables.
402 403
    stopper             When closing tables from thd->open_tables(->next)*, 
                        don't close/remove tables starting from stopper.
404 405 406 407

  IMPLEMENTATION
    Unlocks tables and frees derived tables.
    Put all normal tables used by thread in free list.
408 409 410 411 412

    When in prelocked mode it will only close/mark as free for reuse
    tables opened by this substatement, it will also check if we are
    closing tables after execution of complete query (i.e. we are on
    upper level) and will leave prelocked mode if needed.
413
*/
unknown's avatar
unknown committed
414

415
void close_thread_tables(THD *thd, bool lock_in_use, bool skip_derived)
unknown's avatar
unknown committed
416
{
417
  bool found_old_table;
418
  prelocked_mode_type prelocked_mode= thd->prelocked_mode;
unknown's avatar
unknown committed
419 420
  DBUG_ENTER("close_thread_tables");

421 422 423 424 425 426 427 428 429 430 431
  /*
    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.
  */
432 433 434 435
  if (thd->derived_tables && !skip_derived)
  {
    TABLE *table, *next;
    /*
436 437
      Close all derived tables generated in queries like
      SELECT * FROM (SELECT * FROM t1)
438 439 440 441 442 443 444 445
    */
    for (table= thd->derived_tables ; table ; table= next)
    {
      next= table->next;
      free_tmp_table(thd, table);
    }
    thd->derived_tables= 0;
  }
446 447

  if (prelocked_mode)
448
  {
449 450 451 452 453 454 455 456 457
    /*
      Mark all temporary tables used by this substatement as free for reuse.
    */
    mark_used_tables_as_free_for_reuse(thd, thd->temporary_tables);
  }

  if (thd->locked_tables || prelocked_mode)
  {
    /*
458 459 460 461 462 463
      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.
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485
    */
    ha_commit_stmt(thd);

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

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

    DBUG_ASSERT(prelocked_mode);
    /*
      We are in prelocked mode, so we have to leave it now with doing
      implicit UNLOCK TABLES if need.
    */
486
    DBUG_PRINT("info",("thd->prelocked_mode= NON_PRELOCKED"));
487 488 489 490 491 492 493 494
    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 */
495
  }
unknown's avatar
unknown committed
496 497 498

  if (thd->lock)
  {
499 500
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;
unknown's avatar
unknown committed
501
  }
502 503 504 505 506 507 508 509 510 511
  /*
    assume handlers auto-commit (if some doesn't - transaction handling
    in MySQL should be redesigned to support it; it's a big change,
    and it's not worth it - better to commit explicitly only writing
    transactions, read-only ones should better take care of themselves.
    saves some work in 2pc too)
    see also sql_parse.cc - dispatch_command()
  */
  bzero(&thd->transaction.stmt, sizeof(thd->transaction.stmt));
  if (!thd->active_transaction())
512
    thd->transaction.xid_state.xid.null();
513

unknown's avatar
unknown committed
514
  /* VOID(pthread_sigmask(SIG_SETMASK,&thd->block_signals,NULL)); */
515
  if (!lock_in_use)
unknown's avatar
unknown committed
516
    VOID(pthread_mutex_lock(&LOCK_open));
517
  safe_mutex_assert_owner(&LOCK_open);
unknown's avatar
unknown committed
518

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

521
 found_old_table= 0;
522
  while (thd->open_tables)
523
    found_old_table|=close_thread_table(thd, &thd->open_tables);
524
  thd->some_tables_deleted=0;
525

unknown's avatar
unknown committed
526
  /* Free tables to hold down open files */
527
  while (open_cache.records > table_cache_size && unused_tables)
unknown's avatar
unknown committed
528 529 530 531 532
    VOID(hash_delete(&open_cache,(byte*) unused_tables)); /* purecov: tested */
  check_unused();
  if (found_old_table)
  {
    /* Tell threads waiting for refresh that something has happened */
533
    broadcast_refresh();
unknown's avatar
unknown committed
534
  }
535
  if (!lock_in_use)
unknown's avatar
unknown committed
536 537
    VOID(pthread_mutex_unlock(&LOCK_open));
  /*  VOID(pthread_sigmask(SIG_SETMASK,&thd->signals,NULL)); */
538 539 540 541 542 543 544 545 546 547 548

  if (prelocked_mode == PRELOCKED)
  {
    /*
      If we are here then we are leaving normal prelocked mode, so it is
      good idea to turn off OPTION_TABLE_LOCK flag.
    */
    DBUG_ASSERT(thd->lex->requires_prelocking());
    thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
  }

unknown's avatar
unknown committed
549 550 551
  DBUG_VOID_RETURN;
}

552 553 554 555
/* move one table to free list */

bool close_thread_table(THD *thd, TABLE **table_ptr)
{
556 557
  bool found_old_table= 0;
  TABLE *table= *table_ptr;
558
  DBUG_ENTER("close_thread_table");
559
  DBUG_ASSERT(table->key_read == 0);
unknown's avatar
unknown committed
560
  DBUG_ASSERT(table->file->inited == handler::NONE);
561 562

  *table_ptr=table->next;
563
  if (table->s->version != refresh_version ||
564 565 566 567 568 569 570
      thd->version != refresh_version || !table->db_stat)
  {
    VOID(hash_delete(&open_cache,(byte*) table));
    found_old_table=1;
  }
  else
  {
571
    if (table->s->flush_version != flush_version)
572
    {
573
      table->s->flush_version= flush_version;
574 575 576 577 578
      table->file->extra(HA_EXTRA_FLUSH);
    }
    else
    {
      // Free memory and reset for next loop
unknown's avatar
unknown committed
579
      table->file->reset();
580 581 582 583 584 585 586 587 588 589 590 591 592 593 594
    }
    table->in_use=0;
    if (unused_tables)
    {
      table->next=unused_tables;		/* Link in last */
      table->prev=unused_tables->prev;
      unused_tables->prev=table;
      table->prev->next=table;
    }
    else
      unused_tables=table->next=table->prev=table;
  }
  DBUG_RETURN(found_old_table);
}

unknown's avatar
unknown committed
595 596 597 598 599 600
	/* Close and delete temporary tables */

void close_temporary(TABLE *table,bool delete_table)
{
  DBUG_ENTER("close_temporary");
  char path[FN_REFLEN];
601 602
  db_type table_type=table->s->db_type;
  strmov(path,table->s->path);
unknown's avatar
unknown committed
603 604 605 606 607 608 609 610
  free_io_cache(table);
  closefrm(table);
  my_free((char*) table,MYF(0));
  if (delete_table)
    rm_temporary_table(table_type, path);
  DBUG_VOID_RETURN;
}

611 612 613 614 615 616 617
/* 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 + table->s->key_length - 4);
}

/* Creates one DROP TEMPORARY TABLE binlog event for each pseudo-thread */
unknown's avatar
unknown committed
618 619 620

void close_temporary_tables(THD *thd)
{
621
  TABLE *table;
622 623
  if (!thd->temporary_tables)
    return;
624

625 626 627 628 629 630 631 632 633
  if (!mysql_bin_log.is_open())
  {
    for (table= thd->temporary_tables; table; table= table->next)
    {
      close_temporary(table, 1);
    }
    thd->temporary_tables= 0;
    return;
  }
634

635 636 637 638 639 640 641 642 643 644 645
  TABLE *next,
    *prev_table /* prev link is not maintained in TABLE's double-linked list */;
  bool was_quote_show= true; /* to assume thd->options has OPTION_QUOTE_SHOW_CREATE */
  // Better add "if exists", in case a RESET MASTER has been done
  const char stub[]= "DROP /*!40005 TEMPORARY */ TABLE IF EXISTS ";
  uint stub_len= sizeof(stub) - 1;
  char buf[256];
  memcpy(buf, stub, stub_len);
  String s_query= String(buf, sizeof(buf), system_charset_info);
  bool found_user_tables= false;
  LINT_INIT(next);
646 647 648

  /*
     insertion sort of temp tables by pseudo_thread_id to build ordered list
649 650
     of sublists of equal pseudo_thread_id
  */
651

652
  for (prev_table= thd->temporary_tables, table= prev_table->next;
653 654 655
       table;
       prev_table= table, table= table->next)
  {
656 657
    TABLE *prev_sorted /* same as for prev_table */, *sorted;
    if (is_user_table(table))
658
    {
659 660
      if (!found_user_tables)
        found_user_tables= true;
661
      for (prev_sorted= NULL, sorted= thd->temporary_tables; sorted != table;
662
           prev_sorted= sorted, sorted= sorted->next)
663
      {
664 665
        if (!is_user_table(sorted) ||
            tmpkeyval(thd, sorted) > tmpkeyval(thd, table))
666
        {
667 668 669
          /* move into the sorted part of the list from the unsorted */
          prev_table->next= table->next;
          table->next= sorted;
670
          if (prev_sorted)
671 672 673 674 675 676 677 678 679
          {
            prev_sorted->next= table;
          }
          else
          {
            thd->temporary_tables= table;
          }
          table= prev_table;
          break;
680 681 682
        }
      }
    }
683 684 685 686 687
  }

  /* We always quote db,table names though it is slight overkill */
  if (found_user_tables &&
      !(was_quote_show= (thd->options & OPTION_QUOTE_SHOW_CREATE)))
unknown's avatar
unknown committed
688
  {
689
    thd->options |= OPTION_QUOTE_SHOW_CREATE;
unknown's avatar
unknown committed
690
  }
691 692

  /* scan sorted tmps to generate sequence of DROP */
693
  for (table= thd->temporary_tables; table; table= next)
unknown's avatar
unknown committed
694
  {
695
    if (is_user_table(table))
696 697 698 699 700
    {
      /* Set pseudo_thread_id to be that of the processed table */
      thd->variables.pseudo_thread_id= tmpkeyval(thd, table);
      /* Loop forward through all tables within the sublist of
         common pseudo_thread_id to create single DROP query */
701 702
      for (s_query.length(stub_len);
           table && is_user_table(table) &&
703 704 705
             tmpkeyval(thd, table) == thd->variables.pseudo_thread_id;
           table= next)
      {
706 707 708 709
        /*
          We are going to add 4 ` around the db/table names and possible more
          due to special characters in the names
        */
710
        append_identifier(thd, &s_query, table->s->db, strlen(table->s->db));
711
        s_query.q_append('.');
712 713
        append_identifier(thd, &s_query, table->s->table_name,
                          strlen(table->s->table_name));
714
        s_query.q_append(',');
715 716 717 718
        next= table->next;
        close_temporary(table, 1);
      }
      thd->clear_error();
719 720
      CHARSET_INFO *cs_save= thd->variables.character_set_client;
      thd->variables.character_set_client= system_charset_info;
721 722 723
      Query_log_event qinfo(thd, s_query.ptr(),
                            s_query.length() - 1 /* to remove trailing ',' */,
                            0, FALSE);
724
      thd->variables.character_set_client= cs_save;
725 726 727 728 729 730 731 732 733 734 735 736
      /*
        Imagine the thread had created a temp table, then was doing a SELECT, and
        the SELECT was killed. Then it's not clever to mark the statement above as
        "killed", because it's not really a statement updating data, and there
        are 99.99% chances it will succeed on slave.
        If a real update (one updating a persistent table) was killed on the
        master, then this real update will be logged with error_code=killed,
        rightfully causing the slave to stop.
      */
      qinfo.error_code= 0;
      mysql_bin_log.write(&qinfo);
    }
737
    else
738 739 740 741
    {
      next= table->next;
      close_temporary(table, 1);
    }
unknown's avatar
unknown committed
742
  }
743 744
  if (!was_quote_show)
    thd->options &= ~OPTION_QUOTE_SHOW_CREATE; /* restore option */
unknown's avatar
unknown committed
745 746 747 748
  thd->temporary_tables=0;
}


749
/*
750
  Find table in list.
751 752

  SYNOPSIS
753
    find_table_in_list()
754
    table		Pointer to table list
755
    offset		Offset to which list in table structure to use
756 757
    db_name		Data base name
    table_name		Table name
unknown's avatar
VIEW  
unknown committed
758

759 760 761
  NOTES:
    This is called by find_table_in_local_list() and
    find_table_in_global_list().
unknown's avatar
VIEW  
unknown committed
762 763 764 765 766 767

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

768
TABLE_LIST *find_table_in_list(TABLE_LIST *table,
769
                               st_table_list *TABLE_LIST::*link,
770 771
                               const char *db_name,
                               const char *table_name)
unknown's avatar
VIEW  
unknown committed
772
{
773
  for (; table; table= table->*link )
774
  {
775 776 777 778
    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;
779
  }
unknown's avatar
VIEW  
unknown committed
780 781 782 783
  return table;
}


784
/*
785
  Test that table is unique (It's only exists once in the table list)
786 787 788

  SYNOPSIS
    unique_table()
789
    thd                   thread handle
790
    table                 table which should be checked
791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808
    table_list            list of tables

  NOTE: to exclude derived tables from check we use following mechanism:
    a) during derived table processing set THD::derived_tables_processing
    b) JOIN::prepare set SELECT::exclude_from_table_unique_test if
       THD::derived_tables_processing set. (we can't use JOIN::execute
       because for PS we perform only JOIN::prepare, but we can't set this
       flag in JOIN::prepare if we are not sure that we are in derived table
       processing loop, because multi-update call fix_fields() for some its
       items (which mean JOIN::prepare for subqueries) before unique_table
       call to detect which tables should be locked for write).
    c) unique_table skip all tables which belong to SELECT with
       SELECT::exclude_from_table_unique_test set.
    Also SELECT::exclude_from_table_unique_test used to exclude from check
    tables of main SELECT of multi-delete and multi-update

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

  RETURN
unknown's avatar
unknown committed
811 812
    found duplicate
    0 if table is unique
813 814
*/

815
TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list)
816
{
unknown's avatar
unknown committed
817
  TABLE_LIST *res;
818
  const char *d_name, *t_name;
unknown's avatar
unknown committed
819 820
  DBUG_ENTER("unique_table");
  DBUG_PRINT("enter", ("table alias: %s", table->alias));
821 822 823 824 825 826 827 828 829 830 831 832

  /*
    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)
833
  {
834 835 836 837 838 839 840 841 842
    /* 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);
843
  }
844 845
  d_name= table->db;
  t_name= table->table_name;
846 847

  DBUG_PRINT("info", ("real table: %s.%s", d_name, t_name));
unknown's avatar
unknown committed
848
  for (;;)
unknown's avatar
unknown committed
849
  {
850 851 852 853
    if (((! (res= find_table_in_global_list(table_list, d_name, t_name))) &&
         (! (res= mysql_lock_have_duplicate(thd, table, table_list)))) ||
        ((!res->table || res->table != table->table) &&
         res->select_lex && !res->select_lex->exclude_from_table_unique_test))
854
      break;
855 856 857 858 859
    /*
      If we found entry of this table or or table of SELECT which already
      processed in derived table or top select of multi-update/multi-delete
      (exclude_from_table_unique_test).
    */
860
    table_list= res->next_global;
861 862
    DBUG_PRINT("info",
               ("found same copy of table or table which we should skip"));
unknown's avatar
unknown committed
863
  }
864
  DBUG_RETURN(res);
865 866 867
}


868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 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
/*
  Issue correct error message in case we found 2 duplicate tables which
  prevent some update operation

  SYNOPSIS
    update_non_unique_table_error()
    update      table which we try to update
    operation   name of update operation
    duplicate   duplicate table which we found

  NOTE:
    here we hide view underlying tables if we have them
*/

void update_non_unique_table_error(TABLE_LIST *update,
                                   const char *operation,
                                   TABLE_LIST *duplicate)
{
  update= update->top_table();
  duplicate= duplicate->top_table();
  if (!update->view || !duplicate->view ||
      update->view == duplicate->view ||
      update->view_name.length != duplicate->view_name.length ||
      update->view_db.length != duplicate->view_db.length ||
      my_strcasecmp(table_alias_charset,
                    update->view_name.str, duplicate->view_name.str) != 0 ||
      my_strcasecmp(table_alias_charset,
                    update->view_db.str, duplicate->view_db.str) != 0)
  {
    /*
      it is not the same view repeated (but it can be parts of the same copy
      of view), so we have to hide underlying tables.
    */
    if (update->view)
    {
      if (update->view == duplicate->view)
        my_error(ER_NON_UPDATABLE_TABLE, MYF(0), update->alias, operation);
      else
        my_error(ER_VIEW_PREVENT_UPDATE, MYF(0),
                 (duplicate->view ? duplicate->alias : update->alias),
                 operation, update->alias);
      return;
    }
    if (duplicate->view)
    {
      my_error(ER_VIEW_PREVENT_UPDATE, MYF(0), duplicate->alias, operation,
               update->alias);
      return;
    }
  }
  my_error(ER_UPDATE_TABLE_USED, MYF(0), update->alias);
}


unknown's avatar
unknown committed
922 923 924 925 926 927
TABLE **find_temporary_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;
  TABLE *table,**prev;

unknown's avatar
unknown committed
928 929
  int4store(key+key_length,thd->server_id);
  key_length += 4;
unknown's avatar
unknown committed
930
  int4store(key+key_length,thd->variables.pseudo_thread_id);
931
  key_length += 4;
932

unknown's avatar
unknown committed
933 934 935
  prev= &thd->temporary_tables;
  for (table=thd->temporary_tables ; table ; table=table->next)
  {
936 937
    if (table->s->key_length == key_length &&
	!memcmp(table->s->table_cache_key,key,key_length))
unknown's avatar
unknown committed
938 939 940 941 942 943 944 945 946 947 948 949 950 951
      return prev;
    prev= &table->next;
  }
  return 0;					// Not a temporary table
}

bool close_temporary_table(THD *thd, const char *db, const char *table_name)
{
  TABLE *table,**prev;

  if (!(prev=find_temporary_table(thd,db,table_name)))
    return 1;
  table= *prev;
  *prev= table->next;
unknown's avatar
unknown committed
952
  close_temporary(table, 1);
953
  if (thd->slave_thread)
954
    --slave_open_temp_tables;
unknown's avatar
unknown committed
955 956 957
  return 0;
}

unknown's avatar
unknown committed
958 959 960 961 962 963 964
/*
  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'.
*/
965

966
bool rename_temporary_table(THD* thd, TABLE *table, const char *db,
unknown's avatar
unknown committed
967 968 969
			    const char *table_name)
{
  char *key;
970 971
  TABLE_SHARE *share= table->s;

unknown's avatar
unknown committed
972
  if (!(key=(char*) alloc_root(&table->mem_root,
unknown's avatar
unknown committed
973
			       (uint) strlen(db)+
unknown's avatar
unknown committed
974
			       (uint) strlen(table_name)+6+4)))
unknown's avatar
unknown committed
975
    return 1;				/* purecov: inspected */
976
  share->key_length= (uint)
unknown's avatar
unknown committed
977 978
    (strmov((char*) (share->table_name= strmov(share->table_cache_key= key,
                                               db)+1),
979 980 981 982 983 984
	    table_name) - share->table_cache_key)+1;
  share->db= share->table_cache_key;
  int4store(key+share->key_length, thd->server_id);
  share->key_length+= 4;
  int4store(key+share->key_length, thd->variables.pseudo_thread_id);
  share->key_length+= 4;
unknown's avatar
unknown committed
985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014
  return 0;
}


	/* move table first in unused links */

static void relink_unused(TABLE *table)
{
  if (table != unused_tables)
  {
    table->prev->next=table->next;		/* Remove from unused list */
    table->next->prev=table->prev;
    table->next=unused_tables;			/* Link in unused tables */
    table->prev=unused_tables->prev;
    unused_tables->prev->next=table;
    unused_tables->prev=table;
    unused_tables=table;
    check_unused();
  }
}


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

TABLE *unlink_open_table(THD *thd, TABLE *list, TABLE *find)
{
  char key[MAX_DBKEY_LENGTH];
1015
  uint key_length= find->s->key_length;
unknown's avatar
unknown committed
1016 1017
  TABLE *start=list,**prev,*next;
  prev= &start;
1018 1019

  memcpy(key, find->s->table_cache_key, key_length);
unknown's avatar
unknown committed
1020 1021 1022
  for (; list ; list=next)
  {
    next=list->next;
1023 1024
    if (list->s->key_length == key_length &&
	!memcmp(list->s->table_cache_key, key, key_length))
unknown's avatar
unknown committed
1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
    {
      if (thd->locked_tables)
	mysql_lock_remove(thd, thd->locked_tables,list);
      VOID(hash_delete(&open_cache,(byte*) list)); // Close table
    }
    else
    {
      *prev=list;				// put in use list
      prev= &list->next;
    }
  }
  *prev=0;
  // Notify any 'refresh' threads
1038
  broadcast_refresh();
unknown's avatar
unknown committed
1039 1040 1041 1042
  return start;
}


1043
/*
unknown's avatar
unknown committed
1044
   When we call the following function we must have a lock on
1045
   LOCK_open ; This lock will be unlocked on return.
unknown's avatar
unknown committed
1046 1047 1048 1049
*/

void wait_for_refresh(THD *thd)
{
unknown's avatar
unknown committed
1050
  DBUG_ENTER("wait_for_refresh");
1051 1052
  safe_mutex_assert_owner(&LOCK_open);

unknown's avatar
unknown committed
1053 1054 1055 1056 1057 1058
  /* Wait until the current table is up to date */
  const char *proc_info;
  thd->mysys_var->current_mutex= &LOCK_open;
  thd->mysys_var->current_cond= &COND_refresh;
  proc_info=thd->proc_info;
  thd->proc_info="Waiting for table";
unknown's avatar
unknown committed
1059 1060
  if (!thd->killed)
    (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
unknown's avatar
unknown committed
1061 1062 1063 1064 1065 1066 1067

  pthread_mutex_unlock(&LOCK_open);	// Must be unlocked first
  pthread_mutex_lock(&thd->mysys_var->mutex);
  thd->mysys_var->current_mutex= 0;
  thd->mysys_var->current_cond= 0;
  thd->proc_info= proc_info;
  pthread_mutex_unlock(&thd->mysys_var->mutex);
unknown's avatar
unknown committed
1068
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1069 1070
}

1071

1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090
/*
  Open table which is already name-locked by this thread.

  SYNOPSIS
    reopen_name_locked_table()
      thd         Thread handle
      table_list  TABLE_LIST object for table to be open, TABLE_LIST::table
                  member should point to TABLE object which was used for
                  name-locking.

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

  RETURN VALUE
    FALSE - Success
    TRUE  - Error
*/

bool reopen_name_locked_table(THD* thd, TABLE_LIST* table_list)
1091
{
1092
  TABLE *table= table_list->table;
1093
  TABLE_SHARE *share;
1094 1095 1096 1097 1098 1099
  char *db= table_list->db;
  char *table_name= table_list->table_name;
  char key[MAX_DBKEY_LENGTH];
  uint key_length;
  TABLE orig_table;
  DBUG_ENTER("reopen_name_locked_table");
1100

1101 1102 1103 1104 1105 1106
  safe_mutex_assert_owner(&LOCK_open);

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

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

1109
  if (open_unireg_entry(thd, table, db, table_name, table_name, 0,
unknown's avatar
unknown committed
1110
                        thd->mem_root) ||
1111 1112
      !(table->s->table_cache_key= memdup_root(&table->mem_root, (char*) key,
                                               key_length)))
unknown's avatar
unknown committed
1113
  {
1114 1115 1116 1117 1118 1119 1120 1121 1122
    intern_close_table(table);
    /*
      If there was an error during opening of table (for example if it
      does not exist) '*table' object can be wiped out. To be able
      properly release name-lock in this case we should restore this
      object to its original state.
    */
    *table= orig_table;
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
1123
  }
1124

1125 1126 1127 1128 1129
  share= table->s;
  share->db= share->table_cache_key;
  share->key_length=key_length;
  share->version=0;
  share->flush_version=0;
1130 1131
  table->in_use = thd;
  check_unused();
unknown's avatar
unknown committed
1132 1133
  table->next = thd->open_tables;
  thd->open_tables = table;
1134 1135 1136
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
1137
  table->null_row= table->maybe_null= table->force_index= 0;
1138
  table->status=STATUS_NO_RECORD;
1139 1140
  table->keys_in_use_for_query= share->keys_in_use;
  table->used_keys= share->keys_for_keyread;
1141
  DBUG_RETURN(FALSE);
1142 1143
}

unknown's avatar
unknown committed
1144

1145 1146 1147 1148 1149
/*
  Open a table.

  SYNOPSIS
    open_table()
1150 1151 1152 1153 1154 1155 1156 1157 1158 1159
    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.
1160 1161
                          MYSQL_OPEN_IGNORE_LOCKED_TABLES - Open table
                          ignoring set of locked tables and prelocked mode.
1162 1163 1164 1165 1166 1167

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

  RETURN
    NULL  Open failed.  If refresh is set then one should close
1168
          all other tables and retry the open.
1169 1170
    #     Success. Pointer to TABLE object for open table.
*/
unknown's avatar
unknown committed
1171 1172


unknown's avatar
VIEW  
unknown committed
1173
TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
1174
		  bool *refresh, uint flags)
unknown's avatar
unknown committed
1175 1176 1177 1178
{
  reg1	TABLE *table;
  char	key[MAX_DBKEY_LENGTH];
  uint	key_length;
unknown's avatar
VIEW  
unknown committed
1179
  char	*alias= table_list->alias;
1180
  HASH_SEARCH_STATE state;
unknown's avatar
unknown committed
1181 1182 1183 1184 1185
  DBUG_ENTER("open_table");

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

  /* an open table operation needs a lot of the stack space */
1188
  if (check_stack_overrun(thd, STACK_MIN_SIZE_FOR_OPEN, (char *)&alias))
1189
    DBUG_RETURN(0);
1190

unknown's avatar
unknown committed
1191 1192
  if (thd->killed)
    DBUG_RETURN(0);
unknown's avatar
VIEW  
unknown committed
1193
  key_length= (uint) (strmov(strmov(key, table_list->db)+1,
1194
			     table_list->table_name)-key)+1;
unknown's avatar
unknown committed
1195
  int4store(key + key_length, thd->server_id);
unknown's avatar
unknown committed
1196
  int4store(key + key_length + 4, thd->variables.pseudo_thread_id);
1197

unknown's avatar
VIEW  
unknown committed
1198
  if (!table_list->skip_temporary)
unknown's avatar
unknown committed
1199
  {
unknown's avatar
VIEW  
unknown committed
1200
    for (table= thd->temporary_tables; table ; table=table->next)
unknown's avatar
unknown committed
1201
    {
1202 1203
      if (table->s->key_length == key_length + TMP_TABLE_KEY_EXTRA &&
	  !memcmp(table->s->table_cache_key, key,
unknown's avatar
unknown committed
1204
		  key_length + TMP_TABLE_KEY_EXTRA))
unknown's avatar
unknown committed
1205
      {
1206 1207
	if (table->query_id == thd->query_id ||
            thd->prelocked_mode && table->query_id)
unknown's avatar
VIEW  
unknown committed
1208
	{
1209
	  my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
unknown's avatar
VIEW  
unknown committed
1210 1211 1212 1213 1214
	  DBUG_RETURN(0);
	}
	table->query_id= thd->query_id;
	table->clear_query_id= 1;
	thd->tmp_table_used= 1;
unknown's avatar
unknown committed
1215 1216
        DBUG_PRINT("info",("Using temporary table"));
        goto reset;
unknown's avatar
unknown committed
1217 1218 1219 1220
      }
    }
  }

1221 1222
  if (!(flags & MYSQL_OPEN_IGNORE_LOCKED_TABLES) &&
      (thd->locked_tables || thd->prelocked_mode))
unknown's avatar
unknown committed
1223
  {						// Using table locks
1224
    TABLE *best_table= 0;
unknown's avatar
unknown committed
1225
    int best_distance= INT_MIN;
1226 1227 1228
    bool check_if_used= thd->prelocked_mode &&
                        ((int) table_list->lock_type >=
                         (int) TL_WRITE_ALLOW_WRITE);
unknown's avatar
unknown committed
1229 1230
    for (table=thd->open_tables; table ; table=table->next)
    {
1231
      if (table->s->key_length == key_length &&
1232
          !memcmp(table->s->table_cache_key, key, key_length))
unknown's avatar
unknown committed
1233
      {
1234 1235
        if (check_if_used && table->query_id &&
            table->query_id != thd->query_id)
1236
        {
1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280
          /*
            If we are in stored function or trigger we should ensure that
            we won't change table that is already used by calling statement.
            So if we are opening table for writing, we should check that it
            is not already open by some calling stamement.
          */
          my_error(ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG, MYF(0),
                   table->s->table_name);
          DBUG_RETURN(0);
        }
        if (!my_strcasecmp(system_charset_info, table->alias, alias) &&
            table->query_id != thd->query_id && /* skip tables already used */
            !(thd->prelocked_mode && table->query_id))
        {
          int distance= ((int) table->reginfo.lock_type -
                         (int) table_list->lock_type);
          /*
            Find a table that either has the exact lock type requested,
            or has the best suitable lock. In case there is no locked
            table that has an equal or higher lock than requested,
            we us the closest matching lock to be able to produce an error
            message about wrong lock mode on the table. The best_table
            is changed if bd < 0 <= d or bd < d < 0 or 0 <= d < bd.

            distance <  0 - No suitable lock found
            distance >  0 - we have lock mode higher then we require
            distance == 0 - we have lock mode exactly which we need
          */
          if (best_distance < 0 && distance > best_distance ||
              distance >= 0 && distance < best_distance)
          {
            best_distance= distance;
            best_table= table;
            if (best_distance == 0 && !check_if_used)
            {
              /*
                If we have found perfect match and we don't need to check that
                table is not used by one of calling statements (assuming that
                we are inside of function or trigger) we can finish iterating
                through open tables list.
              */
              break;
            }
          }
1281
        }
unknown's avatar
unknown committed
1282
      }
unknown's avatar
unknown committed
1283
    }
1284 1285 1286 1287 1288 1289 1290
    if (best_table)
    {
      table= best_table;
      table->query_id= thd->query_id;
      DBUG_PRINT("info",("Using locked table"));
      goto reset;
    }
unknown's avatar
unknown committed
1291 1292 1293 1294 1295 1296 1297
    /*
      is it view?
      (it is work around to allow to open view with locked tables,
      real fix will be made after definition cache will be made)
    */
    {
      char path[FN_REFLEN];
1298
      db_type not_used;
unknown's avatar
unknown committed
1299
      strxnmov(path, FN_REFLEN, mysql_data_home, "/", table_list->db, "/",
1300
               table_list->table_name, reg_ext, NullS);
unknown's avatar
unknown committed
1301
      (void) unpack_filename(path, path);
1302
      if (mysql_frm_type(thd, path, &not_used) == FRMTYPE_VIEW)
unknown's avatar
unknown committed
1303
      {
1304 1305 1306 1307 1308
        /*
          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;
1309
        table= &tab;
unknown's avatar
unknown committed
1310
        VOID(pthread_mutex_lock(&LOCK_open));
1311 1312 1313
        if (!open_unireg_entry(thd, table, table_list->db,
                               table_list->table_name,
                               alias, table_list, mem_root))
unknown's avatar
unknown committed
1314
        {
1315
          DBUG_ASSERT(table_list->view != 0);
unknown's avatar
unknown committed
1316 1317 1318 1319 1320 1321
          VOID(pthread_mutex_unlock(&LOCK_open));
          DBUG_RETURN(0); // VIEW
        }
        VOID(pthread_mutex_unlock(&LOCK_open));
      }
    }
1322
    my_error(ER_TABLE_NOT_LOCKED, MYF(0), alias);
unknown's avatar
unknown committed
1323 1324
    DBUG_RETURN(0);
  }
unknown's avatar
unknown committed
1325

unknown's avatar
unknown committed
1326 1327 1328 1329
  VOID(pthread_mutex_lock(&LOCK_open));

  if (!thd->open_tables)
    thd->version=refresh_version;
1330 1331
  else if ((thd->version != refresh_version) &&
           ! (flags & MYSQL_LOCK_IGNORE_FLUSH))
unknown's avatar
unknown committed
1332 1333
  {
    /* Someone did a refresh while thread was opening tables */
1334 1335
    if (refresh)
      *refresh=1;
unknown's avatar
unknown committed
1336 1337 1338 1339
    VOID(pthread_mutex_unlock(&LOCK_open));
    DBUG_RETURN(0);
  }

1340
  /* close handler tables which are marked for flush */
unknown's avatar
unknown committed
1341
  if (thd->handler_tables)
1342
    mysql_ha_flush(thd, (TABLE_LIST*) NULL, MYSQL_HA_REOPEN_ON_USAGE, TRUE);
1343

1344 1345
  for (table= (TABLE*) hash_first(&open_cache, (byte*) key, key_length,
                                  &state);
unknown's avatar
unknown committed
1346
       table && table->in_use ;
1347 1348
       table= (TABLE*) hash_next(&open_cache, (byte*) key, key_length,
                                 &state))
unknown's avatar
unknown committed
1349
  {
1350
    if (table->s->version != refresh_version)
unknown's avatar
unknown committed
1351
    {
unknown's avatar
unknown committed
1352 1353 1354
      DBUG_PRINT("note",
                 ("Found table '%s.%s' with different refresh version",
                  table_list->db, table_list->table_name));
1355 1356 1357 1358 1359 1360 1361
      if (flags & MYSQL_LOCK_IGNORE_FLUSH)
      {
        /* Force close at once after usage */
        thd->version= table->s->version;
        continue;
      }

unknown's avatar
unknown committed
1362
      /*
1363 1364
        There is a refresh in progress for this table
        Wait until the table is freed or the thread is killed.
unknown's avatar
unknown committed
1365
      */
unknown's avatar
unknown committed
1366
      close_old_data_files(thd,thd->open_tables,0,0);
unknown's avatar
unknown committed
1367 1368 1369
      if (table->in_use != thd)
	wait_for_refresh(thd);
      else
unknown's avatar
VIEW  
unknown committed
1370
      {
unknown's avatar
unknown committed
1371
	VOID(pthread_mutex_unlock(&LOCK_open));
unknown's avatar
VIEW  
unknown committed
1372
      }
unknown's avatar
unknown committed
1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387
      if (refresh)
	*refresh=1;
      DBUG_RETURN(0);
    }
  }
  if (table)
  {
    if (table == unused_tables)
    {						// First unused
      unused_tables=unused_tables->next;	// Remove from link
      if (table == unused_tables)
	unused_tables=0;
    }
    table->prev->next=table->next;		/* Remove from unused list */
    table->next->prev=table->prev;
1388
    table->in_use= thd;
unknown's avatar
unknown committed
1389 1390 1391
  }
  else
  {
1392
    TABLE_SHARE *share;
unknown's avatar
unknown committed
1393
    /* Free cache if too big */
1394
    while (open_cache.records > table_cache_size && unused_tables)
unknown's avatar
unknown committed
1395 1396 1397 1398
      VOID(hash_delete(&open_cache,(byte*) unused_tables)); /* purecov: tested */

    /* make a new table */
    if (!(table=(TABLE*) my_malloc(sizeof(*table),MYF(MY_WME))))
1399 1400
    {
      VOID(pthread_mutex_unlock(&LOCK_open));
unknown's avatar
unknown committed
1401
      DBUG_RETURN(NULL);
1402
    }
1403
    if (open_unireg_entry(thd, table, table_list->db, table_list->table_name,
unknown's avatar
VIEW  
unknown committed
1404 1405
			  alias, table_list, mem_root) ||
	(!table_list->view && 
1406 1407 1408
	 !(table->s->table_cache_key= memdup_root(&table->mem_root,
                                                  (char*) key,
                                                  key_length))))
unknown's avatar
unknown committed
1409 1410 1411 1412 1413 1414
    {
      table->next=table->prev=table;
      free_cache_entry(table);
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(NULL);
    }
unknown's avatar
VIEW  
unknown committed
1415 1416 1417 1418 1419 1420
    if (table_list->view)
    {
      my_free((gptr)table, MYF(0));
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(0); // VIEW
    }
1421 1422 1423 1424 1425
    share= table->s;
    share->db=            share->table_cache_key;
    share->key_length=    key_length;
    share->version=       refresh_version;
    share->flush_version= flush_version;
unknown's avatar
unknown committed
1426
    DBUG_PRINT("info", ("inserting table %p into the cache", table));
unknown's avatar
SCRUM  
unknown committed
1427
    VOID(my_hash_insert(&open_cache,(byte*) table));
unknown's avatar
unknown committed
1428 1429
  }

1430
  check_unused();				// Debugging call
unknown's avatar
VIEW  
unknown committed
1431

unknown's avatar
unknown committed
1432 1433 1434 1435 1436 1437 1438 1439 1440
  VOID(pthread_mutex_unlock(&LOCK_open));
  if (refresh)
  {
    table->next=thd->open_tables;		/* Link into simple list */
    thd->open_tables=table;
  }
  table->reginfo.lock_type=TL_READ;		/* Assume read */

 reset:
unknown's avatar
unknown committed
1441 1442
  if (thd->lex->need_correct_ident())
    table->alias_name_used= my_strcasecmp(table_alias_charset,
1443
                                          table->s->table_name, alias);
unknown's avatar
unknown committed
1444
  /* Fix alias if table name changes */
1445
  if (strcmp(table->alias, alias))
unknown's avatar
unknown committed
1446
  {
unknown's avatar
unknown committed
1447
    uint length=(uint) strlen(alias)+1;
1448 1449 1450
    table->alias= (char*) my_realloc((char*) table->alias, length,
                                     MYF(MY_WME));
    memcpy((char*) table->alias, alias, length);
unknown's avatar
unknown committed
1451 1452 1453 1454 1455
  }
  /* These variables are also set in reopen_table() */
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
1456
  table->null_row= table->maybe_null= table->force_index= 0;
unknown's avatar
unknown committed
1457
  table->status=STATUS_NO_RECORD;
1458
  table->keys_in_use_for_query= table->s->keys_in_use;
1459
  table->insert_values= 0;
1460
  table->used_keys= table->s->keys_for_keyread;
unknown's avatar
unknown committed
1461 1462
  table->fulltext_searched= 0;
  table->file->ft_handler= 0;
unknown's avatar
unknown committed
1463
  if (table->timestamp_field)
1464
    table->timestamp_field_type= table->timestamp_field->get_auto_set_type();
unknown's avatar
VIEW  
unknown committed
1465
  table_list->updatable= 1; // It is not derived table nor non-updatable VIEW
unknown's avatar
unknown committed
1466
  DBUG_ASSERT(table->key_read == 0);
unknown's avatar
unknown committed
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477
  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)
  {
1478 1479
    if (table->s->key_length == key_length &&
	!memcmp(table->s->table_cache_key,key,key_length))
unknown's avatar
unknown committed
1480 1481 1482 1483 1484 1485 1486
      return table;
  }
  return(0);
}


/****************************************************************************
1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500
  Reopen an table because the definition has changed. The date file for the
  table is already closed.

  SYNOPSIS
    reopen_table()
    table		Table to be opened
    locked		1 if we have already a lock on LOCK_open

  NOTES
    table->query_id will be 0 if table was reopened

  RETURN
    0  ok
    1  error ('table' is unchanged if table couldn't be reopened)
unknown's avatar
unknown committed
1501 1502 1503 1504 1505
****************************************************************************/

bool reopen_table(TABLE *table,bool locked)
{
  TABLE tmp;
1506 1507 1508
  char *db= table->s->table_cache_key;
  const char *table_name= table->s->table_name;
  bool error= 1;
unknown's avatar
unknown committed
1509 1510 1511 1512 1513 1514 1515
  Field **field;
  uint key,part;
  DBUG_ENTER("reopen_table");

#ifdef EXTRA_DEBUG
  if (table->db_stat)
    sql_print_error("Table %s had a open data handler in reopen_table",
1516
		    table->alias);
unknown's avatar
unknown committed
1517 1518 1519
#endif
  if (!locked)
    VOID(pthread_mutex_lock(&LOCK_open));
1520
  safe_mutex_assert_owner(&LOCK_open);
unknown's avatar
unknown committed
1521

1522
  if (open_unireg_entry(table->in_use, &tmp, db, table_name,
1523
			table->alias, 0, table->in_use->mem_root))
unknown's avatar
unknown committed
1524 1525 1526
    goto end;
  free_io_cache(table);

1527 1528
  if (!(tmp.s->table_cache_key= memdup_root(&tmp.mem_root,db,
                                            table->s->key_length)))
unknown's avatar
unknown committed
1529
  {
1530
    delete tmp.triggers;
unknown's avatar
unknown committed
1531 1532 1533
    closefrm(&tmp);				// End of memory
    goto end;
  }
1534
  tmp.s->db= tmp.s->table_cache_key;
unknown's avatar
unknown committed
1535

1536
  /* This list copies variables set by open_table */
unknown's avatar
unknown committed
1537 1538 1539 1540
  tmp.tablenr=		table->tablenr;
  tmp.used_fields=	table->used_fields;
  tmp.const_table=	table->const_table;
  tmp.null_row=		table->null_row;
1541
  tmp.maybe_null=	table->maybe_null;
unknown's avatar
unknown committed
1542
  tmp.status=		table->status;
1543 1544
  tmp.keys_in_use_for_query= tmp.s->keys_in_use;
  tmp.used_keys= 	tmp.s->keys_for_keyread;
1545 1546

  /* Get state */
1547
  tmp.s->key_length=	table->s->key_length;
1548 1549
  tmp.in_use=    	table->in_use;
  tmp.reginfo.lock_type=table->reginfo.lock_type;
1550 1551
  tmp.s->version=	refresh_version;
  tmp.s->tmp_table=	table->s->tmp_table;
unknown's avatar
unknown committed
1552 1553
  tmp.grant=		table->grant;

1554
  /* Replace table in open list */
1555 1556
  tmp.next=		table->next;
  tmp.prev=		table->prev;
1557

1558
  delete table->triggers;
unknown's avatar
unknown committed
1559 1560 1561
  if (table->file)
    VOID(closefrm(table));		// close file, free everything

1562 1563
  *table= tmp;
  table->s= &table->share_not_to_be_used;
unknown's avatar
unknown committed
1564 1565
  table->file->change_table_ptr(table);

1566
  DBUG_ASSERT(table->alias != 0);
unknown's avatar
unknown committed
1567 1568
  for (field=table->field ; *field ; field++)
  {
unknown's avatar
unknown committed
1569
    (*field)->table= (*field)->orig_table= table;
1570
    (*field)->table_name= &table->alias;
unknown's avatar
unknown committed
1571
  }
1572
  for (key=0 ; key < table->s->keys ; key++)
1573
  {
unknown's avatar
unknown committed
1574
    for (part=0 ; part < table->key_info[key].usable_key_parts ; part++)
unknown's avatar
unknown committed
1575
      table->key_info[key].key_part[part].field->table= table;
1576
  }
1577 1578 1579
  if (table->triggers)
    table->triggers->set_table(table);

1580
  broadcast_refresh();
unknown's avatar
unknown committed
1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600
  error=0;

 end:
  if (!locked)
    VOID(pthread_mutex_unlock(&LOCK_open));
  DBUG_RETURN(error);
}


/*
  Used with ALTER TABLE:
  Close all instanses of table when LOCK TABLES is in used;
  Close first all instances of table and then reopen them
 */

bool close_data_tables(THD *thd,const char *db, const char *table_name)
{
  TABLE *table;
  for (table=thd->open_tables; table ; table=table->next)
  {
1601 1602
    if (!strcmp(table->s->table_name, table_name) &&
	!strcmp(table->s->db, db))
unknown's avatar
unknown committed
1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620
    {
      mysql_lock_remove(thd, thd->locked_tables,table);
      table->file->close();
      table->db_stat=0;
    }
  }
  return 0;					// For the future
}


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

bool reopen_tables(THD *thd,bool get_locks,bool in_refresh)
{
  DBUG_ENTER("reopen_tables");
1621 1622
  safe_mutex_assert_owner(&LOCK_open);

unknown's avatar
unknown committed
1623 1624 1625 1626 1627
  if (!thd->open_tables)
    DBUG_RETURN(0);

  TABLE *table,*next,**prev;
  TABLE **tables,**tables_ptr;			// For locks
1628
  bool error=0, not_used;
unknown's avatar
unknown committed
1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646
  if (get_locks)
  {
    /* The ptr is checked later */
    uint opens=0;
    for (table=thd->open_tables; table ; table=table->next) opens++;
    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;
    if (!tables || (!db_stat && reopen_table(table,1)))
    {
1647
      my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
unknown's avatar
unknown committed
1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658
      VOID(hash_delete(&open_cache,(byte*) table));
      error=1;
    }
    else
    {
      *prev= table;
      prev= &table->next;
      if (get_locks && !db_stat)
	*tables_ptr++= table;			// need new lock on this
      if (in_refresh)
      {
1659
	table->s->version=0;
unknown's avatar
unknown committed
1660 1661 1662 1663 1664 1665 1666 1667 1668
	table->locked_by_flush=0;
      }
    }
  }
  if (tables != tables_ptr)			// Should we get back old locks
  {
    MYSQL_LOCK *lock;
    /* We should always get these locks */
    thd->some_tables_deleted=0;
1669 1670
    if ((lock= mysql_lock_tables(thd, tables, (uint) (tables_ptr - tables),
                                 0, &not_used)))
unknown's avatar
unknown committed
1671 1672 1673 1674 1675 1676 1677 1678 1679 1680
    {
      thd->locked_tables=mysql_lock_merge(thd->locked_tables,lock);
    }
    else
      error=1;
  }
  if (get_locks && tables)
  {
    my_afree((gptr) tables);
  }
1681
  broadcast_refresh();
unknown's avatar
unknown committed
1682 1683 1684 1685 1686 1687 1688 1689 1690 1691
  *prev=0;
  DBUG_RETURN(error);
}

/*
  Close handlers for tables in list, but leave the TABLE structure
  intact so that we can re-open these quickly
  abort_locks is set if called from flush_tables.
*/

unknown's avatar
unknown committed
1692 1693
void close_old_data_files(THD *thd, TABLE *table, bool abort_locks,
			  bool send_refresh)
unknown's avatar
unknown committed
1694
{
unknown's avatar
unknown committed
1695 1696
  DBUG_ENTER("close_old_data_files");
  bool found=send_refresh;
unknown's avatar
unknown committed
1697 1698
  for (; table ; table=table->next)
  {
1699
    if (table->s->version != refresh_version)
unknown's avatar
unknown committed
1700 1701 1702
    {
      found=1;
      if (!abort_locks)				// If not from flush tables
1703
	table->s->version= refresh_version;	// Let other threads use table
unknown's avatar
unknown committed
1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717
      if (table->db_stat)
      {
	if (abort_locks)
	{
	  mysql_lock_abort(thd,table);		// Close waiting threads
	  mysql_lock_remove(thd, thd->locked_tables,table);
	  table->locked_by_flush=1;		// Will be reopened with locks
	}
	table->file->close();
	table->db_stat=0;
      }
    }
  }
  if (found)
1718
    broadcast_refresh();
unknown's avatar
unknown committed
1719
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1720 1721 1722 1723 1724 1725 1726 1727 1728
}


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

unknown's avatar
unknown committed
1729
bool table_is_used(TABLE *table, bool wait_for_name_lock)
unknown's avatar
unknown committed
1730 1731 1732
{
  do
  {
1733 1734
    char *key= table->s->table_cache_key;
    uint key_length= table->s->key_length;
unknown's avatar
unknown committed
1735 1736
    HASH_SEARCH_STATE state;
    for (TABLE *search= (TABLE*) hash_first(&open_cache, (byte*) key,
1737
                                             key_length, &state);
unknown's avatar
unknown committed
1738
	 search ;
1739 1740
         search= (TABLE*) hash_next(&open_cache, (byte*) key,
                                    key_length, &state))
unknown's avatar
unknown committed
1741 1742
    {
      if (search->locked_by_flush ||
unknown's avatar
unknown committed
1743
	  search->locked_by_name && wait_for_name_lock ||
1744
	  search->db_stat && search->s->version < refresh_version)
unknown's avatar
unknown committed
1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760
	return 1;				// Table is used
    }
  } while ((table=table->next));
  return 0;
}


/* Wait until all used tables are refreshed */

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

  thd->proc_info="Waiting for tables";
  pthread_mutex_lock(&LOCK_open);
unknown's avatar
unknown committed
1761
  while (!thd->killed)
unknown's avatar
unknown committed
1762
  {
unknown's avatar
unknown committed
1763 1764
    thd->some_tables_deleted=0;
    close_old_data_files(thd,thd->open_tables,0,dropping_tables != 0);
1765
    mysql_ha_flush(thd, (TABLE_LIST*) NULL, MYSQL_HA_REOPEN_ON_USAGE, TRUE);
unknown's avatar
unknown committed
1766 1767
    if (!table_is_used(thd->open_tables,1))
      break;
1768
    (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
unknown's avatar
unknown committed
1769 1770 1771 1772 1773 1774 1775
  }
  if (thd->killed)
    result= 1;					// aborted
  else
  {
    /* Now we can open all tables without any interference */
    thd->proc_info="Reopen tables";
unknown's avatar
unknown committed
1776
    thd->version= refresh_version;
1777
    result=reopen_tables(thd,0,0);
1778
  }
unknown's avatar
unknown committed
1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791
  pthread_mutex_unlock(&LOCK_open);
  thd->proc_info=0;
  DBUG_RETURN(result);
}


/* drop tables from locked list */

bool drop_locked_tables(THD *thd,const char *db, const char *table_name)
{
  TABLE *table,*next,**prev;
  bool found=0;
  prev= &thd->open_tables;
1792
  for (table= thd->open_tables; table ; table=next)
unknown's avatar
unknown committed
1793 1794
  {
    next=table->next;
1795 1796
    if (!strcmp(table->s->table_name, table_name) &&
	!strcmp(table->s->db, db))
unknown's avatar
unknown committed
1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809
    {
      mysql_lock_remove(thd, thd->locked_tables,table);
      VOID(hash_delete(&open_cache,(byte*) table));
      found=1;
    }
    else
    {
      *prev=table;
      prev= &table->next;
    }
  }
  *prev=0;
  if (found)
1810
    broadcast_refresh();
unknown's avatar
unknown committed
1811 1812 1813 1814 1815 1816 1817 1818 1819
  if (thd->locked_tables && thd->locked_tables->table_count == 0)
  {
    my_free((gptr) thd->locked_tables,MYF(0));
    thd->locked_tables=0;
  }
  return found;
}


1820 1821 1822 1823 1824
/*
  If we have the table open, which only happens when a LOCK TABLE has been
  done on the table, change the lock type to a lock that will abort all
  other threads trying to get the lock.
*/
unknown's avatar
unknown committed
1825 1826 1827 1828

void abort_locked_tables(THD *thd,const char *db, const char *table_name)
{
  TABLE *table;
1829
  for (table= thd->open_tables; table ; table= table->next)
unknown's avatar
unknown committed
1830
  {
1831 1832
    if (!strcmp(table->s->table_name,table_name) &&
	!strcmp(table->s->db, db))
1833
    {
unknown's avatar
unknown committed
1834
      mysql_lock_abort(thd,table);
1835 1836
      break;
    }
unknown's avatar
unknown committed
1837 1838 1839
  }
}

1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850

/*
  Load a table definition from file and open unireg table

  SYNOPSIS
    open_unireg_entry()
    thd			Thread handle
    entry		Store open table definition here
    db			Database name
    name		Table name
    alias		Alias name
1851
    table_desc		TABLE_LIST descriptor (used with views)
unknown's avatar
VIEW  
unknown committed
1852
    mem_root		temporary mem_root for parsing
1853 1854 1855 1856 1857 1858 1859

  NOTES
   Extra argument for open is taken from thd->open_options

  RETURN
    0	ok
    #	Error
unknown's avatar
unknown committed
1860
*/
1861
static int open_unireg_entry(THD *thd, TABLE *entry, const char *db,
unknown's avatar
VIEW  
unknown committed
1862 1863
			     const char *name, const char *alias,
			     TABLE_LIST *table_desc, MEM_ROOT *mem_root)
unknown's avatar
unknown committed
1864 1865
{
  char path[FN_REFLEN];
1866
  int error;
unknown's avatar
unknown committed
1867
  uint discover_retry_count= 0;
unknown's avatar
unknown committed
1868 1869
  DBUG_ENTER("open_unireg_entry");

1870
  strxmov(path, mysql_data_home, "/", db, "/", name, NullS);
1871
  while ((error= openfrm(thd, path, alias,
unknown's avatar
VIEW  
unknown committed
1872 1873
		         (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
			         HA_GET_INDEX | HA_TRY_READ_ONLY |
1874
                                 NO_ERR_ON_NEW_FRM),
unknown's avatar
VIEW  
unknown committed
1875 1876 1877
		      READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
		      thd->open_options, entry)) &&
      (error != 5 ||
unknown's avatar
unknown committed
1878
       (fn_format(path, path, 0, reg_ext, MY_UNPACK_FILENAME),
1879
        open_new_frm(thd, path, alias, db, name,
unknown's avatar
unknown committed
1880 1881 1882 1883
                     (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
                             HA_GET_INDEX | HA_TRY_READ_ONLY),
                     READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
                     thd->open_options, entry, table_desc, mem_root))))
unknown's avatar
VIEW  
unknown committed
1884

unknown's avatar
unknown committed
1885
  {
1886
    if (!entry->s || !entry->s->crashed)
unknown's avatar
unknown committed
1887 1888
    {
      /*
1889 1890 1891 1892
        Frm file could not be found on disk
        Since it does not exist, no one can be using it
        LOCK_open has been locked to protect from someone else
        trying to discover the table at the same time.
unknown's avatar
unknown committed
1893 1894
      */
      if (discover_retry_count++ != 0)
unknown's avatar
unknown committed
1895
        goto err;
1896
      if (ha_create_table_from_engine(thd, db, name) > 0)
1897 1898 1899
      {
        /* Give right error message */
        thd->clear_error();
unknown's avatar
unknown committed
1900
        DBUG_PRINT("error", ("Discovery of %s/%s failed", db, name));
1901 1902 1903 1904 1905
        my_printf_error(ER_UNKNOWN_ERROR,
                        "Failed to open '%-.64s', error while "
                        "unpacking from engine",
                        MYF(0), name);

unknown's avatar
unknown committed
1906
        goto err;
1907
      }
unknown's avatar
unknown committed
1908

unknown's avatar
unknown committed
1909
      mysql_reset_errors(thd, 1);    // Clear warnings
1910
      thd->clear_error();            // Clear error message
unknown's avatar
unknown committed
1911 1912
      continue;
    }
1913

unknown's avatar
unknown committed
1914
    // Code below is for repairing a crashed file
1915
    TABLE_LIST table_list;
unknown's avatar
unknown committed
1916
    bzero((char*) &table_list, sizeof(table_list)); // just for safe
1917
    table_list.db=(char*) db;
1918
    table_list.table_name=(char*) name;
unknown's avatar
unknown committed
1919

1920 1921
    safe_mutex_assert_owner(&LOCK_open);

1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934
    if ((error=lock_table_name(thd,&table_list)))
    {
      if (error < 0)
      {
	goto err;
      }
      if (wait_for_locked_table_names(thd,&table_list))
      {
	unlock_table_name(thd,&table_list);
	goto err;
      }
    }
    pthread_mutex_unlock(&LOCK_open);
unknown's avatar
unknown committed
1935 1936
    thd->clear_error();				// Clear error message
    error= 0;
1937
    if (openfrm(thd, path, alias,
1938 1939 1940 1941
		(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,
1942
		entry) || ! entry->file ||
1943 1944
	(entry->file->is_crashed() && entry->file->check_and_repair(thd)))
    {
unknown's avatar
unknown committed
1945
      /* Give right error message */
unknown's avatar
unknown committed
1946
      thd->clear_error();
1947
      my_error(ER_NOT_KEYFILE, MYF(0), name, my_errno);
unknown's avatar
unknown committed
1948
      sql_print_error("Couldn't repair table: %s.%s",db,name);
1949 1950
      if (entry->file)
	closefrm(entry);
1951 1952
      error=1;
    }
1953
    else
unknown's avatar
unknown committed
1954
      thd->clear_error();			// Clear error message
unknown's avatar
unknown committed
1955
    pthread_mutex_lock(&LOCK_open);
1956
    unlock_table_name(thd,&table_list);
unknown's avatar
unknown committed
1957

1958 1959
    if (error)
      goto err;
unknown's avatar
unknown committed
1960 1961
    break;
  }
unknown's avatar
VIEW  
unknown committed
1962 1963 1964 1965

  if (error == 5)
    DBUG_RETURN(0);	// we have just opened VIEW

1966 1967 1968 1969 1970 1971 1972 1973 1974
  /*
    We can't mark all tables in 'mysql' database as system since we don't
    allow to lock such tables for writing with any other tables (even with
    other system tables) and some privilege tables need this.
  */
  if (!my_strcasecmp(system_charset_info, db, "mysql") &&
      !my_strcasecmp(system_charset_info, name, "proc"))
    entry->s->system_table= 1;

1975
  if (Table_triggers_list::check_n_load(thd, db, name, entry, 0))
1976 1977
    goto err;

unknown's avatar
unknown committed
1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992
  /*
    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;
      uint query_buf_size= 20 + 2*NAME_LEN + 1;
      if ((query= (char*)my_malloc(query_buf_size,MYF(MY_WME))))
      {
        end = strxmov(strmov(query, "DELETE FROM `"),
                      db,"`.`",name,"`", NullS);
1993
        Query_log_event qinfo(thd, query, (ulong)(end-query), 0, FALSE);
unknown's avatar
unknown committed
1994 1995 1996 1997 1998 1999 2000 2001 2002 2003
        mysql_bin_log.write(&qinfo);
        my_free(query, MYF(0));
      }
      else
      {
        /*
          As replication is maybe going to be corrupted, we need to warn the
          DBA on top of warning the client (which will automatically be done
          because of MYF(MY_WME) in my_malloc() above).
        */
unknown's avatar
unknown committed
2004
        sql_print_error("When opening HEAP table, could not allocate \
unknown's avatar
unknown committed
2005
memory to write 'DELETE FROM `%s`.`%s`' to the binary log",db,name);
2006
        delete entry->triggers;
unknown's avatar
unknown committed
2007 2008 2009 2010 2011
        if (entry->file)
          closefrm(entry);
        goto err;
      }
    }
unknown's avatar
unknown committed
2012 2013
  }
  DBUG_RETURN(0);
2014
err:
2015
  /* Hide "Table doesn't exist" errors if table belong to view */
unknown's avatar
unknown committed
2016 2017
  if (thd->net.last_errno == ER_NO_SUCH_TABLE &&
      table_desc && table_desc->belong_to_view)
2018
  {
unknown's avatar
unknown committed
2019
    TABLE_LIST *view= table_desc->belong_to_view;
2020 2021 2022
    thd->clear_error();
    my_error(ER_VIEW_INVALID, MYF(0), view->view_db.str, view->view_name.str);
  }
2023
  DBUG_RETURN(1);
unknown's avatar
unknown committed
2024 2025
}

2026

unknown's avatar
unknown committed
2027 2028 2029 2030 2031 2032
/*
  Open all tables in list

  SYNOPSIS
    open_tables()
    thd - thread handler
2033
    start - list of tables in/out
unknown's avatar
unknown committed
2034
    counter - number of opened tables will be return using this parameter
2035 2036 2037
    flags   - bitmap of flags to modify how the tables will be open:
              MYSQL_LOCK_IGNORE_FLUSH - open table even if someone has
              done a flush or namelock on it.
unknown's avatar
unknown committed
2038

2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049
  NOTE
    Unless we are already in prelocked mode, this function will also precache
    all SP/SFs explicitly or implicitly (via views and triggers) used by the
    query and add tables needed for their execution to table list. If resulting
    tables list will be non empty it will mark query as requiring precaching.
    Prelocked mode will be enabled for such query during lock_tables() call.

    If query for which we are opening tables is already marked as requiring
    prelocking it won't do such precaching and will simply reuse table list
    which is already built.

unknown's avatar
unknown committed
2050 2051 2052 2053 2054
  RETURN
    0  - OK
    -1 - error
*/

2055
int open_tables(THD *thd, TABLE_LIST **start, uint *counter, uint flags)
unknown's avatar
unknown committed
2056 2057 2058 2059
{
  TABLE_LIST *tables;
  bool refresh;
  int result=0;
unknown's avatar
VIEW  
unknown committed
2060
  MEM_ROOT new_frm_mem;
2061 2062 2063
  /* Also used for indicating that prelocking is need */
  TABLE_LIST **query_tables_last_own;
  DBUG_ENTER("open_tables");
unknown's avatar
VIEW  
unknown committed
2064 2065 2066 2067 2068
  /*
    temporary mem_root for new .frm parsing.
    TODO: variables for size
  */
  init_alloc_root(&new_frm_mem, 8024, 8024);
unknown's avatar
unknown committed
2069

2070
  thd->current_tablenr= 0;
unknown's avatar
unknown committed
2071
 restart:
unknown's avatar
unknown committed
2072
  *counter= 0;
2073
  query_tables_last_own= 0;
unknown's avatar
unknown committed
2074
  thd->proc_info="Opening tables";
2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086

  /*
    If we are not already executing prelocked statement and don't have
    statement for which table list for prelocking is already built, let
    us cache routines and try to build such table list.

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

  if (!thd->prelocked_mode && !thd->lex->requires_prelocking() &&
2089
      thd->lex->sroutines_list.elements)
2090
  {
2091
    bool first_no_prelocking, need_prelocking, tabs_changed;
2092
    TABLE_LIST **save_query_tables_last= thd->lex->query_tables_last;
2093 2094

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

2097 2098
    if (sp_cache_routines_and_add_tables(thd, thd->lex,
                                         first_no_prelocking,
2099
                                         &tabs_changed))
2100
    {
2101 2102 2103 2104 2105 2106
      /*
        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;
2107 2108 2109
      goto err;
    }
    else if ((tabs_changed || *start) && need_prelocking)
2110 2111 2112 2113 2114 2115 2116
    {
      query_tables_last_own= save_query_tables_last;
      *start= thd->lex->query_tables;
    }
  }

  for (tables= *start; tables ;tables= tables->next_global)
unknown's avatar
unknown committed
2117
  {
unknown's avatar
unknown committed
2118 2119 2120
    /*
      Ignore placeholders for derived tables. After derived tables
      processing, link to created temporary table will be put here.
2121 2122
      If this is derived table for view then we still want to process
      routines used by this view.
unknown's avatar
unknown committed
2123 2124
     */
    if (tables->derived)
2125 2126 2127
    {
      if (tables->view)
        goto process_view_routines;
unknown's avatar
unknown committed
2128
      continue;
2129
    }
2130 2131 2132 2133 2134 2135
    if (tables->schema_table)
    {
      if (!mysql_schema_table(thd, thd->lex, tables))
        continue;
      DBUG_RETURN(-1);
    }
unknown's avatar
unknown committed
2136
    (*counter)++;
2137
    
unknown's avatar
unknown committed
2138
    if (!tables->table &&
2139
	!(tables->table= open_table(thd, tables, &new_frm_mem, &refresh, flags)))
unknown's avatar
unknown committed
2140
    {
unknown's avatar
VIEW  
unknown committed
2141
      free_root(&new_frm_mem, MYF(MY_KEEP_PREALLOC));
2142

unknown's avatar
VIEW  
unknown committed
2143 2144
      if (tables->view)
      {
2145
        /* VIEW placeholder */
unknown's avatar
VIEW  
unknown committed
2146
	(*counter)--;
2147

2148
        /*
2149 2150 2151 2152 2153
          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
2154 2155 2156
          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.
2157
        */
unknown's avatar
unknown committed
2158
        if (query_tables_last_own == &(tables->next_global) &&
2159 2160
            tables->view->query_tables)
          query_tables_last_own= tables->view->query_tables_last;
2161
        /*
2162 2163
          Let us free memory used by 'sroutines' hash here since we never
          call destructor for this LEX.
2164
        */
2165
        hash_free(&tables->view->sroutines);
2166
	goto process_view_routines;
unknown's avatar
VIEW  
unknown committed
2167 2168
      }

unknown's avatar
unknown committed
2169 2170
      if (refresh)				// Refresh in progress
      {
2171
        /*
2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183
          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.
2184 2185 2186
        */
        if (query_tables_last_own)
          thd->lex->mark_as_requiring_prelocking(query_tables_last_own);
2187
        close_tables_for_reopen(thd, start);
unknown's avatar
unknown committed
2188 2189 2190 2191 2192
	goto restart;
      }
      result= -1;				// Fatal error
      break;
    }
unknown's avatar
VIEW  
unknown committed
2193
    else
2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207
    {
      /*
        If we are not already in prelocked mode and extended table list is not
        yet built and we have trigger for table being opened then we should
        cache all routines used by its triggers and add their tables to
        prelocking list.
        If we lock table for reading we won't update it so there is no need to
        process its triggers since they never will be activated.
      */
      if (!thd->prelocked_mode && !thd->lex->requires_prelocking() &&
          tables->table->triggers &&
          tables->lock_type >= TL_WRITE_ALLOW_WRITE)
      {
        if (!query_tables_last_own)
2208 2209
          query_tables_last_own= thd->lex->query_tables_last;
        if (sp_cache_routines_and_add_tables_for_triggers(thd, thd->lex,
2210
                                                          tables))
2211
        {
2212 2213 2214 2215 2216 2217
          /*
            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;
2218 2219
          goto err;
        }
2220
      }
unknown's avatar
VIEW  
unknown committed
2221
      free_root(&new_frm_mem, MYF(MY_KEEP_PREALLOC));
2222
    }
unknown's avatar
VIEW  
unknown committed
2223

2224
    if (tables->lock_type != TL_UNLOCK && ! thd->locked_tables)
unknown's avatar
unknown committed
2225 2226
      tables->table->reginfo.lock_type=tables->lock_type;
    tables->table->grant= tables->grant;
2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239

process_view_routines:
    /*
      Again we may need cache all routines used by this view and add
      tables used by them to table list.
    */
    if (tables->view && !thd->prelocked_mode &&
        !thd->lex->requires_prelocking() &&
        tables->view->sroutines_list.elements)
    {
      /* We have at least one table in TL here. */
      if (!query_tables_last_own)
        query_tables_last_own= thd->lex->query_tables_last;
2240
      if (sp_cache_routines_and_add_tables_for_view(thd, thd->lex, tables))
2241
      {
2242 2243 2244 2245 2246 2247
        /*
          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;
2248 2249
        goto err;
      }
2250
    }
unknown's avatar
unknown committed
2251
  }
2252 2253

 err:
unknown's avatar
unknown committed
2254
  thd->proc_info=0;
2255
  free_root(&new_frm_mem, MYF(0));              // Free pre-alloced block
2256 2257 2258 2259

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

unknown's avatar
unknown committed
2260 2261 2262 2263
  DBUG_RETURN(result);
}


unknown's avatar
unknown committed
2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286
/*
  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)
  {
2287
    my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),table->alias);
unknown's avatar
unknown committed
2288 2289
    DBUG_RETURN(1);
  }
unknown's avatar
unknown committed
2290
  if ((error=table->file->start_stmt(thd, lock_type)))
unknown's avatar
unknown committed
2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307
  {
    table->file->print_error(error,MYF(0));
    DBUG_RETURN(1);
  }
  DBUG_RETURN(0);
}


/*
  Open and lock one table

  SYNOPSIS
    open_ltable()
    thd			Thread handler
    table_list		Table to open is first table in this list
    lock_type		Lock to use for open

2308 2309 2310 2311 2312
  NOTE
    This function don't do anything like SP/SF/views/triggers analysis done
    in open_tables(). It is intended for opening of only one concrete table.
    And used only in special contexts.

unknown's avatar
unknown committed
2313 2314 2315 2316 2317 2318 2319 2320 2321
  RETURN VALUES
    table		Opened table
    0			Error
  
    If ok, the following are also set:
      table_list->lock_type 	lock_type
      table_list->table		table
*/

unknown's avatar
unknown committed
2322 2323 2324 2325 2326 2327 2328
TABLE *open_ltable(THD *thd, TABLE_LIST *table_list, thr_lock_type lock_type)
{
  TABLE *table;
  bool refresh;
  DBUG_ENTER("open_ltable");

  thd->proc_info="Opening table";
2329
  thd->current_tablenr= 0;
2330 2331
  /* open_ltable can be used only for BASIC TABLEs */
  table_list->required_type= FRMTYPE_TABLE;
2332
  while (!(table= open_table(thd, table_list, thd->mem_root, &refresh, 0)) &&
2333
         refresh)
2334
    ;
unknown's avatar
unknown committed
2335

unknown's avatar
unknown committed
2336 2337
  if (table)
  {
unknown's avatar
unknown committed
2338
#if defined( __WIN__) || defined(OS2)
2339
    /* Win32 can't drop a file that is open */
unknown's avatar
unknown committed
2340
    if (lock_type == TL_WRITE_ALLOW_READ)
2341 2342 2343
    {
      lock_type= TL_WRITE;
    }
unknown's avatar
unknown committed
2344
#endif /* __WIN__ || OS2 */
unknown's avatar
unknown committed
2345 2346
    table_list->lock_type= lock_type;
    table_list->table=	   table;
unknown's avatar
unknown committed
2347 2348 2349
    table->grant= table_list->grant;
    if (thd->locked_tables)
    {
unknown's avatar
unknown committed
2350 2351 2352 2353 2354
      if (check_lock_and_start_stmt(thd, table, lock_type))
	table= 0;
    }
    else
    {
2355
      DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
unknown's avatar
unknown committed
2356
      if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)
2357 2358
	if (! (thd->lock= mysql_lock_tables(thd, &table_list->table, 1, 0,
                                            &refresh)))
unknown's avatar
unknown committed
2359
	  table= 0;
unknown's avatar
unknown committed
2360 2361 2362 2363 2364 2365
    }
  }
  thd->proc_info=0;
  DBUG_RETURN(table);
}

unknown's avatar
unknown committed
2366

unknown's avatar
unknown committed
2367
/*
unknown's avatar
unknown committed
2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380
  Open all tables in list and locks them for read without derived
  tables processing.

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

  RETURN
    0  - ok
    -1 - error

  NOTE
2381
    The lock will automaticaly be freed by close_thread_tables()
unknown's avatar
unknown committed
2382 2383
*/

unknown's avatar
unknown committed
2384
int simple_open_n_lock_tables(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
2385
{
unknown's avatar
unknown committed
2386
  uint counter;
2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397
  bool need_reopen;
  DBUG_ENTER("simple_open_n_lock_tables");

  for ( ; ; ) 
  {
    if (open_tables(thd, &tables, &counter, 0))
      DBUG_RETURN(-1);
    if (!lock_tables(thd, tables, counter, &need_reopen))
      break;
    if (!need_reopen)
      DBUG_RETURN(-1);
2398
    close_tables_for_reopen(thd, &tables);
2399
  }
unknown's avatar
unknown committed
2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413
  DBUG_RETURN(0);
}


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

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

  RETURN
unknown's avatar
unknown committed
2414 2415
    FALSE - ok
    TRUE  - error
unknown's avatar
unknown committed
2416 2417

  NOTE
2418
    The lock will automaticaly be freed by close_thread_tables()
unknown's avatar
unknown committed
2419 2420
*/

unknown's avatar
unknown committed
2421
bool open_and_lock_tables(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
2422 2423
{
  uint counter;
2424
  bool need_reopen;
unknown's avatar
unknown committed
2425
  DBUG_ENTER("open_and_lock_tables");
2426 2427 2428 2429 2430 2431 2432 2433 2434

  for ( ; ; ) 
  {
    if (open_tables(thd, &tables, &counter, 0))
      DBUG_RETURN(-1);
    if (!lock_tables(thd, tables, counter, &need_reopen))
      break;
    if (!need_reopen)
      DBUG_RETURN(-1);
2435
    close_tables_for_reopen(thd, &tables);
2436 2437
  }
  if (mysql_handle_derived(thd->lex, &mysql_derived_prepare) ||
unknown's avatar
unknown committed
2438 2439
      (thd->fill_derived_tables() &&
       mysql_handle_derived(thd->lex, &mysql_derived_filling)))
unknown's avatar
unknown committed
2440
    DBUG_RETURN(TRUE); /* purecov: inspected */
unknown's avatar
unknown committed
2441
  DBUG_RETURN(0);
unknown's avatar
unknown committed
2442 2443 2444
}


2445 2446 2447 2448 2449 2450
/*
  Open all tables in list and process derived tables

  SYNOPSIS
    open_normal_and_derived_tables
    thd		- thread handler
2451
    tables	- list of tables for open
2452 2453 2454
    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.
2455 2456 2457 2458 2459 2460 2461 2462 2463 2464

  RETURN
    FALSE - ok
    TRUE  - error

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

2465
bool open_normal_and_derived_tables(THD *thd, TABLE_LIST *tables, uint flags)
2466 2467 2468
{
  uint counter;
  DBUG_ENTER("open_normal_and_derived_tables");
unknown's avatar
unknown committed
2469
  DBUG_ASSERT(!thd->fill_derived_tables());
2470
  if (open_tables(thd, &tables, &counter, flags) ||
unknown's avatar
unknown committed
2471 2472 2473
      mysql_handle_derived(thd->lex, &mysql_derived_prepare))
    DBUG_RETURN(TRUE); /* purecov: inspected */
  DBUG_RETURN(0);
2474 2475 2476
}


2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497
/*
  Mark all real tables in the list as free for reuse.

  SYNOPSIS
    mark_real_tables_as_free_for_reuse()
      thd   - thread context
      table - head of the list of tables

  DESCRIPTION
    Marks all real tables in the list (i.e. not views, derived
    or schema tables) as free for reuse.
*/

static void mark_real_tables_as_free_for_reuse(TABLE_LIST *table)
{
  for (; table; table= table->next_global)
    if (!table->placeholder() && !table->schema_table)
      table->table->query_id= 0;
}


unknown's avatar
unknown committed
2498 2499 2500 2501 2502 2503 2504
/*
  Lock all tables in list

  SYNOPSIS
    lock_tables()
    thd			Thread handler
    tables		Tables to lock
2505 2506 2507 2508 2509 2510
    count		Number of opened tables
    need_reopen         Out parameter which if TRUE indicates that some
                        tables were dropped or altered during this call
                        and therefore invoker should reopen tables and
                        try to lock them once again (in this case
                        lock_tables() will also return error).
unknown's avatar
unknown committed
2511

2512 2513 2514 2515 2516
  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.

2517 2518 2519 2520
    If query for which we are calling this function marked as requring
    prelocking, this function will do implicit LOCK TABLES and change
    thd::prelocked_mode accordingly.

unknown's avatar
unknown committed
2521 2522 2523 2524 2525
  RETURN VALUES
   0	ok
   -1	Error
*/

2526
int lock_tables(THD *thd, TABLE_LIST *tables, uint count, bool *need_reopen)
unknown's avatar
unknown committed
2527
{
unknown's avatar
unknown committed
2528
  TABLE_LIST *table;
2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541

  DBUG_ENTER("lock_tables");
  /*
    We can't meet statement requiring prelocking if we already
    in prelocked mode.
  */
  DBUG_ASSERT(!thd->prelocked_mode || !thd->lex->requires_prelocking());
  /*
    If statement requires prelocking then it has non-empty table list.
    So it is safe to shortcut.
  */
  DBUG_ASSERT(!thd->lex->requires_prelocking() || tables);

2542 2543
  *need_reopen= FALSE;

unknown's avatar
unknown committed
2544
  if (!tables)
2545
    DBUG_RETURN(0);
unknown's avatar
unknown committed
2546

2547 2548 2549 2550 2551 2552 2553 2554 2555 2556
  /*
    We need this extra check for thd->prelocked_mode because we want to avoid
    attempts to lock tables in substatements. Checking for thd->locked_tables
    is not enough in some situations. For example for SP containing
    "drop table t3; create temporary t3 ..; insert into t3 ...;"
    thd->locked_tables may be 0 after drop tables, and without this extra
    check insert will try to lock temporary table t3, that will lead
    to memory leak...
  */
  if (!thd->locked_tables && !thd->prelocked_mode)
unknown's avatar
unknown committed
2557
  {
2558
    DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
unknown's avatar
unknown committed
2559
    TABLE **start,**ptr;
2560

2561
    if (!(ptr=start=(TABLE**) thd->alloc(sizeof(TABLE*)*count)))
2562
      DBUG_RETURN(-1);
unknown's avatar
VIEW  
unknown committed
2563
    for (table= tables; table; table= table->next_global)
unknown's avatar
unknown committed
2564
    {
unknown's avatar
unknown committed
2565
      if (!table->placeholder() && !table->schema_table)
unknown's avatar
unknown committed
2566 2567
	*(ptr++)= table->table;
    }
2568 2569 2570 2571 2572 2573 2574 2575

    /* We have to emulate LOCK TABLES if we are statement needs prelocking. */
    if (thd->lex->requires_prelocking())
    {
      thd->in_lock_tables=1;
      thd->options|= OPTION_TABLE_LOCK;
    }

2576 2577 2578
    if (! (thd->lock= mysql_lock_tables(thd, start, (uint) (ptr - start),
                                        MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN,
                                        need_reopen)))
2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624
    {
      if (thd->lex->requires_prelocking())
      {
        thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
        thd->in_lock_tables=0;
      }
      DBUG_RETURN(-1);
    }
    if (thd->lex->requires_prelocking() &&
        thd->lex->sql_command != SQLCOM_LOCK_TABLES)
    {
      TABLE_LIST *first_not_own= thd->lex->first_not_own_table();
      /*
        We just have done implicit LOCK TABLES, and now we have
        to emulate first open_and_lock_tables() after it.

        Note that "LOCK TABLES" can also be marked as requiring prelocking
        (e.g. if one locks view which uses functions). We should not emulate
        such open_and_lock_tables() in this case. We also should not set
        THD::prelocked_mode or first close_thread_tables() call will do
        "UNLOCK TABLES".
      */
      thd->locked_tables= thd->lock;
      thd->lock= 0;
      thd->in_lock_tables=0;

      for (table= tables; table != first_not_own; table= table->next_global)
      {
        if (!table->placeholder() && !table->schema_table)
        {
          table->table->query_id= thd->query_id;
          if (check_lock_and_start_stmt(thd, table->table, table->lock_type))
          {
            ha_rollback_stmt(thd);
            mysql_unlock_tables(thd, thd->locked_tables);
            thd->locked_tables= 0;
            thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
            DBUG_RETURN(-1);
          }
        }
      }
      /*
        Let us mark all tables which don't belong to the statement itself,
        and was marked as occupied during open_tables() as free for reuse.
      */
      mark_real_tables_as_free_for_reuse(first_not_own);
2625
      DBUG_PRINT("info",("prelocked_mode= PRELOCKED"));
2626 2627
      thd->prelocked_mode= PRELOCKED;
    }
unknown's avatar
unknown committed
2628
  }
unknown's avatar
unknown committed
2629 2630
  else
  {
2631 2632
    TABLE_LIST *first_not_own= thd->lex->first_not_own_table();
    for (table= tables; table != first_not_own; table= table->next_global)
unknown's avatar
unknown committed
2633
    {
2634
      if (!table->placeholder() && !table->schema_table &&
unknown's avatar
unknown committed
2635
	  check_lock_and_start_stmt(thd, table->table, table->lock_type))
unknown's avatar
unknown committed
2636
      {
unknown's avatar
unknown committed
2637
	ha_rollback_stmt(thd);
2638
	DBUG_RETURN(-1);
unknown's avatar
unknown committed
2639 2640
      }
    }
2641 2642 2643 2644 2645 2646 2647 2648
    /*
      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);
2649
      DBUG_PRINT("info", ("thd->prelocked_mode= PRELOCKED_UNDER_LOCK_TABLES"));
2650 2651
      thd->prelocked_mode= PRELOCKED_UNDER_LOCK_TABLES;
    }
unknown's avatar
unknown committed
2652
  }
2653
  DBUG_RETURN(0);
unknown's avatar
unknown committed
2654 2655
}

unknown's avatar
unknown committed
2656

2657 2658 2659 2660 2661 2662
/*
  Prepare statement for reopening of tables and recalculation of set of
  prelocked tables.

  SYNOPSIS
    close_tables_for_reopen()
2663 2664
      thd    in     Thread context
      tables in/out List of tables which we were trying to open and lock
2665 2666 2667

*/

2668
void close_tables_for_reopen(THD *thd, TABLE_LIST **tables)
2669
{
2670 2671 2672 2673 2674 2675
  /*
    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;
2676 2677
  thd->lex->chop_off_not_own_tables();
  sp_remove_not_own_routines(thd->lex);
2678 2679 2680
  for (TABLE_LIST *tmp= *tables; tmp; tmp= tmp->next_global)
    tmp->table= 0;
  mark_used_tables_as_free_for_reuse(thd, thd->temporary_tables);
2681 2682 2683 2684
  close_thread_tables(thd);
}


unknown's avatar
unknown committed
2685
/*
unknown's avatar
unknown committed
2686 2687 2688
  Open a single table without table caching and don't set it in open_list
  Used by alter_table to open a temporary table and when creating
  a temporary table with CREATE TEMPORARY ...
unknown's avatar
unknown committed
2689 2690 2691 2692 2693 2694
*/

TABLE *open_temporary_table(THD *thd, const char *path, const char *db,
			    const char *table_name, bool link_in_list)
{
  TABLE *tmp_table;
2695
  TABLE_SHARE *share;
unknown's avatar
unknown committed
2696
  DBUG_ENTER("open_temporary_table");
2697

unknown's avatar
unknown committed
2698 2699 2700 2701 2702 2703 2704
  /*
    The extra size in my_malloc() is for table_cache_key
    4 bytes for master thread id if we are in the slave
    1 byte to terminate db
    1 byte to terminate table_name
    total of 6 extra bytes in my_malloc in addition to table/db stuff
  */
unknown's avatar
unknown committed
2705
  if (!(tmp_table=(TABLE*) my_malloc(sizeof(*tmp_table)+(uint) strlen(db)+
unknown's avatar
unknown committed
2706
				     (uint) strlen(table_name)+6+4,
unknown's avatar
unknown committed
2707 2708 2709
				     MYF(MY_WME))))
    DBUG_RETURN(0);				/* purecov: inspected */

2710
  if (openfrm(thd, path, table_name,
unknown's avatar
unknown committed
2711
	      (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE | HA_GET_INDEX),
unknown's avatar
unknown committed
2712
	      READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
2713
	      ha_open_options,
unknown's avatar
unknown committed
2714 2715
	      tmp_table))
  {
2716
    my_free((char*) tmp_table,MYF(0));
unknown's avatar
unknown committed
2717 2718 2719
    DBUG_RETURN(0);
  }

2720
  share= tmp_table->s;
unknown's avatar
unknown committed
2721
  tmp_table->reginfo.lock_type=TL_WRITE;	 // Simulate locked
2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733
  share->tmp_table= (tmp_table->file->has_transactions() ? 
                     TRANSACTIONAL_TMP_TABLE : TMP_TABLE);
  share->table_cache_key= (char*) (tmp_table+1);
  share->db= share->table_cache_key;
  share->key_length= (uint) (strmov(((char*) (share->table_name=
                                              strmov(share->table_cache_key,
                                                     db)+1)),
                                    table_name) -
                             share->table_cache_key) +1;
  int4store(share->table_cache_key + share->key_length, thd->server_id);
  share->key_length+= 4;
  int4store(share->table_cache_key + share->key_length,
unknown's avatar
unknown committed
2734
	    thd->variables.pseudo_thread_id);
2735
  share->key_length+= 4;
2736

unknown's avatar
unknown committed
2737 2738 2739 2740
  if (link_in_list)
  {
    tmp_table->next=thd->temporary_tables;
    thd->temporary_tables=tmp_table;
unknown's avatar
unknown committed
2741 2742
    if (thd->slave_thread)
      slave_open_temp_tables++;
unknown's avatar
unknown committed
2743 2744 2745 2746 2747 2748 2749 2750
  }
  DBUG_RETURN(tmp_table);
}


bool rm_temporary_table(enum db_type base, char *path)
{
  bool error=0;
2751 2752
  DBUG_ENTER("rm_temporary_table");

unknown's avatar
unknown committed
2753 2754 2755 2756 2757
  fn_format(path, path,"",reg_ext,4);
  unpack_filename(path,path);
  if (my_delete(path,MYF(0)))
    error=1; /* purecov: inspected */
  *fn_ext(path)='\0';				// remove extension
2758
  handler *file= get_new_handler((TABLE*) 0, current_thd->mem_root, base);
unknown's avatar
unknown committed
2759
  if (file && file->delete_table(path))
unknown's avatar
unknown committed
2760
  {
unknown's avatar
unknown committed
2761
    error=1;
unknown's avatar
unknown committed
2762 2763
    sql_print_warning("Could not remove tmp table: '%s', error: %d",
                      path, my_errno);
unknown's avatar
unknown committed
2764
  }
unknown's avatar
unknown committed
2765
  delete file;
2766
  DBUG_RETURN(error);
unknown's avatar
unknown committed
2767 2768 2769 2770
}


/*****************************************************************************
unknown's avatar
unknown committed
2771 2772 2773 2774 2775 2776
* The following find_field_in_XXX procedures implement the core of the
* name resolution functionality. The entry point to resolve a column name in a
* list of tables is 'find_field_in_tables'. It calls 'find_field_in_table_ref'
* for each table reference. In turn, depending on the type of table reference,
* 'find_field_in_table_ref' calls one of the 'find_field_in_XXX' procedures
* below specific for the type of table reference.
unknown's avatar
unknown committed
2777 2778
******************************************************************************/

unknown's avatar
unknown committed
2779
/* Special Field pointers as return values of find_field_in_XXX functions. */
unknown's avatar
unknown committed
2780 2781
Field *not_found_field= (Field*) 0x1;
Field *view_ref_found= (Field*) 0x2; 
unknown's avatar
VIEW  
unknown committed
2782

unknown's avatar
unknown committed
2783 2784
#define WRONG_GRANT (Field*) -1

unknown's avatar
unknown committed
2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799
static void update_field_dependencies(THD *thd, Field *field, TABLE *table)
{
  if (thd->set_query_id)
  {
    if (field->query_id != thd->query_id)
    {
      field->query_id= thd->query_id;
      table->used_fields++;
      table->used_keys.intersect(field->part_of_key);
    }
    else
      thd->dupp_field= field;
  }
}

unknown's avatar
VIEW  
unknown committed
2800 2801

/*
unknown's avatar
unknown committed
2802
  Find a field by name in a view that uses merge algorithm.
unknown's avatar
VIEW  
unknown committed
2803 2804

  SYNOPSIS
unknown's avatar
unknown committed
2805
    find_field_in_view()
unknown's avatar
VIEW  
unknown committed
2806
    thd				thread handler
unknown's avatar
unknown committed
2807
    table_list			view to search for 'name'
unknown's avatar
VIEW  
unknown committed
2808 2809
    name			name of field
    length			length of name
2810
    item_name                   name of item if it will be created (VIEW)
unknown's avatar
unknown committed
2811 2812
    ref				expression substituted in VIEW should be passed
                                using this reference (return view_ref_found)
unknown's avatar
unknown committed
2813
    register_tree_change        TRUE if ref is not stack variable and we
unknown's avatar
unknown committed
2814
                                need register changes in item tree
unknown's avatar
VIEW  
unknown committed
2815 2816 2817 2818

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

unknown's avatar
unknown committed
2822 2823
static Field *
find_field_in_view(THD *thd, TABLE_LIST *table_list,
2824 2825
                   const char *name, uint length,
                   const char *item_name, Item **ref,
unknown's avatar
unknown committed
2826
                   bool register_tree_change)
unknown's avatar
VIEW  
unknown committed
2827
{
unknown's avatar
unknown committed
2828 2829 2830 2831 2832 2833
  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);
2834 2835
  Query_arena *arena, backup;  
  
unknown's avatar
unknown committed
2836 2837 2838
  DBUG_ASSERT(table_list->schema_table_reformed ||
              (ref != 0 && table_list->view != 0));
  for (; !field_it.end_of_fields(); field_it.next())
unknown's avatar
VIEW  
unknown committed
2839
  {
unknown's avatar
unknown committed
2840
    if (!my_strcasecmp(system_charset_info, field_it.name(), name))
2841
    {
2842 2843 2844
      // in PS use own arena or data will be freed after prepare
      if (register_tree_change)
        arena= thd->activate_stmt_arena_if_needed(&backup);
2845 2846 2847 2848
      /*
        create_item() may, or may not create a new Item, depending on
        the column reference. See create_view_field() for details.
      */
unknown's avatar
unknown committed
2849
      Item *item= field_it.create_item(thd);
2850 2851 2852
      if (register_tree_change && arena)
        thd->restore_active_arena(arena, &backup);
      
unknown's avatar
unknown committed
2853 2854 2855 2856 2857 2858
      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.
2859
       We need to set alias on both ref itself and on ref real item.
unknown's avatar
unknown committed
2860 2861
      */
      if (*ref && !(*ref)->is_autogenerated_name)
2862
      {
unknown's avatar
unknown committed
2863 2864
        item->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
2865 2866 2867
        item->real_item()->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
      }
unknown's avatar
unknown committed
2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895
      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

2896 2897 2898 2899 2900 2901
  DESCRIPTION
    Search for a field among the result fields of a NATURAL/USING join.
    Notice that this procedure is called only for non-qualified field
    names. In the case of qualified fields, we search directly the base
    tables of a natural join.

unknown's avatar
unknown committed
2902
  RETURN
2903 2904 2905
    NULL        if the field was not found
    WRONG_GRANT if no access rights to the found field
    #           Pointer to the found Field
unknown's avatar
unknown committed
2906 2907 2908 2909
*/

static Field *
find_field_in_natural_join(THD *thd, TABLE_LIST *table_ref, const char *name,
2910
                           uint length, Item **ref, bool register_tree_change,
2911
                           TABLE_LIST **actual_table)
unknown's avatar
unknown committed
2912
{
2913 2914 2915 2916
  List_iterator_fast<Natural_join_column>
    field_it(*(table_ref->join_columns));
  Natural_join_column *nj_col;
  Field *found_field;
2917
  Query_arena *arena, backup;
unknown's avatar
unknown committed
2918
  DBUG_ENTER("find_field_in_natural_join");
2919
  DBUG_PRINT("enter", ("field name: '%s', ref 0x%lx",
unknown's avatar
unknown committed
2920 2921
		       name, (ulong) ref));
  DBUG_ASSERT(table_ref->is_natural_join && table_ref->join_columns);
2922
  DBUG_ASSERT(*actual_table == NULL);
unknown's avatar
unknown committed
2923

2924
  LINT_INIT(found_field);
unknown's avatar
unknown committed
2925

2926
  for (;;)
unknown's avatar
unknown committed
2927
  {
2928 2929 2930
    if (!(nj_col= field_it++))
      DBUG_RETURN(NULL);

unknown's avatar
unknown committed
2931 2932
    if (!my_strcasecmp(system_charset_info, nj_col->name(), name))
      break;
unknown's avatar
VIEW  
unknown committed
2933
  }
unknown's avatar
unknown committed
2934 2935 2936

  if (nj_col->view_field)
  {
unknown's avatar
unknown committed
2937
    Item *item;
2938 2939
    if (register_tree_change)
      arena= thd->activate_stmt_arena_if_needed(&backup);
2940 2941 2942 2943
    /*
      create_item() may, or may not create a new Item, depending on the
      column reference. See create_view_field() for details.
    */
unknown's avatar
unknown committed
2944
    item= nj_col->create_item(thd);
2945 2946 2947
    if (register_tree_change && arena)
      thd->restore_active_arena(arena, &backup);

unknown's avatar
unknown committed
2948 2949 2950 2951
    if (!item)
      DBUG_RETURN(NULL);
    DBUG_ASSERT(nj_col->table_field == NULL);
    if (nj_col->table_ref->schema_table_reformed)
2952
    {
unknown's avatar
unknown committed
2953 2954 2955 2956 2957 2958
      /*
        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);
2959
    }
unknown's avatar
unknown committed
2960 2961 2962 2963 2964 2965 2966 2967 2968 2969
    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);
2970
    DBUG_ASSERT(nj_col->table_ref->table == nj_col->table_field->table);
unknown's avatar
unknown committed
2971 2972 2973 2974 2975 2976 2977
    found_field= nj_col->table_field;
    update_field_dependencies(thd, found_field, nj_col->table_ref->table);
  }

  *actual_table= nj_col->table_ref;
  
  DBUG_RETURN(found_field);
unknown's avatar
VIEW  
unknown committed
2978 2979
}

2980

unknown's avatar
VIEW  
unknown committed
2981
/*
unknown's avatar
unknown committed
2982
  Find field by name in a base table or a view with temp table algorithm.
unknown's avatar
VIEW  
unknown committed
2983 2984

  SYNOPSIS
unknown's avatar
unknown committed
2985
    find_field_in_table()
unknown's avatar
VIEW  
unknown committed
2986
    thd				thread handler
unknown's avatar
unknown committed
2987
    table			table where to search for the field
unknown's avatar
VIEW  
unknown committed
2988 2989 2990
    name			name of field
    length			length of name
    allow_rowid			do allow finding of "_rowid" field?
unknown's avatar
unknown committed
2991 2992
    cached_field_index_ptr	cached position in field list (used to speedup
                                lookup for fields in prepared tables)
unknown's avatar
VIEW  
unknown committed
2993 2994

  RETURN
2995 2996
    0	field is not found
    #	pointer to field
unknown's avatar
VIEW  
unknown committed
2997 2998
*/

unknown's avatar
unknown committed
2999 3000
Field *
find_field_in_table(THD *thd, TABLE *table, const char *name, uint length,
3001
                    bool allow_rowid, uint *cached_field_index_ptr)
unknown's avatar
unknown committed
3002
{
unknown's avatar
unknown committed
3003 3004
  Field **field_ptr, *field;
  uint cached_field_index= *cached_field_index_ptr;
3005 3006
  DBUG_ENTER("find_field_in_table");
  DBUG_PRINT("enter", ("table: '%s', field name: '%s'", table->alias, name));
unknown's avatar
unknown committed
3007 3008

  /* We assume here that table->field < NO_CACHED_FIELD_INDEX = UINT_MAX */
3009
  if (cached_field_index < table->s->fields &&
3010
      !my_strcasecmp(system_charset_info,
unknown's avatar
unknown committed
3011 3012
                     table->field[cached_field_index]->field_name, name))
    field_ptr= table->field + cached_field_index;
3013 3014 3015
  else if (table->s->name_hash.records)
    field_ptr= (Field**) hash_search(&table->s->name_hash, (byte*) name,
                                     length);
unknown's avatar
unknown committed
3016 3017 3018
  else
  {
    if (!(field_ptr= table->field))
unknown's avatar
unknown committed
3019
      DBUG_RETURN((Field *)0);
unknown's avatar
unknown committed
3020 3021 3022 3023 3024 3025
    for (; *field_ptr; ++field_ptr)
      if (!my_strcasecmp(system_charset_info, (*field_ptr)->field_name, name))
        break;
  }

  if (field_ptr && *field_ptr)
unknown's avatar
unknown committed
3026
  {
unknown's avatar
unknown committed
3027 3028
    *cached_field_index_ptr= field_ptr - table->field;
    field= *field_ptr;
unknown's avatar
unknown committed
3029 3030 3031
  }
  else
  {
unknown's avatar
unknown committed
3032 3033 3034
    if (!allow_rowid ||
        my_strcasecmp(system_charset_info, name, "_rowid") ||
        !(field=table->rowid_field))
unknown's avatar
unknown committed
3035
      DBUG_RETURN((Field*) 0);
unknown's avatar
unknown committed
3036 3037
  }

unknown's avatar
unknown committed
3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051
  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
3052
    length		   [in]  field length of name
unknown's avatar
unknown committed
3053 3054
    item_name              [in]  name of item if it will be created (VIEW)
    db_name                [in]  optional database name that qualifies the
3055
    table_name             [in]  optional table name that qualifies the field
unknown's avatar
unknown committed
3056 3057
    ref		       [in/out] if 'name' is resolved to a view field, ref
                                 is set to point to the found view field
3058
    check_privileges       [in]  check privileges
unknown's avatar
unknown committed
3059 3060 3061 3062 3063 3064 3065 3066 3067
    allow_rowid		   [in]  do allow finding of "_rowid" field?
    cached_field_index_ptr [in]  cached position in field list (used to
                                 speedup lookup for fields in prepared tables)
    register_tree_change   [in]  TRUE if ref is not stack variable and we
                                 need register changes in item tree
    actual_table           [out] the original table reference where the field
                                 belongs - differs from 'table_list' only for
                                 NATURAL_USING joins.

unknown's avatar
unknown committed
3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079
  DESCRIPTION
    Find a field in a table reference depending on the type of table
    reference. There are three types of table references with respect
    to the representation of their result columns:
    - an array of Field_translator objects for MERGE views and some
      information_schema tables,
    - an array of Field objects (and possibly a name hash) for stored
      tables,
    - a list of Natural_join_column objects for NATURAL/USING joins.
    This procedure detects the type of the table reference 'table_list'
    and calls the corresponding search routine.

unknown's avatar
unknown committed
3080 3081 3082 3083 3084 3085 3086 3087
  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,
3088 3089 3090
                        const char *name, uint length,
                        const char *item_name, const char *db_name,
                        const char *table_name, Item **ref,
3091 3092
                        bool check_privileges, bool allow_rowid,
                        uint *cached_field_index_ptr,
unknown's avatar
unknown committed
3093 3094 3095 3096 3097 3098 3099 3100 3101 3102
                        bool register_tree_change, TABLE_LIST **actual_table)
{
  Field *fld;
  DBUG_ENTER("find_field_in_table_ref");
  DBUG_PRINT("enter",
             ("table: '%s'  field name: '%s'  item name: '%s'  ref 0x%lx",
              table_list->alias, name, item_name, (ulong) ref));

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

3105 3106 3107 3108
    Exclude from the test below nested joins because the columns in a
    nested join generally originate from different tables. Nested joins
    also have no table name, except when a nested join is a merge view
    or an information schema table.
unknown's avatar
unknown committed
3109 3110 3111 3112 3113 3114

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

3115 3116
    TODO: Ensure that table_name, db_name and tables->db always points to
          something !
unknown's avatar
unknown committed
3117
  */
3118 3119
  if (/* Exclude nested joins. */
      (!table_list->nested_join ||
unknown's avatar
unknown committed
3120 3121 3122 3123 3124 3125
       /* Include merge views and information schema tables. */
       table_list->field_translation) &&
      /*
        Test if the field qualifiers match the table reference we plan
        to search.
      */
3126 3127
      table_name && table_name[0] &&
      (my_strcasecmp(table_alias_charset, table_list->alias, table_name) ||
unknown's avatar
unknown committed
3128 3129 3130 3131
       (db_name && db_name[0] && table_list->db && table_list->db[0] &&
        strcmp(db_name, table_list->db))))
    DBUG_RETURN(0);

3132
  *actual_table= NULL;
unknown's avatar
unknown committed
3133

unknown's avatar
unknown committed
3134 3135
  if (table_list->field_translation)
  {
unknown's avatar
unknown committed
3136
    /* 'table_list' is a view or an information schema table. */
3137
    if ((fld= find_field_in_view(thd, table_list, name, length, item_name, ref,
3138
                                 register_tree_change)))
unknown's avatar
unknown committed
3139 3140
      *actual_table= table_list;
  }
3141
  else if (!table_list->nested_join)
3142
  {
3143 3144
    /* 'table_list' is a stored table. */
    DBUG_ASSERT(table_list->table);
unknown's avatar
unknown committed
3145
    if ((fld= find_field_in_table(thd, table_list->table, name, length,
3146 3147
                                  allow_rowid,
                                  cached_field_index_ptr)))
unknown's avatar
unknown committed
3148 3149 3150 3151 3152 3153 3154 3155 3156 3157
      *actual_table= table_list;
  }
  else
  {
    /*
      'table_list' is a NATURAL/USING join, or an operand of such join that
      is a nested join itself.

      If the field name we search for is qualified, then search for the field
      in the table references used by NATURAL/USING the join.
unknown's avatar
unknown committed
3158
    */
3159 3160 3161 3162 3163 3164
    if (table_name && table_name[0])
    {
      List_iterator<TABLE_LIST> it(table_list->nested_join->join_list);
      TABLE_LIST *table;
      while ((table= it++))
      {
3165 3166
        if ((fld= find_field_in_table_ref(thd, table, name, length, item_name,
                                          db_name, table_name, ref,
3167 3168
                                          check_privileges, allow_rowid,
                                          cached_field_index_ptr,
3169 3170 3171 3172 3173 3174 3175
                                          register_tree_change, actual_table)))
          DBUG_RETURN(fld);
      }
      DBUG_RETURN(0);
    }
    /*
      Non-qualified field, search directly in the result columns of the
unknown's avatar
unknown committed
3176 3177 3178
      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.
3179 3180
    */
    fld= find_field_in_natural_join(thd, table_list, name, length, ref,
unknown's avatar
unknown committed
3181
                                    register_tree_change, actual_table);
3182
  }
unknown's avatar
unknown committed
3183

3184 3185 3186 3187 3188 3189 3190
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  /* Check if there are sufficient access rights to the found field. */
  if (fld && check_privileges &&
      check_column_grant_in_table_ref(thd, *actual_table, name, length))
    fld= WRONG_GRANT;
#endif

unknown's avatar
unknown committed
3191
  DBUG_RETURN(fld);
unknown's avatar
unknown committed
3192 3193
}

3194

3195 3196 3197 3198 3199
/*
  Find field in table list.

  SYNOPSIS
    find_field_in_tables()
unknown's avatar
unknown committed
3200 3201 3202 3203 3204 3205
    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
3206
                          point to the found view field
unknown's avatar
unknown committed
3207
    report_error	  Degree of error reporting:
3208 3209
                          - IGNORE_ERRORS then do not report any error
                          - IGNORE_EXCEPT_NON_UNIQUE report only non-unique
unknown's avatar
unknown committed
3210
                            fields, suppress all other errors
3211 3212 3213 3214
                          - REPORT_EXCEPT_NON_UNIQUE report all other errors
                            except when non-unique fields were found
                          - REPORT_ALL_ERRORS
    check_privileges      need to check privileges
unknown's avatar
unknown committed
3215 3216
    register_tree_change  TRUE if ref is not a stack variable and we
                          to need register changes in item tree
3217 3218

  RETURN VALUES
3219 3220 3221
    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.
3222 3223 3224 3225 3226
    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
3227
*/
unknown's avatar
unknown committed
3228 3229

Field *
unknown's avatar
unknown committed
3230 3231
find_field_in_tables(THD *thd, Item_ident *item,
                     TABLE_LIST *first_table, TABLE_LIST *last_table,
3232
		     Item **ref, find_item_error_report_type report_error,
3233
                     bool check_privileges, bool register_tree_change)
unknown's avatar
unknown committed
3234 3235
{
  Field *found=0;
unknown's avatar
unknown committed
3236 3237 3238
  const char *db= item->db_name;
  const char *table_name= item->table_name;
  const char *name= item->field_name;
unknown's avatar
unknown committed
3239
  uint length=(uint) strlen(name);
3240
  char name_buff[NAME_LEN+1];
unknown's avatar
unknown committed
3241 3242
  TABLE_LIST *cur_table= first_table;
  TABLE_LIST *actual_table;
unknown's avatar
unknown committed
3243 3244 3245 3246 3247 3248 3249 3250 3251
  bool allow_rowid;

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

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

unknown's avatar
unknown committed
3253 3254 3255
  if (item->cached_table)
  {
    /*
unknown's avatar
unknown committed
3256 3257
      This shortcut is used by prepared statements. We assume that
      TABLE_LIST *first_table is not changed during query execution (which
3258
      is true for all queries except RENAME but luckily RENAME doesn't
unknown's avatar
unknown committed
3259
      use fields...) so we can rely on reusing pointer to its member.
unknown's avatar
unknown committed
3260
      With this optimization we also miss case when addition of one more
3261
      field makes some prepared query ambiguous and so erroneous, but we
unknown's avatar
unknown committed
3262 3263
      accept this trade off.
    */
unknown's avatar
unknown committed
3264 3265 3266 3267 3268 3269 3270 3271
    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,
3272
                                 TRUE, &(item->cached_field_index));
3273
    else
3274
      found= find_field_in_table_ref(thd, table_ref, name, length, item->name,
3275 3276
                                     NULL, NULL, ref, check_privileges,
                                     TRUE, &(item->cached_field_index),
unknown's avatar
unknown committed
3277 3278
                                     register_tree_change,
                                     &actual_table);
unknown's avatar
unknown committed
3279 3280 3281
    if (found)
    {
      if (found == WRONG_GRANT)
3282
	return (Field*) 0;
3283 3284
      {
        SELECT_LEX *current_sel= thd->lex->current_select;
unknown's avatar
unknown committed
3285
        SELECT_LEX *last_select= table_ref->select_lex;
unknown's avatar
unknown committed
3286 3287
        /*
          If the field was an outer referencee, mark all selects using this
unknown's avatar
unknown committed
3288
          sub query as dependent on the outer query
unknown's avatar
unknown committed
3289
        */
3290
        if (current_sel != last_select)
unknown's avatar
unknown committed
3291
          mark_select_range_as_dependent(thd, last_select, current_sel,
3292 3293
                                         found, *ref, item);
      }
unknown's avatar
unknown committed
3294 3295 3296 3297
      return found;
    }
  }

3298 3299 3300
  if (db && lower_case_table_names)
  {
    /*
unknown's avatar
unknown committed
3301
      convert database to lower case for comparison.
3302 3303 3304 3305
      We can't do this in Item_field as this would change the
      'name' of the item which may be used in the select list
    */
    strmake(name_buff, db, sizeof(name_buff)-1);
unknown's avatar
unknown committed
3306
    my_casedn_str(files_charset_info, name_buff);
3307 3308
    db= name_buff;
  }
unknown's avatar
unknown committed
3309

3310 3311 3312 3313 3314
  if (last_table)
    last_table= last_table->next_name_resolution_table;

  for (; cur_table != last_table ;
       cur_table= cur_table->next_name_resolution_table)
unknown's avatar
unknown committed
3315
  {
3316 3317
    Field *cur_field= find_field_in_table_ref(thd, cur_table, name, length,
                                              item->name, db, table_name, ref,
3318
                                              check_privileges, allow_rowid,
unknown's avatar
unknown committed
3319 3320 3321 3322
                                              &(item->cached_field_index),
                                              register_tree_change,
                                              &actual_table);
    if (cur_field)
3323
    {
unknown's avatar
unknown committed
3324
      if (cur_field == WRONG_GRANT)
unknown's avatar
unknown committed
3325
	return (Field*) 0;
unknown's avatar
unknown committed
3326 3327 3328 3329 3330 3331 3332 3333

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

3334 3335 3336 3337 3338
      DBUG_ASSERT(thd->where);
      /*
        If we found a fully qualified field we return it directly as it can't
        have duplicates.
       */
unknown's avatar
unknown committed
3339
      if (db)
3340 3341
        return cur_field;

unknown's avatar
unknown committed
3342 3343
      if (found)
      {
3344 3345
        if (report_error == REPORT_ALL_ERRORS ||
            report_error == IGNORE_EXCEPT_NON_UNIQUE)
3346
          my_error(ER_NON_UNIQ_ERROR, MYF(0),
unknown's avatar
unknown committed
3347
                   table_name ? item->full_name() : name, thd->where);
unknown's avatar
unknown committed
3348 3349
	return (Field*) 0;
      }
unknown's avatar
unknown committed
3350
      found= cur_field;
unknown's avatar
unknown committed
3351 3352
    }
  }
3353

unknown's avatar
unknown committed
3354 3355
  if (found)
    return found;
3356 3357 3358 3359 3360 3361 3362 3363

  /*
    If the field was qualified and there were no tables to search, issue
    an error that an unknown table was given. The situation is detected
    as follows: if there were no tables we wouldn't go through the loop
    and cur_table wouldn't be updated by the loop increment part, so it
    will be equal to the first table.
  */
unknown's avatar
unknown committed
3364
  if (table_name && (cur_table == first_table) &&
3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375
      (report_error == REPORT_ALL_ERRORS ||
       report_error == REPORT_EXCEPT_NON_UNIQUE))
  {
    char buff[NAME_LEN*2+1];
    if (db && db[0])
    {
      strxnmov(buff,sizeof(buff)-1,db,".",table_name,NullS);
      table_name=buff;
    }
    my_error(ER_UNKNOWN_TABLE, MYF(0), table_name, thd->where);
  }
3376
  else
unknown's avatar
unknown committed
3377
  {
3378 3379 3380 3381 3382
    if (report_error == REPORT_ALL_ERRORS ||
        report_error == REPORT_EXCEPT_NON_UNIQUE)
      my_error(ER_BAD_FIELD_ERROR, MYF(0), item->full_name(), thd->where);
    else
      found= not_found_field;
unknown's avatar
unknown committed
3383
  }
3384
  return found;
unknown's avatar
unknown committed
3385 3386
}

3387 3388 3389

/*
  Find Item in list of items (find_field_in_tables analog)
3390 3391 3392 3393

  TODO
    is it better return only counter?

3394 3395
  SYNOPSIS
    find_item_in_list()
3396 3397 3398
    find			Item to find
    items			List of items
    counter			To return number of found item
3399
    report_error
3400 3401 3402 3403 3404
      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
3405 3406 3407 3408
    unaliased                   Set to true if item is field which was found
                                by original field name and not by its alias
                                in item list. Set to false otherwise.

3409
  RETURN VALUES
3410 3411 3412 3413 3414
    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
3415
                        found field
3416 3417
*/

3418
/* Special Item pointer to serve as a return value from find_item_in_list(). */
unknown's avatar
unknown committed
3419
Item **not_found_item= (Item**) 0x1;
3420 3421


unknown's avatar
unknown committed
3422
Item **
3423
find_item_in_list(Item *find, List<Item> &items, uint *counter,
3424
                  find_item_error_report_type report_error, bool *unaliased)
unknown's avatar
unknown committed
3425 3426
{
  List_iterator<Item> li(items);
3427
  Item **found=0, **found_unaliased= 0, *item;
3428
  const char *db_name=0;
unknown's avatar
unknown committed
3429 3430
  const char *field_name=0;
  const char *table_name=0;
3431 3432
  bool found_unaliased_non_uniq= 0;
  uint unaliased_counter;
3433

3434 3435
  LINT_INIT(unaliased_counter);                 // Dependent on found_unaliased

3436 3437
  *unaliased= FALSE;

unknown's avatar
unknown committed
3438 3439 3440 3441
  if (find->type() == Item::FIELD_ITEM	|| find->type() == Item::REF_ITEM)
  {
    field_name= ((Item_ident*) find)->field_name;
    table_name= ((Item_ident*) find)->table_name;
3442
    db_name=    ((Item_ident*) find)->db_name;
unknown's avatar
unknown committed
3443 3444
  }

3445
  for (uint i= 0; (item=li++); i++)
unknown's avatar
unknown committed
3446
  {
3447
    if (field_name && item->real_item()->type() == Item::FIELD_ITEM)
unknown's avatar
unknown committed
3448
    {
3449
      Item_ident *item_field= (Item_ident*) item;
3450

unknown's avatar
unknown committed
3451 3452 3453 3454 3455 3456
      /*
	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
      */ 
3457 3458 3459 3460
      if (!item_field->name)
        continue;

      if (table_name)
unknown's avatar
unknown committed
3461
      {
3462 3463 3464
        /*
          If table name is specified we should find field 'field_name' in
          table 'table_name'. According to SQL-standard we should ignore
3465 3466 3467 3468 3469
          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.
3470

3471
          We use strcmp for table names and database names as these may be
3472 3473
          case sensitive. In cases where they are not case sensitive, they
          are always in lower case.
3474 3475

	  item_field->field_name and item_field->table_name can be 0x0 if
3476
	  item is not fix_field()'ed yet.
3477
        */
3478 3479
        if (item_field->field_name && item_field->table_name &&
	    !my_strcasecmp(system_charset_info, item_field->field_name,
3480 3481 3482 3483 3484
                           field_name) &&
            !strcmp(item_field->table_name, table_name) &&
            (!db_name || (item_field->db_name &&
                          !strcmp(item_field->db_name, db_name))))
        {
3485
          if (found_unaliased)
3486
          {
3487 3488 3489 3490 3491 3492 3493
            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.
            */
3494
            if (report_error != IGNORE_ERRORS)
3495 3496
              my_error(ER_NON_UNIQ_ERROR, MYF(0),
                       find->full_name(), current_thd->where);
3497 3498
            return (Item**) 0;
          }
3499 3500
          found_unaliased= li.ref();
          unaliased_counter= i;
3501 3502
          if (db_name)
            break;                              // Perfect match
3503 3504 3505
        }
      }
      else if (!my_strcasecmp(system_charset_info, item_field->name,
3506
                              field_name))
3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519
      {
        /*
          If table name was not given we should scan through aliases
          (or non-aliased fields) first. We are also checking unaliased
          name of the field in then next else-if, to be able to find
          instantly field (hidden by alias) if no suitable alias (or
          non-aliased field) was found.
        */
        if (found)
        {
          if ((*found)->eq(item, 0))
            continue;                           // Same field twice
          if (report_error != IGNORE_ERRORS)
3520 3521
            my_error(ER_NON_UNIQ_ERROR, MYF(0),
                     find->full_name(), current_thd->where);
3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546
          return (Item**) 0;
        }
        found= li.ref();
        *counter= i;
      }
      else if (!my_strcasecmp(system_charset_info, item_field->field_name,
                              field_name))
      {
        /*
          We will use un-aliased field or react on such ambiguities only if
          we won't be able to find aliased field.
          Again if we have ambiguity with field outside of select list
          we should prefer fields from select list.
        */
        if (found_unaliased)
        {
          if ((*found_unaliased)->eq(item, 0))
            continue;                           // Same field twice
          found_unaliased_non_uniq= 1;
        }
        else
        {
          found_unaliased= li.ref();
          unaliased_counter= i;
        }
unknown's avatar
unknown committed
3547 3548
      }
    }
unknown's avatar
unknown committed
3549
    else if (!table_name && (find->eq(item,0) ||
3550
			     find->name && item->name &&
3551 3552
			     !my_strcasecmp(system_charset_info, 
					    item->name,find->name)))
unknown's avatar
unknown committed
3553
    {
3554 3555
      found= li.ref();
      *counter= i;
unknown's avatar
unknown committed
3556 3557 3558
      break;
    }
  }
3559 3560 3561 3562 3563
  if (!found)
  {
    if (found_unaliased_non_uniq)
    {
      if (report_error != IGNORE_ERRORS)
3564 3565
        my_error(ER_NON_UNIQ_ERROR, MYF(0),
                 find->full_name(), current_thd->where);
3566 3567 3568 3569 3570 3571
      return (Item **) 0;
    }
    if (found_unaliased)
    {
      found= found_unaliased;
      *counter= unaliased_counter;
3572
      *unaliased= TRUE;
3573 3574
    }
  }
3575 3576
  if (found)
    return found;
3577
  if (report_error != REPORT_EXCEPT_NOT_FOUND)
3578 3579
  {
    if (report_error == REPORT_ALL_ERRORS)
3580 3581
      my_error(ER_BAD_FIELD_ERROR, MYF(0),
               find->full_name(), current_thd->where);
3582 3583 3584 3585
    return (Item **) 0;
  }
  else
    return (Item **) not_found_item;
unknown's avatar
unknown committed
3586 3587
}

unknown's avatar
unknown committed
3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615

/*
  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;
3616
    if (!my_strcasecmp(system_charset_info, find, curr_str->ptr()))
unknown's avatar
unknown committed
3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637
      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
3638 3639
    FALSE  if all OK
    TRUE   otherwise
unknown's avatar
unknown committed
3640 3641 3642 3643 3644 3645
*/

static bool
set_new_item_local_context(THD *thd, Item_ident *item, TABLE_LIST *table_ref)
{
  Name_resolution_context *context;
3646
  if (!(context= new (thd->mem_root) Name_resolution_context))
unknown's avatar
unknown committed
3647 3648
    return TRUE;
  context->init();
3649 3650
  context->first_name_resolution_table=
    context->last_name_resolution_table= table_ref;
unknown's avatar
unknown committed
3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682
  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
3683 3684
    TRUE   error when some common column is non-unique, or out of memory
    FALSE  OK
unknown's avatar
unknown committed
3685 3686 3687 3688 3689 3690 3691 3692 3693 3694
*/

static bool
mark_common_columns(THD *thd, TABLE_LIST *table_ref_1, TABLE_LIST *table_ref_2,
                    List<String> *using_fields, uint *found_using_fields)
{
  Field_iterator_table_ref it_1, it_2;
  Natural_join_column *nj_col_1, *nj_col_2;
  Query_arena *arena, backup;
  bool result= TRUE;
unknown's avatar
unknown committed
3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705
  bool first_outer_loop= TRUE;
  /*
    Leaf table references to which new natural join columns are added
    if the leaves are != NULL.
  */
  TABLE_LIST *leaf_1= (table_ref_1->nested_join &&
                       !table_ref_1->is_natural_join) ?
                      NULL : table_ref_1;
  TABLE_LIST *leaf_2= (table_ref_2->nested_join &&
                       !table_ref_2->is_natural_join) ?
                      NULL : table_ref_2;
unknown's avatar
unknown committed
3706 3707

  DBUG_ENTER("mark_common_columns");
3708
  DBUG_PRINT("info", ("operand_1: %s  operand_2: %s",
unknown's avatar
unknown committed
3709 3710
                      table_ref_1->alias, table_ref_2->alias));

3711
  *found_using_fields= 0;
unknown's avatar
unknown committed
3712
  arena= thd->activate_stmt_arena_if_needed(&backup);
unknown's avatar
unknown committed
3713 3714 3715

  for (it_1.set(table_ref_1); !it_1.end_of_fields(); it_1.next())
  {
3716
    bool found= FALSE;
unknown's avatar
unknown committed
3717
    const char *field_name_1;
unknown's avatar
unknown committed
3718
    if (!(nj_col_1= it_1.get_or_create_column_ref(leaf_1)))
unknown's avatar
unknown committed
3719 3720 3721
      goto err;
    field_name_1= nj_col_1->name();

3722 3723 3724 3725 3726 3727 3728
    /*
      Find a field with the same name in table_ref_2.

      Note that for the second loop, it_2.set() will iterate over
      table_ref_2->join_columns and not generate any new elements or
      lists.
    */
unknown's avatar
unknown committed
3729 3730 3731 3732
    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;
3733
      const char *cur_field_name_2;
unknown's avatar
unknown committed
3734
      if (!(cur_nj_col_2= it_2.get_or_create_column_ref(leaf_2)))
unknown's avatar
unknown committed
3735
        goto err;
3736
      cur_field_name_2= cur_nj_col_2->name();
unknown's avatar
unknown committed
3737

unknown's avatar
unknown committed
3738 3739 3740 3741 3742 3743 3744
      /*
        Compare the two columns and check for duplicate common fields.
        A common field is duplicate either if it was already found in
        table_ref_2 (then found == TRUE), or if a field in table_ref_2
        was already matched by some previous field in table_ref_1
        (then cur_nj_col_2->is_common == TRUE).
      */
unknown's avatar
unknown committed
3745 3746
      if (!my_strcasecmp(system_charset_info, field_name_1, cur_field_name_2))
      {
unknown's avatar
unknown committed
3747
        if (found || cur_nj_col_2->is_common)
unknown's avatar
unknown committed
3748 3749 3750 3751 3752 3753 3754 3755
        {
          my_error(ER_NON_UNIQ_ERROR, MYF(0), field_name_1, thd->where);
          goto err;
        }
        nj_col_2= cur_nj_col_2;
        found= TRUE;
      }
    }
unknown's avatar
unknown committed
3756 3757 3758 3759 3760 3761 3762 3763 3764
    if (first_outer_loop && leaf_2)
    {
      /*
        Make sure that the next inner loop "knows" that all columns
        are materialized already.
      */
      leaf_2->is_join_columns_complete= TRUE;
      first_outer_loop= FALSE;
    }
unknown's avatar
unknown committed
3765
    if (!found)
3766
      continue;                                 // No matching field
unknown's avatar
unknown committed
3767 3768 3769 3770 3771 3772 3773 3774

    /*
      field_1 and field_2 have the same names. Check if they are in the USING
      clause (if present), mark them as common fields, and add a new
      equi-join condition to the ON clause.
    */
    if (nj_col_2 &&
        (!using_fields ||
3775
          test_if_string_in_list(field_name_1, using_fields)))
unknown's avatar
unknown committed
3776 3777 3778 3779 3780 3781
    {
      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;
3782 3783 3784 3785 3786
      Item_func_eq *eq_cond;

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

unknown's avatar
unknown committed
3787
      /*
3788
        The following assert checks that the two created items are of
unknown's avatar
unknown committed
3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812
        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.
      */
3813 3814
      if (set_new_item_local_context(thd, item_ident_1, nj_col_1->table_ref) ||
          set_new_item_local_context(thd, item_ident_2, nj_col_2->table_ref))
unknown's avatar
unknown committed
3815 3816
        goto err;

3817 3818
      if (!(eq_cond= new Item_func_eq(item_ident_1, item_ident_2)))
        goto err;                               /* Out of memory. */
unknown's avatar
unknown committed
3819 3820 3821 3822 3823 3824

      /*
        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.
       */
3825 3826 3827
      add_join_on((table_ref_1->outer_join & JOIN_TYPE_RIGHT ?
                   table_ref_1 : table_ref_2),
                  eq_cond);
unknown's avatar
unknown committed
3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847

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

      if (field_1)
      {
        /* Mark field_1 used for table cache. */
        field_1->query_id= thd->query_id;
        nj_col_1->table_ref->table->used_keys.intersect(field_1->part_of_key);
      }
      if (field_2)
      {
        /* Mark field_2 used for table cache. */
        field_2->query_id= thd->query_id;
        nj_col_2->table_ref->table->used_keys.intersect(field_2->part_of_key);
      }

      if (using_fields != NULL)
        ++(*found_using_fields);
    }
  }
unknown's avatar
unknown committed
3848 3849
  if (leaf_1)
    leaf_1->is_join_columns_complete= TRUE;
unknown's avatar
unknown committed
3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861

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

err:
  if (arena)
unknown's avatar
unknown committed
3862
    thd->restore_active_arena(arena, &backup);
unknown's avatar
unknown committed
3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898
  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
3899 3900
    TRUE    error: Some common column is ambiguous
    FALSE   OK
unknown's avatar
unknown committed
3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913
*/

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;
3914
  List<Natural_join_column> *non_join_columns;
unknown's avatar
unknown committed
3915 3916
  DBUG_ENTER("store_natural_using_join_columns");

3917 3918
  DBUG_ASSERT(!natural_using_join->join_columns);

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

3921 3922
  if (!(non_join_columns= new List<Natural_join_column>) ||
      !(natural_using_join->join_columns= new List<Natural_join_column>))
unknown's avatar
unknown committed
3923 3924 3925 3926 3927
    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())
  {
3928
    nj_col_1= it_1.get_natural_column_ref();
unknown's avatar
unknown committed
3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949
    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++))
    {
3950
      const char *using_field_name_ptr= using_field_name->c_ptr();
unknown's avatar
unknown committed
3951 3952 3953
      List_iterator_fast<Natural_join_column>
        it(*(natural_using_join->join_columns));
      Natural_join_column *common_field;
3954 3955

      for (;;)
unknown's avatar
unknown committed
3956
      {
3957 3958 3959 3960 3961 3962 3963
        /* If reached the end of fields, and none was found, report error. */
        if (!(common_field= it++))
        {
          my_error(ER_BAD_FIELD_ERROR, MYF(0), using_field_name_ptr,
                   current_thd->where);
          goto err;
        }
unknown's avatar
unknown committed
3964 3965
        if (!my_strcasecmp(system_charset_info,
                           common_field->name(), using_field_name_ptr))
3966
          break;                                // Found match
unknown's avatar
unknown committed
3967 3968 3969 3970 3971 3972 3973
      }
    }
  }

  /* 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())
  {
3974
    nj_col_2= it_2.get_natural_column_ref();
unknown's avatar
unknown committed
3975 3976 3977
    if (!nj_col_2->is_common)
      non_join_columns->push_back(nj_col_2);
    else
3978
    {
unknown's avatar
unknown committed
3979 3980
      /* Reset the common columns for the next call to mark_common_columns. */
      nj_col_2->is_common= FALSE;
3981
    }
unknown's avatar
unknown committed
3982 3983 3984 3985 3986 3987 3988 3989 3990 3991
  }

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

  result= FALSE;

err:
  if (arena)
unknown's avatar
unknown committed
3992
    thd->restore_active_arena(arena, &backup);
unknown's avatar
unknown committed
3993 3994 3995
  DBUG_RETURN(result);
}

3996

unknown's avatar
unknown committed
3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022
/*
  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
4023 4024
    TRUE   Error
    FALSE  OK
unknown's avatar
unknown committed
4025 4026 4027 4028 4029 4030 4031
*/

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

unknown's avatar
unknown committed
4035
  DBUG_ENTER("store_top_level_join_columns");
4036

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

unknown's avatar
unknown committed
4039 4040 4041 4042 4043 4044
  /* Call the procedure recursively for each nested table reference. */
  if (table_ref->nested_join)
  {
    List_iterator_fast<TABLE_LIST> nested_it(table_ref->nested_join->join_list);
    TABLE_LIST *cur_left_neighbor= nested_it++;
    TABLE_LIST *cur_right_neighbor= NULL;
4045

unknown's avatar
unknown committed
4046 4047
    while (cur_left_neighbor)
    {
4048
      TABLE_LIST *cur_table_ref= cur_left_neighbor;
unknown's avatar
unknown committed
4049
      cur_left_neighbor= nested_it++;
4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070
      /*
        The order of RIGHT JOIN operands is reversed in 'join list' to
        transform it into a LEFT JOIN. However, in this procedure we need
        the join operands in their lexical order, so below we reverse the
        join operands. Notice that this happens only in the first loop, and
        not in the second one, as in the second loop cur_left_neighbor == NULL.
        This is the correct behavior, because the second loop
        sets cur_table_ref reference correctly after the join operands are
        swapped in the first loop.
      */
      if (cur_left_neighbor &&
          cur_table_ref->outer_join & JOIN_TYPE_RIGHT)
      {
        /* This can happen only for JOIN ... ON. */
        DBUG_ASSERT(table_ref->nested_join->join_list.elements == 2);
        swap_variables(TABLE_LIST*, cur_left_neighbor, cur_table_ref);
      }

      if (cur_table_ref->nested_join &&
          store_top_level_join_columns(thd, cur_table_ref,
                                       cur_left_neighbor, cur_right_neighbor))
unknown's avatar
unknown committed
4071
        goto err;
4072
      cur_right_neighbor= cur_table_ref;
unknown's avatar
unknown committed
4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102
    }
  }

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

    /*
      The two join operands were interchanged in the parser, change the order
      back for 'mark_common_columns'.
    */
    if (table_ref_2->outer_join & JOIN_TYPE_RIGHT)
      swap_variables(TABLE_LIST*, table_ref_1, table_ref_2);
    if (mark_common_columns(thd, table_ref_1, table_ref_2,
                            using_fields, &found_using_fields))
unknown's avatar
unknown committed
4103
      goto err;
unknown's avatar
unknown committed
4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114

    /*
      Swap the join operands back, so that we pick the columns of the second
      one as the coalesced columns. In this way the coalesced columns are the
      same as of an equivalent LEFT JOIN.
    */
    if (table_ref_1->outer_join & JOIN_TYPE_RIGHT)
      swap_variables(TABLE_LIST*, table_ref_1, table_ref_2);
    if (store_natural_using_join_columns(thd, table_ref, table_ref_1,
                                         table_ref_2, using_fields,
                                         found_using_fields))
unknown's avatar
unknown committed
4115
      goto err;
unknown's avatar
unknown committed
4116 4117 4118 4119 4120 4121 4122 4123 4124

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

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

unknown's avatar
unknown committed
4130 4131 4132
    /* Change this table reference to become a leaf for name resolution. */
    if (left_neighbor)
    {
4133
      TABLE_LIST *last_leaf_on_the_left;
unknown's avatar
unknown committed
4134 4135 4136 4137 4138
      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)
    {
4139
      TABLE_LIST *first_leaf_on_the_right;
unknown's avatar
unknown committed
4140 4141 4142 4143 4144 4145
      first_leaf_on_the_right= right_neighbor->first_leaf_for_name_resolution();
      table_ref->next_name_resolution_table= first_leaf_on_the_right;
    }
    else
      table_ref->next_name_resolution_table= NULL;
  }
unknown's avatar
unknown committed
4146 4147 4148 4149
  result= FALSE; /* All is OK. */

err:
  if (arena)
unknown's avatar
unknown committed
4150
    thd->restore_active_arena(arena, &backup);
unknown's avatar
unknown committed
4151
  DBUG_RETURN(result);
unknown's avatar
unknown committed
4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175
}


/*
  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
4176 4177
    TRUE   Error
    FALSE  OK
unknown's avatar
unknown committed
4178
*/
4179 4180
static bool setup_natural_join_row_types(THD *thd,
                                         List<TABLE_LIST> *from_clause,
unknown's avatar
unknown committed
4181 4182 4183 4184 4185 4186 4187 4188 4189
                                         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. */
4190
  TABLE_LIST *left_neighbor;
unknown's avatar
unknown committed
4191 4192 4193
  /* Table reference to the right of the current. */
  TABLE_LIST *right_neighbor= NULL;

4194 4195
  /* Note that tables in the list are in reversed order */
  for (left_neighbor= table_ref_it++; left_neighbor ; )
unknown's avatar
unknown committed
4196 4197 4198
  {
    table_ref= left_neighbor;
    left_neighbor= table_ref_it++;
4199 4200
    /* For stored procedures do not redo work if already done. */
    if (context->select_lex->first_execution)
unknown's avatar
unknown committed
4201
    {
4202 4203 4204 4205 4206 4207 4208 4209 4210
      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;
      }
unknown's avatar
unknown committed
4211 4212 4213 4214 4215 4216 4217
    }
    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
4218
    right_neighbor points to the left-most top-level table reference in the
unknown's avatar
unknown committed
4219 4220 4221 4222 4223 4224 4225 4226 4227 4228
    FROM clause.
  */
  DBUG_ASSERT(right_neighbor);
  context->first_name_resolution_table=
    right_neighbor->first_leaf_for_name_resolution();

  return FALSE;
}


unknown's avatar
unknown committed
4229
/****************************************************************************
4230
** Expand all '*' in given fields
unknown's avatar
unknown committed
4231 4232
****************************************************************************/

4233 4234 4235
int setup_wild(THD *thd, TABLE_LIST *tables, List<Item> &fields,
	       List<Item> *sum_func_list,
	       uint wild_num)
unknown's avatar
unknown committed
4236
{
4237
  if (!wild_num)
4238
    return(0);
4239

4240
  Item *item;
unknown's avatar
unknown committed
4241
  List_iterator<Item> it(fields);
unknown's avatar
unknown committed
4242
  Query_arena *arena, backup;
4243
  DBUG_ENTER("setup_wild");
unknown's avatar
unknown committed
4244 4245

  /*
4246 4247
    Don't use arena if we are not in prepared statements or stored procedures
    For PS/SP we have to use arena to remember the changes
unknown's avatar
unknown committed
4248
  */
unknown's avatar
unknown committed
4249
  arena= thd->activate_stmt_arena_if_needed(&backup);
4250

unknown's avatar
unknown committed
4251
  while (wild_num && (item= it++))
unknown's avatar
VIEW  
unknown committed
4252
  {
4253 4254
    if (item->type() == Item::FIELD_ITEM &&
        ((Item_field*) item)->field_name &&
4255 4256
	((Item_field*) item)->field_name[0] == '*' &&
	!((Item_field*) item)->field)
4257
    {
4258
      uint elem= fields.elements;
unknown's avatar
VIEW  
unknown committed
4259
      bool any_privileges= ((Item_field *) item)->any_privileges;
unknown's avatar
unknown committed
4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270
      Item_subselect *subsel= thd->lex->current_select->master_unit()->item;
      if (subsel &&
          subsel->substype() == Item_subselect::EXISTS_SUBS)
      {
        /*
          It is EXISTS(SELECT * ...) and we can replace * by any constant.

          Item_int do not need fix_fields() because it is basic constant.
        */
        it.replace(new Item_int("Not_used", (longlong) 1, 21));
      }
4271 4272
      else if (insert_fields(thd, ((Item_field*) item)->context,
                             ((Item_field*) item)->db_name,
unknown's avatar
unknown committed
4273
                             ((Item_field*) item)->table_name, &it,
4274
                             any_privileges))
unknown's avatar
unknown committed
4275 4276
      {
	if (arena)
unknown's avatar
unknown committed
4277
	  thd->restore_active_arena(arena, &backup);
4278
	DBUG_RETURN(-1);
unknown's avatar
unknown committed
4279
      }
4280
      if (sum_func_list)
4281 4282 4283 4284 4285 4286 4287 4288
      {
	/*
	  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;
      }
4289
      wild_num--;
4290 4291
    }
  }
unknown's avatar
unknown committed
4292 4293 4294 4295 4296 4297 4298
  if (arena)
  {
    /* make * substituting permanent */
    SELECT_LEX *select_lex= thd->lex->current_select;
    select_lex->with_wild= 0;
    select_lex->item_list= fields;

unknown's avatar
unknown committed
4299
    thd->restore_active_arena(arena, &backup);
unknown's avatar
unknown committed
4300
  }
4301
  DBUG_RETURN(0);
4302 4303
}

4304 4305 4306 4307
/****************************************************************************
** Check that all given fields exists and fill struct with current data
****************************************************************************/

4308
bool setup_fields(THD *thd, Item **ref_pointer_array,
unknown's avatar
unknown committed
4309 4310
                  List<Item> &fields, bool set_query_id,
                  List<Item> *sum_func_list, bool allow_sum_func)
4311 4312
{
  reg2 Item *item;
unknown's avatar
unknown committed
4313
  bool save_set_query_id= thd->set_query_id;
unknown's avatar
unknown committed
4314
  nesting_map save_allow_sum_func= thd->lex->allow_sum_func;
4315 4316 4317 4318
  List_iterator<Item> it(fields);
  DBUG_ENTER("setup_fields");

  thd->set_query_id=set_query_id;
unknown's avatar
unknown committed
4319 4320
  if (allow_sum_func)
    thd->lex->allow_sum_func|= 1 << thd->lex->current_select->nest_level;
4321
  thd->where= THD::DEFAULT_WHERE;
4322

4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336
  /*
    To prevent fail on forward lookup we fill it with zerows,
    then if we got pointer on zero after find_item_in_list we will know
    that it is forward lookup.

    There is other way to solve problem: fill array with pointers to list,
    but it will be slower.

    TODO: remove it when (if) we made one list for allfields and
    ref_pointer_array
  */
  if (ref_pointer_array)
    bzero(ref_pointer_array, sizeof(Item *) * fields.elements);

unknown's avatar
unknown committed
4337 4338
  Item **ref= ref_pointer_array;
  while ((item= it++))
4339
  {
4340
    if (!item->fixed && item->fix_fields(thd, it.ref()) ||
unknown's avatar
unknown committed
4341
	(item= *(it.ref()))->check_cols(1))
unknown's avatar
unknown committed
4342
    {
unknown's avatar
unknown committed
4343
      thd->lex->allow_sum_func= save_allow_sum_func;
unknown's avatar
unknown committed
4344
      thd->set_query_id= save_set_query_id;
unknown's avatar
unknown committed
4345
      DBUG_RETURN(TRUE); /* purecov: inspected */
unknown's avatar
unknown committed
4346
    }
unknown's avatar
unknown committed
4347 4348
    if (ref)
      *(ref++)= item;
4349 4350
    if (item->with_sum_func && item->type() != Item::SUM_FUNC_ITEM &&
	sum_func_list)
4351
      item->split_sum_func(thd, ref_pointer_array, *sum_func_list);
unknown's avatar
unknown committed
4352
    thd->used_tables|= item->used_tables();
4353
  }
unknown's avatar
unknown committed
4354
  thd->lex->allow_sum_func= save_allow_sum_func;
unknown's avatar
unknown committed
4355
  thd->set_query_id= save_set_query_id;
4356
  DBUG_RETURN(test(thd->net.report_error));
4357
}
4358

4359

4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374
/*
  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)
  {
4375 4376 4377 4378 4379 4380
    if (table->merge_underlying_list)
    {
      DBUG_ASSERT(table->view &&
                  table->effective_algorithm == VIEW_ALGORITHM_MERGE);
      list= make_leaves_list(list, table->merge_underlying_list);
    }
4381 4382 4383 4384 4385 4386 4387 4388 4389
    else
    {
      *list= table;
      list= &table->next_leaf;
    }
  }
  return list;
}

4390
/*
unknown's avatar
unknown committed
4391 4392 4393 4394
  prepare tables

  SYNOPSIS
    setup_tables()
unknown's avatar
unknown committed
4395
    thd		  Thread handler
4396
    context       name resolution contest to setup table list there
unknown's avatar
unknown committed
4397 4398
    from_clause   Top-level list of table references in the FROM clause
    tables	  Table list (select_lex->table_list)
unknown's avatar
unknown committed
4399
    conds	  Condition of current SELECT (can be changed by VIEW)
unknown's avatar
unknown committed
4400
    leaves        List of join table leaves list (select_lex->leaf_tables)
unknown's avatar
unknown committed
4401 4402
    refresh       It is onle refresh for subquery
    select_insert It is SELECT ... INSERT command
unknown's avatar
unknown committed
4403

unknown's avatar
unknown committed
4404 4405
  NOTE
    Check also that the 'used keys' and 'ignored keys' exists and set up the
unknown's avatar
unknown committed
4406 4407 4408 4409
    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.
4410

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

unknown's avatar
unknown committed
4414
  RETURN
unknown's avatar
unknown committed
4415
    FALSE ok;  In this case *map will includes the chosen index
unknown's avatar
unknown committed
4416
    TRUE  error
4417 4418
*/

4419
bool setup_tables(THD *thd, Name_resolution_context *context,
unknown's avatar
unknown committed
4420 4421
                  List<TABLE_LIST> *from_clause, TABLE_LIST *tables,
                  Item **conds, TABLE_LIST **leaves, bool select_insert)
4422
{
unknown's avatar
unknown committed
4423
  uint tablenr= 0;
4424
  DBUG_ENTER("setup_tables");
4425

unknown's avatar
unknown committed
4426
  context->table_list= context->first_name_resolution_table= tables;
4427

unknown's avatar
unknown committed
4428 4429
  /*
    this is used for INSERT ... SELECT.
4430
    For select we setup tables except first (and its underlying tables)
unknown's avatar
unknown committed
4431 4432 4433 4434
  */
  TABLE_LIST *first_select_table= (select_insert ?
                                   tables->next_local:
                                   0);
4435 4436 4437
  if (!(*leaves))
    make_leaves_list(leaves, tables);

unknown's avatar
unknown committed
4438 4439
  TABLE_LIST *table_list;
  for (table_list= *leaves;
unknown's avatar
VIEW  
unknown committed
4440
       table_list;
4441
       table_list= table_list->next_leaf, tablenr++)
unknown's avatar
unknown committed
4442
  {
unknown's avatar
unknown committed
4443
    TABLE *table= table_list->table;
unknown's avatar
unknown committed
4444
    table->pos_in_table_list= table_list;
unknown's avatar
unknown committed
4445
    if (first_select_table &&
4446
        table_list->top_table() == first_select_table)
unknown's avatar
unknown committed
4447 4448 4449 4450 4451
    {
      /* new counting for SELECT of INSERT ... SELECT command */
      first_select_table= 0;
      tablenr= 0;
    }
unknown's avatar
unknown committed
4452
    setup_table_map(table, table_list, tablenr);
4453
    table->used_keys= table->s->keys_for_keyread;
unknown's avatar
unknown committed
4454
    if (table_list->use_index)
unknown's avatar
unknown committed
4455
    {
4456 4457 4458
      key_map map;
      get_key_map_from_key_list(&map, table, table_list->use_index);
      if (map.is_set_all())
4459
	DBUG_RETURN(1);
unknown's avatar
unknown committed
4460
      table->keys_in_use_for_query=map;
unknown's avatar
unknown committed
4461
    }
unknown's avatar
unknown committed
4462
    if (table_list->ignore_index)
unknown's avatar
unknown committed
4463
    {
4464 4465 4466
      key_map map;
      get_key_map_from_key_list(&map, table, table_list->ignore_index);
      if (map.is_set_all())
4467
	DBUG_RETURN(1);
4468
      table->keys_in_use_for_query.subtract(map);
unknown's avatar
unknown committed
4469
    }
4470
    table->used_keys.intersect(table->keys_in_use_for_query);
unknown's avatar
unknown committed
4471 4472 4473 4474
  }
  if (tablenr > MAX_TABLES)
  {
    my_error(ER_TOO_MANY_TABLES,MYF(0),MAX_TABLES);
4475
    DBUG_RETURN(1);
unknown's avatar
unknown committed
4476
  }
unknown's avatar
unknown committed
4477
  for (table_list= tables;
4478 4479
       table_list;
       table_list= table_list->next_local)
4480
  {
4481
    if (table_list->merge_underlying_list)
4482
    {
4483 4484
      DBUG_ASSERT(table_list->view &&
                  table_list->effective_algorithm == VIEW_ALGORITHM_MERGE);
unknown's avatar
unknown committed
4485
      Query_arena *arena= thd->stmt_arena, backup;
4486 4487 4488 4489
      bool res;
      if (arena->is_conventional())
        arena= 0;                                   // For easier test
      else
unknown's avatar
unknown committed
4490
        thd->set_n_backup_active_arena(arena, &backup);
4491
      res= table_list->setup_underlying(thd);
4492
      if (arena)
unknown's avatar
unknown committed
4493
        thd->restore_active_arena(arena, &backup);
4494 4495 4496
      if (res)
        DBUG_RETURN(1);
    }
4497
  }
unknown's avatar
unknown committed
4498 4499 4500 4501 4502

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

4503
  DBUG_RETURN(0);
unknown's avatar
unknown committed
4504
}
4505

unknown's avatar
unknown committed
4506

4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548
/*
  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,
                                   Item **conds, TABLE_LIST **leaves,
                                   bool select_insert,
                                   ulong want_access)
{
  TABLE_LIST *leaves_tmp = NULL;

  if (setup_tables (thd, context, from_clause, tables, conds, 
                    &leaves_tmp, select_insert))
    return TRUE;

  if (leaves)
    *leaves = leaves_tmp;

  for (; leaves_tmp; leaves_tmp= leaves_tmp->next_leaf)
    if (leaves_tmp->belong_to_view && 
4549
        check_single_table_access(thd, want_access,  leaves_tmp))
4550 4551 4552 4553 4554 4555 4556 4557 4558
    {
      tables->hide_view_error(thd);
      return TRUE;
    }

  return FALSE;
}


4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573
/*
   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,
4574
                               List<String> *index_list)
unknown's avatar
unknown committed
4575
{
unknown's avatar
unknown committed
4576
  List_iterator_fast<String> it(*index_list);
unknown's avatar
unknown committed
4577 4578
  String *name;
  uint pos;
4579 4580

  map->clear_all();
unknown's avatar
unknown committed
4581 4582
  while ((name=it++))
  {
4583 4584 4585
    if (table->s->keynames.type_names == 0 ||
        (pos= find_type(&table->s->keynames, name->ptr(),
                        name->length(), 1)) <=
4586
        0)
unknown's avatar
unknown committed
4587
    {
4588
      my_error(ER_KEY_DOES_NOT_EXITS, MYF(0), name->c_ptr(),
unknown's avatar
unknown committed
4589
	       table->pos_in_table_list->alias);
4590
      map->set_all();
4591
      return 1;
unknown's avatar
unknown committed
4592
    }
4593
    map->set_bit(pos-1);
unknown's avatar
unknown committed
4594
  }
4595
  return 0;
unknown's avatar
unknown committed
4596 4597
}

4598

4599 4600 4601 4602 4603 4604
/*
  Drops in all fields instead of current '*' field

  SYNOPSIS
    insert_fields()
    thd			Thread handler
4605
    context             Context for name resolution
4606 4607 4608 4609 4610 4611 4612
    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
4613
    0	ok     'it' is updated to point at last inserted
unknown's avatar
unknown committed
4614
    1	error.  Error message is generated but not sent to client
4615
*/
unknown's avatar
unknown committed
4616

unknown's avatar
unknown committed
4617
bool
4618
insert_fields(THD *thd, Name_resolution_context *context, const char *db_name,
unknown's avatar
VIEW  
unknown committed
4619
	      const char *table_name, List_iterator<Item> *it,
4620
              bool any_privileges)
unknown's avatar
unknown committed
4621
{
unknown's avatar
unknown committed
4622 4623
  Field_iterator_table_ref field_iterator;
  bool found;
unknown's avatar
unknown committed
4624
  char name_buff[NAME_LEN+1];
unknown's avatar
unknown committed
4625
  DBUG_ENTER("insert_fields");
unknown's avatar
unknown committed
4626
  DBUG_PRINT("arena", ("stmt arena: 0x%lx", (ulong)thd->stmt_arena));
unknown's avatar
unknown committed
4627

4628 4629
  if (db_name && lower_case_table_names)
  {
unknown's avatar
unknown committed
4630 4631 4632 4633 4634
    /*
      convert database to lower case for comparison
      We can't do this in Item_field as this would change the
      'name' of the item which may be used in the select list
    */
unknown's avatar
unknown committed
4635
    strmake(name_buff, db_name, sizeof(name_buff)-1);
unknown's avatar
unknown committed
4636
    my_casedn_str(files_charset_info, name_buff);
unknown's avatar
unknown committed
4637
    db_name= name_buff;
4638 4639
  }

unknown's avatar
unknown committed
4640
  found= FALSE;
4641 4642 4643 4644 4645 4646 4647 4648

  /*
    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);
4649
       tables;
4650 4651 4652
       tables= (table_name ? tables->next_local :
                tables->next_name_resolution_table)
       )
unknown's avatar
unknown committed
4653
  {
4654 4655 4656
    Field *field;
    TABLE *table= tables->table;

unknown's avatar
unknown committed
4657 4658
    DBUG_ASSERT(tables->is_leaf_for_name_resolution());

4659 4660 4661 4662
    if (table_name && my_strcasecmp(table_alias_charset, table_name,
                                    tables->alias) ||
        (db_name && strcmp(tables->db,db_name)))
      continue;
unknown's avatar
unknown committed
4663

unknown's avatar
unknown committed
4664
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
4665 4666 4667 4668 4669 4670 4671
    /* Ensure that we have access rights to all fields to be inserted. */
    if (!((table && (table->grant.privilege & SELECT_ACL) ||
           tables->view && (tables->grant.privilege & SELECT_ACL))) &&
        !any_privileges)
    {
      field_iterator.set(tables);
      if (check_grant_all_columns(thd, SELECT_ACL, field_iterator.grant(),
4672 4673
                                  field_iterator.db_name(),
                                  field_iterator.table_name(),
unknown's avatar
unknown committed
4674 4675 4676
                                  &field_iterator))
        DBUG_RETURN(TRUE);
    }
unknown's avatar
unknown committed
4677
#endif
unknown's avatar
VIEW  
unknown committed
4678 4679


unknown's avatar
unknown committed
4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702
    /*
      Update the tables used in the query based on the referenced fields. For
      views and natural joins this update is performed inside the loop below.
    */
    if (table)
      thd->used_tables|= table->map;

    /*
      Initialize a generic field iterator for the current table reference.
      Notice that it is guaranteed that this iterator will iterate over the
      fields of a single table reference, because 'tables' is a leaf (for
      name resolution purposes).
    */
    field_iterator.set(tables);

    for (; !field_iterator.end_of_fields(); field_iterator.next())
    {
      Item *item;

      if (!(item= field_iterator.create_item(thd)))
        DBUG_RETURN(TRUE);

      if (!found)
4703
      {
unknown's avatar
unknown committed
4704
        found= TRUE;
4705
        it->replace(item); /* Replace '*' with the first found item. */
4706
      }
unknown's avatar
VIEW  
unknown committed
4707
      else
unknown's avatar
unknown committed
4708 4709 4710 4711 4712 4713 4714
        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,
4715 4716 4717
        therefore if 'tables' is itself a view, it is represented by a
        temporary table. Thus in this case we can be sure that 'item' is an
        Item_field.
unknown's avatar
unknown committed
4718 4719
      */
      if (any_privileges)
4720
      {
unknown's avatar
unknown committed
4721 4722 4723 4724
        DBUG_ASSERT(tables->field_translation == NULL && table ||
                    tables->is_natural_join);
        DBUG_ASSERT(item->type() == Item::FIELD_ITEM);
        Item_field *fld= (Item_field*) item;
4725
        const char *field_table_name= field_iterator.table_name();
4726

unknown's avatar
unknown committed
4727 4728 4729 4730
        if (!tables->schema_table && 
            !(fld->have_privileges=
              (get_column_grant(thd, field_iterator.grant(),
                                field_iterator.db_name(),
4731
                                field_table_name, fld->field_name) &
unknown's avatar
unknown committed
4732 4733 4734
               VIEW_ANY_ACL)))
        {
          my_error(ER_COLUMNACCESS_DENIED_ERROR, MYF(0), "ANY",
4735 4736
                   thd->security_ctx->priv_user,
                   thd->security_ctx->host_or_ip,
4737
                   fld->field_name, field_table_name);
unknown's avatar
unknown committed
4738 4739
          DBUG_RETURN(TRUE);
        }
4740
      }
unknown's avatar
unknown committed
4741
#endif
4742

unknown's avatar
unknown committed
4743
      if ((field= field_iterator.field()))
unknown's avatar
unknown committed
4744
      {
unknown's avatar
unknown committed
4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756
        /*
          Mark if field used before in this select.
          Used by 'insert' to verify if a field name is used twice.
        */
        if (field->query_id == thd->query_id)
          thd->dupp_field= field;
        field->query_id= thd->query_id;

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

        if (tables->is_natural_join)
unknown's avatar
unknown committed
4757
        {
unknown's avatar
unknown committed
4758 4759
          TABLE *field_table;
          /*
4760
            In this case we are sure that the column ref will not be created
unknown's avatar
unknown committed
4761
            because it was already created and stored with the natural join.
4762
          */
unknown's avatar
unknown committed
4763
          Natural_join_column *nj_col;
unknown's avatar
unknown committed
4764
          if (!(nj_col= field_iterator.get_natural_column_ref()))
unknown's avatar
unknown committed
4765
            DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
4766
          DBUG_ASSERT(nj_col->table_field);
unknown's avatar
unknown committed
4767 4768
          field_table= nj_col->table_ref->table;
          if (field_table)
unknown's avatar
VIEW  
unknown committed
4769
          {
unknown's avatar
unknown committed
4770 4771 4772
            thd->used_tables|= field_table->map;
            field_table->used_keys.intersect(field->part_of_key);
            field_table->used_fields++;
unknown's avatar
VIEW  
unknown committed
4773
          }
unknown's avatar
unknown committed
4774
        }
unknown's avatar
unknown committed
4775
      }
unknown's avatar
unknown committed
4776 4777 4778 4779 4780 4781
      else
      {
        thd->used_tables|= item->used_tables();
        item->walk(&Item::reset_query_id_processor,
                   (byte *)(&thd->query_id));
      }
unknown's avatar
unknown committed
4782
    }
unknown's avatar
unknown committed
4783 4784 4785 4786 4787 4788 4789 4790
    /*
      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;
unknown's avatar
unknown committed
4791
  }
4792
  if (found)
unknown's avatar
unknown committed
4793
    DBUG_RETURN(FALSE);
4794

unknown's avatar
unknown committed
4795
  /*
4796 4797 4798
    TODO: in the case when we skipped all columns because there was a
    qualified '*', and all columns were coalesced, we have to give a more
    meaningful message than ER_BAD_TABLE_ERROR.
unknown's avatar
unknown committed
4799
  */
4800
  if (!table_name)
unknown's avatar
unknown committed
4801
    my_message(ER_NO_TABLES_USED, ER(ER_NO_TABLES_USED), MYF(0));
4802 4803
  else
    my_error(ER_BAD_TABLE_ERROR, MYF(0), table_name);
unknown's avatar
unknown committed
4804 4805

  DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
4806 4807 4808 4809
}


/*
unknown's avatar
unknown committed
4810
  Fix all conditions and outer join expressions.
4811 4812 4813 4814

  SYNOPSIS
    setup_conds()
    thd     thread handler
unknown's avatar
unknown committed
4815 4816 4817 4818 4819 4820 4821 4822 4823 4824
    tables  list of tables for name resolving (select_lex->table_list)
    leaves  list of leaves of join table tree (select_lex->leaf_tables)
    conds   WHERE clause

  DESCRIPTION
    TODO

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

4827 4828
int setup_conds(THD *thd, TABLE_LIST *tables, TABLE_LIST *leaves,
                COND **conds)
unknown's avatar
unknown committed
4829
{
unknown's avatar
unknown committed
4830
  SELECT_LEX *select_lex= thd->lex->current_select;
unknown's avatar
unknown committed
4831
  Query_arena *arena= thd->stmt_arena, backup;
unknown's avatar
unknown committed
4832
  TABLE_LIST *table= NULL;	// For HP compilers
4833 4834 4835 4836 4837 4838 4839 4840 4841 4842
  /*
    it_is_update set to TRUE when tables of primary SELECT_LEX (SELECT_LEX
    which belong to LEX, i.e. most up SELECT) will be updated by
    INSERT/UPDATE/LOAD
    NOTE: using this condition helps to prevent call of prepare_check_option()
    from subquery of VIEW, because tables of subquery belongs to VIEW
    (see condition before prepare_check_option() call)
  */
  bool it_is_update= (select_lex == &thd->lex->select_lex) &&
    thd->lex->which_check_option_applicable();
unknown's avatar
unknown committed
4843
  DBUG_ENTER("setup_conds");
unknown's avatar
unknown committed
4844

unknown's avatar
unknown committed
4845
  if (select_lex->conds_processed_with_permanent_arena ||
unknown's avatar
unknown committed
4846
      arena->is_conventional())
unknown's avatar
unknown committed
4847 4848
    arena= 0;                                   // For easier test

unknown's avatar
unknown committed
4849
  thd->set_query_id=1;
unknown's avatar
unknown committed
4850
  select_lex->cond_count= 0;
unknown's avatar
VIEW  
unknown committed
4851

4852 4853 4854 4855 4856 4857
  for (table= tables; table; table= table->next_local)
  {
    if (table->prepare_where(thd, conds, FALSE))
      goto err_no_arena;
  }

unknown's avatar
unknown committed
4858 4859 4860
  if (*conds)
  {
    thd->where="where clause";
4861
    if (!(*conds)->fixed && (*conds)->fix_fields(thd, conds) ||
unknown's avatar
unknown committed
4862
	(*conds)->check_cols(1))
4863
      goto err_no_arena;
unknown's avatar
unknown committed
4864 4865
  }

unknown's avatar
unknown committed
4866 4867 4868 4869
  /*
    Apply fix_fields() to all ON clauses at all levels of nesting,
    including the ones inside view definitions.
  */
unknown's avatar
merge  
unknown committed
4870
  for (table= leaves; table; table= table->next_leaf)
unknown's avatar
unknown committed
4871
  {
unknown's avatar
unknown committed
4872 4873
    TABLE_LIST *embedded; /* The table at the current level of nesting. */
    TABLE_LIST *embedding= table; /* The parent nested table reference. */
4874
    do
unknown's avatar
VIEW  
unknown committed
4875
    {
4876 4877
      embedded= embedding;
      if (embedded->on_expr)
4878
      {
4879 4880
        /* Make a join an a expression */
        thd->where="on clause";
unknown's avatar
VIEW  
unknown committed
4881
        if (!embedded->on_expr->fixed &&
4882
            embedded->on_expr->fix_fields(thd, &embedded->on_expr) ||
4883
	    embedded->on_expr->check_cols(1))
4884
	  goto err_no_arena;
unknown's avatar
unknown committed
4885
        select_lex->cond_count++;
4886
      }
4887
      embedding= embedded->embedding;
unknown's avatar
unknown committed
4888
    }
4889 4890
    while (embedding &&
           embedding->nested_join->join_list.head() == embedded);
4891 4892 4893 4894

    /* process CHECK OPTION */
    if (it_is_update)
    {
unknown's avatar
unknown committed
4895
      TABLE_LIST *view= table->top_table();
4896 4897 4898 4899 4900 4901 4902
      if (view->effective_with_check)
      {
        if (view->prepare_check_option(thd))
          goto err_no_arena;
        thd->change_item_tree(&table->check_option, view->check_option);
      }
    }
unknown's avatar
unknown committed
4903
  }
unknown's avatar
unknown committed
4904

unknown's avatar
unknown committed
4905
  if (!thd->stmt_arena->is_conventional())
unknown's avatar
unknown committed
4906 4907 4908 4909 4910 4911 4912 4913 4914 4915
  {
    /*
      We are in prepared statement preparation code => we should store
      WHERE clause changing for next executions.

      We do this ON -> WHERE transformation only once per PS/SP statement.
    */
    select_lex->where= *conds;
    select_lex->conds_processed_with_permanent_arena= 1;
  }
4916
  DBUG_RETURN(test(thd->net.report_error));
unknown's avatar
unknown committed
4917

4918
err_no_arena:
unknown's avatar
unknown committed
4919
  DBUG_RETURN(1);
unknown's avatar
unknown committed
4920 4921 4922 4923 4924 4925 4926 4927
}


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

unknown's avatar
unknown committed
4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943

/*
  Fill fields with given items.

  SYNOPSIS
    fill_record()
    thd           thread handler
    fields        Item_fields list to be filled
    values        values to fill with
    ignore_errors TRUE if we should ignore errors

  RETURN
    FALSE   OK
    TRUE    error occured
*/

unknown's avatar
unknown committed
4944
static bool
unknown's avatar
unknown committed
4945 4946
fill_record(THD * thd, List<Item> &fields, List<Item> &values,
            bool ignore_errors)
unknown's avatar
unknown committed
4947
{
unknown's avatar
unknown committed
4948
  List_iterator_fast<Item> f(fields),v(values);
unknown's avatar
unknown committed
4949 4950 4951 4952 4953 4954 4955
  Item *value;
  Item_field *field;
  DBUG_ENTER("fill_record");

  while ((field=(Item_field*) f++))
  {
    value=v++;
4956 4957
    Field *rfield= field->field;
    TABLE *table= rfield->table;
unknown's avatar
unknown committed
4958
    if (rfield == table->next_number_field)
unknown's avatar
unknown committed
4959
      table->auto_increment_field_not_null= TRUE;
unknown's avatar
unknown committed
4960
    if ((value->save_in_field(rfield, 0) < 0) && !ignore_errors)
unknown's avatar
unknown committed
4961 4962 4963 4964
    {
      my_message(ER_UNKNOWN_ERROR, ER(ER_UNKNOWN_ERROR), MYF(0));
      DBUG_RETURN(TRUE);
    }
unknown's avatar
unknown committed
4965
  }
unknown's avatar
unknown committed
4966
  DBUG_RETURN(thd->net.report_error);
unknown's avatar
unknown committed
4967 4968 4969
}


unknown's avatar
unknown committed
4970 4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004
/*
  Fill fields in list with values from the list of items and invoke
  before triggers.

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

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

  RETURN
    FALSE   OK
    TRUE    error occured
*/

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


unknown's avatar
unknown committed
5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021
/*
  Fill field buffer with values from Field list

  SYNOPSIS
    fill_record()
    thd           thread handler
    ptr           pointer on pointer to record
    values        list of fields
    ignore_errors TRUE if we should ignore errors

  RETURN
    FALSE   OK
    TRUE    error occured
*/

bool
fill_record(THD *thd, Field **ptr, List<Item> &values, bool ignore_errors)
unknown's avatar
unknown committed
5022
{
unknown's avatar
unknown committed
5023
  List_iterator_fast<Item> v(values);
unknown's avatar
unknown committed
5024 5025 5026 5027 5028 5029 5030
  Item *value;
  DBUG_ENTER("fill_record");

  Field *field;
  while ((field = *ptr++))
  {
    value=v++;
5031
    TABLE *table= field->table;
unknown's avatar
unknown committed
5032
    if (field == table->next_number_field)
unknown's avatar
unknown committed
5033
      table->auto_increment_field_not_null= TRUE;
5034
    if (value->save_in_field(field, 0) == -1)
unknown's avatar
unknown committed
5035
      DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
5036
  }
unknown's avatar
unknown committed
5037
  DBUG_RETURN(thd->net.report_error);
unknown's avatar
unknown committed
5038 5039 5040
}


unknown's avatar
unknown committed
5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075
/*
  Fill fields in array with values from the list of items and invoke
  before triggers.

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

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

  RETURN
    FALSE   OK
    TRUE    error occured
*/

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


unknown's avatar
unknown committed
5076 5077
static void mysql_rm_tmp_tables(void)
{
unknown's avatar
unknown committed
5078 5079
  uint i, idx;
  char	filePath[FN_REFLEN], *tmpdir;
unknown's avatar
unknown committed
5080 5081 5082 5083
  MY_DIR *dirp;
  FILEINFO *file;
  DBUG_ENTER("mysql_rm_tmp_tables");

unknown's avatar
unknown committed
5084 5085 5086
  for (i=0; i<=mysql_tmpdir_list.max; i++)
  {
    tmpdir=mysql_tmpdir_list.list[i];
unknown's avatar
unknown committed
5087
  /* See if the directory exists */
unknown's avatar
unknown committed
5088 5089
    if (!(dirp = my_dir(tmpdir,MYF(MY_WME | MY_DONT_SORT))))
      continue;
unknown's avatar
unknown committed
5090

unknown's avatar
unknown committed
5091
    /* Remove all SQLxxx tables from directory */
unknown's avatar
unknown committed
5092

unknown's avatar
unknown committed
5093
  for (idx=0 ; idx < (uint) dirp->number_off_files ; idx++)
unknown's avatar
unknown committed
5094 5095
  {
    file=dirp->dir_entry+idx;
unknown's avatar
unknown committed
5096 5097 5098 5099 5100 5101

    /* skiping . and .. */
    if (file->name[0] == '.' && (!file->name[1] ||
       (file->name[1] == '.' &&  !file->name[2])))
      continue;

unknown's avatar
unknown committed
5102 5103
    if (!bcmp(file->name,tmp_file_prefix,tmp_file_prefix_length))
    {
unknown's avatar
unknown committed
5104 5105
        sprintf(filePath,"%s%s",tmpdir,file->name);
        VOID(my_delete(filePath,MYF(MY_WME)));
unknown's avatar
unknown committed
5106 5107 5108
    }
  }
  my_dirend(dirp);
unknown's avatar
unknown committed
5109
  }
unknown's avatar
unknown committed
5110 5111 5112 5113 5114 5115 5116 5117 5118 5119
  DBUG_VOID_RETURN;
}



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

/*
5120 5121 5122 5123 5124 5125 5126 5127 5128 5129
  Invalidate any cache entries that are for some DB

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

  NOTE:
  We can't use hash_delete when looping hash_elements. We mark them first
  and afterwards delete those marked unused.
unknown's avatar
unknown committed
5130 5131
*/

5132
void remove_db_from_cache(const char *db)
unknown's avatar
unknown committed
5133 5134 5135 5136
{
  for (uint idx=0 ; idx < open_cache.records ; idx++)
  {
    TABLE *table=(TABLE*) hash_element(&open_cache,idx);
5137
    if (!strcmp(table->s->db, db))
unknown's avatar
unknown committed
5138
    {
5139
      table->s->version= 0L;			/* Free when thread is ready */
unknown's avatar
unknown committed
5140 5141 5142 5143
      if (!table->in_use)
	relink_unused(table);
    }
  }
5144
  while (unused_tables && !unused_tables->s->version)
unknown's avatar
unknown committed
5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162
    VOID(hash_delete(&open_cache,(byte*) unused_tables));
}


/*
** free all unused tables
*/

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


/*
unknown's avatar
unknown committed
5163 5164 5165 5166 5167
  Mark all entries with the table as deleted to force an reopen of the table

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

unknown's avatar
unknown committed
5168 5169 5170
  PREREQUISITES
    Lock on LOCK_open()

unknown's avatar
unknown committed
5171 5172 5173 5174
  RETURN
    0  This thread now have exclusive access to this table and no other thread
       can access the table until close_thread_tables() is called.
    1  Table is in use by another thread
unknown's avatar
unknown committed
5175 5176
*/

5177
bool remove_table_from_cache(THD *thd, const char *db, const char *table_name,
unknown's avatar
unknown committed
5178
                             uint flags)
unknown's avatar
unknown committed
5179 5180 5181 5182
{
  char key[MAX_DBKEY_LENGTH];
  uint key_length;
  TABLE *table;
unknown's avatar
unknown committed
5183
  bool result=0, signalled= 0;
unknown's avatar
unknown committed
5184
  DBUG_ENTER("remove_table_from_cache");
unknown's avatar
unknown committed
5185
  DBUG_PRINT("enter", ("Table: '%s.%s'  flags: %u", db, table_name, flags));
unknown's avatar
unknown committed
5186 5187

  key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
unknown's avatar
unknown committed
5188
  for (;;)
unknown's avatar
unknown committed
5189
  {
5190
    HASH_SEARCH_STATE state;
unknown's avatar
unknown committed
5191 5192
    result= signalled= 0;

5193 5194
    for (table= (TABLE*) hash_first(&open_cache, (byte*) key, key_length,
                                    &state);
unknown's avatar
unknown committed
5195
         table;
5196 5197
         table= (TABLE*) hash_next(&open_cache, (byte*) key, key_length,
                                   &state))
unknown's avatar
unknown committed
5198
    {
unknown's avatar
unknown committed
5199
      THD *in_use;
5200
      table->s->version=0L;		/* Free when thread is ready */
unknown's avatar
unknown committed
5201
      if (!(in_use=table->in_use))
unknown's avatar
unknown committed
5202
      {
unknown's avatar
unknown committed
5203 5204
        DBUG_PRINT("info",("Table was not in use"));
        relink_unused(table);
unknown's avatar
unknown committed
5205
      }
unknown's avatar
unknown committed
5206
      else if (in_use != thd)
5207
      {
unknown's avatar
unknown committed
5208 5209
        in_use->some_tables_deleted=1;
        if (table->db_stat)
unknown's avatar
unknown committed
5210 5211
        {
          DBUG_PRINT("info", ("Found another active instance of the table"));
unknown's avatar
unknown committed
5212
  	  result=1;
unknown's avatar
unknown committed
5213
        }
unknown's avatar
unknown committed
5214 5215 5216 5217
        /* Kill delayed insert threads */
        if ((in_use->system_thread & SYSTEM_THREAD_DELAYED_INSERT) &&
            ! in_use->killed)
        {
5218
	  in_use->killed= THD::KILL_CONNECTION;
unknown's avatar
unknown committed
5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237
	  pthread_mutex_lock(&in_use->mysys_var->mutex);
	  if (in_use->mysys_var->current_cond)
	  {
	    pthread_mutex_lock(in_use->mysys_var->current_mutex);
            signalled= 1;
	    pthread_cond_broadcast(in_use->mysys_var->current_cond);
	    pthread_mutex_unlock(in_use->mysys_var->current_mutex);
	  }
	  pthread_mutex_unlock(&in_use->mysys_var->mutex);
        }
        /*
	  Now we must abort all tables locks used by this thread
	  as the thread may be waiting to get a lock for another table
        */
        for (TABLE *thd_table= in_use->open_tables;
	     thd_table ;
	     thd_table= thd_table->next)
        {
	  if (thd_table->db_stat)		// If table is open
unknown's avatar
unknown committed
5238
	    signalled|= mysql_lock_abort_for_thread(thd, thd_table);
unknown's avatar
unknown committed
5239
        }
5240
      }
unknown's avatar
unknown committed
5241
      else
unknown's avatar
unknown committed
5242
        result= result || (flags & RTFC_OWNED_BY_THD_FLAG);
unknown's avatar
unknown committed
5243
    }
unknown's avatar
unknown committed
5244
    while (unused_tables && !unused_tables->s->version)
unknown's avatar
unknown committed
5245
      VOID(hash_delete(&open_cache,(byte*) unused_tables));
unknown's avatar
unknown committed
5246
    if (result && (flags & RTFC_WAIT_OTHER_THREAD_FLAG))
unknown's avatar
unknown committed
5247
    {
unknown's avatar
unknown committed
5248 5249 5250 5251
      /*
        Signal any thread waiting for tables to be freed to
        reopen their tables
      */
5252
      broadcast_refresh();
unknown's avatar
unknown committed
5253
      DBUG_PRINT("info", ("Waiting for refresh signal"));
unknown's avatar
unknown committed
5254
      if (!(flags & RTFC_CHECK_KILLED_FLAG) || !thd->killed)
5255
      {
unknown's avatar
unknown committed
5256
        dropping_tables++;
unknown's avatar
unknown committed
5257 5258 5259 5260
        if (likely(signalled))
          (void) pthread_cond_wait(&COND_refresh, &LOCK_open);
        else
        {
unknown's avatar
unknown committed
5261
          struct timespec abstime;
unknown's avatar
unknown committed
5262 5263 5264 5265 5266 5267 5268 5269 5270 5271
          /*
            It can happen that another thread has opened the
            table but has not yet locked any table at all. Since
            it can be locked waiting for a table that our thread
            has done LOCK TABLE x WRITE on previously, we need to
            ensure that the thread actually hears our signal
            before we go to sleep. Thus we wait for a short time
            and then we retry another loop in the
            remove_table_from_cache routine.
          */
unknown's avatar
unknown committed
5272 5273
          set_timespec(abstime, 10);
          pthread_cond_timedwait(&COND_refresh, &LOCK_open, &abstime);
unknown's avatar
unknown committed
5274
        }
unknown's avatar
unknown committed
5275 5276
        dropping_tables--;
        continue;
5277
      }
unknown's avatar
unknown committed
5278
    }
unknown's avatar
unknown committed
5279
    break;
unknown's avatar
unknown committed
5280 5281 5282 5283
  }
  DBUG_RETURN(result);
}

5284
int setup_ftfuncs(SELECT_LEX *select_lex)
unknown's avatar
unknown committed
5285
{
5286 5287
  List_iterator<Item_func_match> li(*(select_lex->ftfunc_list)),
                                 lj(*(select_lex->ftfunc_list));
5288
  Item_func_match *ftf, *ftf2;
unknown's avatar
unknown committed
5289 5290

  while ((ftf=li++))
5291
  {
unknown's avatar
unknown committed
5292 5293
    if (ftf->fix_index())
      return 1;
5294 5295
    lj.rewind();
    while ((ftf2=lj++) != ftf)
5296
    {
5297
      if (ftf->eq(ftf2,1) && !ftf2->master)
5298 5299 5300
        ftf2->master=ftf;
    }
  }
unknown's avatar
unknown committed
5301 5302 5303

  return 0;
}
5304

5305

5306
int init_ftfuncs(THD *thd, SELECT_LEX *select_lex, bool no_order)
5307
{
5308
  if (select_lex->ftfunc_list->elements)
5309
  {
5310
    List_iterator<Item_func_match> li(*(select_lex->ftfunc_list));
unknown's avatar
unknown committed
5311 5312 5313
    Item_func_match *ifm;
    DBUG_PRINT("info",("Performing FULLTEXT search"));
    thd->proc_info="FULLTEXT initialization";
5314

unknown's avatar
unknown committed
5315 5316 5317
    while ((ifm=li++))
      ifm->init_search(no_order);
  }
5318 5319
  return 0;
}
unknown's avatar
VIEW  
unknown committed
5320 5321 5322 5323 5324 5325 5326


/*
  open new .frm format table

  SYNOPSIS
    open_new_frm()
5327
    THD		  thread handler
unknown's avatar
VIEW  
unknown committed
5328 5329
    path	  path to .frm
    alias	  alias for table
5330 5331
    db            database
    table_name    name of table
unknown's avatar
VIEW  
unknown committed
5332 5333 5334 5335 5336 5337 5338 5339
    db_stat	  open flags (for example HA_OPEN_KEYFILE|HA_OPEN_RNDFILE..)
		  can be 0 (example in ha_example_table)
    prgflag	  READ_ALL etc..
    ha_open_flags HA_OPEN_ABORT_IF_LOCKED etc..
    outparam	  result table
    table_desc	  TABLE_LIST descriptor
    mem_root	  temporary MEM_ROOT for parsing
*/
5340

5341 5342
static bool
open_new_frm(THD *thd, const char *path, const char *alias,
5343 5344
             const char *db, const char *table_name,
             uint db_stat, uint prgflag,
unknown's avatar
VIEW  
unknown committed
5345 5346 5347 5348
	     uint ha_open_flags, TABLE *outparam, TABLE_LIST *table_desc,
	     MEM_ROOT *mem_root)
{
  LEX_STRING pathstr;
5349 5350 5351 5352
  File_parser *parser;
  DBUG_ENTER("open_new_frm");

  pathstr.str=    (char*) path;
unknown's avatar
VIEW  
unknown committed
5353
  pathstr.length= strlen(path);
5354

5355
  if ((parser= sql_parse_prepare(&pathstr, mem_root, 1)))
unknown's avatar
VIEW  
unknown committed
5356
  {
5357
    if (is_equal(&view_type, parser->type()))
unknown's avatar
VIEW  
unknown committed
5358
    {
5359
      if (table_desc == 0 || table_desc->required_type == FRMTYPE_TABLE)
unknown's avatar
VIEW  
unknown committed
5360
      {
unknown's avatar
unknown committed
5361
        my_error(ER_WRONG_OBJECT, MYF(0), db, table_name, "BASE TABLE");
5362
        goto err;
unknown's avatar
VIEW  
unknown committed
5363
      }
5364
      if (mysql_make_view(thd, parser, table_desc))
5365
        goto err;
unknown's avatar
VIEW  
unknown committed
5366 5367 5368 5369 5370
    }
    else
    {
      /* only VIEWs are supported now */
      my_error(ER_FRM_UNKNOWN_TYPE, MYF(0), path,  parser->type()->str);
5371
      goto err;
unknown's avatar
VIEW  
unknown committed
5372
    }
5373
    DBUG_RETURN(0);
unknown's avatar
VIEW  
unknown committed
5374
  }
unknown's avatar
unknown committed
5375
 
5376 5377 5378
err:
  bzero(outparam, sizeof(TABLE));	// do not run repair
  DBUG_RETURN(1);
unknown's avatar
VIEW  
unknown committed
5379
}
5380 5381 5382 5383 5384 5385


bool is_equal(const LEX_STRING *a, const LEX_STRING *b)
{
  return a->length == b->length && !strncmp(a->str, b->str, a->length);
}