sql_base.cc 157 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);
unknown's avatar
VIEW  
unknown committed
40
static my_bool open_new_frm(const char *path, const char *alias,
41
                            const char *db, const char *table_name,
unknown's avatar
VIEW  
unknown committed
42 43 44
			    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
    mysql_ha_flush(thd, tables, MYSQL_HA_REOPEN_ON_USAGE | MYSQL_HA_FLUSH_ALL);
unknown's avatar
unknown committed
315 316
    bool found=1;
    /* Wait until all threads has closed all the tables we had locked */
317 318
    DBUG_PRINT("info",
	       ("Waiting for others threads to close their open tables"));
unknown's avatar
unknown committed
319 320 321 322 323 324
    while (found && ! thd->killed)
    {
      found=0;
      for (uint idx=0 ; idx < open_cache.records ; idx++)
      {
	TABLE *table=(TABLE*) hash_element(&open_cache,idx);
325
	if ((table->s->version) < refresh_version && table->db_stat)
unknown's avatar
unknown committed
326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
	{
	  found=1;
	  pthread_cond_wait(&COND_refresh,&LOCK_open);
	  break;
	}
      }
    }
    /*
      No other thread has the locked tables open; reopen them and get the
      old locks. This should always succeed (unless some external process
      has removed the tables)
    */
    thd->in_lock_tables=1;
    result=reopen_tables(thd,1,1);
    thd->in_lock_tables=0;
341
    /* Set version for table */
unknown's avatar
VIEW  
unknown committed
342
    for (TABLE *table=thd->open_tables; table ; table= table->next)
343
      table->s->version= refresh_version;
unknown's avatar
unknown committed
344 345 346 347 348 349 350 351 352 353 354 355 356 357
  }
  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);
}


358
/*
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382
  Mark all tables in the list which were used by current substatement
  as free for reuse.

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

  DESCRIPTION
    Marks all tables in the list which were used by current substatement
    (they are marked by its query_id) as free for reuse.
*/

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


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

384 385 386 387 388 389 390
  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.
391 392
    stopper             When closing tables from thd->open_tables(->next)*, 
                        don't close/remove tables starting from stopper.
393 394 395 396

  IMPLEMENTATION
    Unlocks tables and frees derived tables.
    Put all normal tables used by thread in free list.
397 398 399 400 401

    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.
402
*/
unknown's avatar
unknown committed
403

404
void close_thread_tables(THD *thd, bool lock_in_use, bool skip_derived)
unknown's avatar
unknown committed
405
{
406
  bool found_old_table;
407
  prelocked_mode_type prelocked_mode= thd->prelocked_mode;
unknown's avatar
unknown committed
408 409
  DBUG_ENTER("close_thread_tables");

410 411 412 413 414 415 416 417 418 419 420
  /*
    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.
  */
421 422 423 424
  if (thd->derived_tables && !skip_derived)
  {
    TABLE *table, *next;
    /*
425 426
      Close all derived tables generated in queries like
      SELECT * FROM (SELECT * FROM t1)
427 428 429 430 431 432 433 434
    */
    for (table= thd->derived_tables ; table ; table= next)
    {
      next= table->next;
      free_tmp_table(thd, table);
    }
    thd->derived_tables= 0;
  }
435 436

  if (prelocked_mode)
437
  {
438 439 440 441 442 443 444 445 446
    /*
      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)
  {
    /*
447 448 449 450 451 452
      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.
453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474
    */
    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.
    */
475
    DBUG_PRINT("info",("thd->prelocked_mode= NON_PRELOCKED"));
476 477 478 479 480 481 482 483
    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 */
484
  }
unknown's avatar
unknown committed
485 486 487

  if (thd->lock)
  {
488 489
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;
unknown's avatar
unknown committed
490
  }
491 492 493 494 495 496 497 498 499 500
  /*
    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())
501
    thd->transaction.xid_state.xid.null();
502

unknown's avatar
unknown committed
503
  /* VOID(pthread_sigmask(SIG_SETMASK,&thd->block_signals,NULL)); */
504
  if (!lock_in_use)
unknown's avatar
unknown committed
505
    VOID(pthread_mutex_lock(&LOCK_open));
506
  safe_mutex_assert_owner(&LOCK_open);
unknown's avatar
unknown committed
507

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

510
 found_old_table= 0;
511
  while (thd->open_tables)
512
    found_old_table|=close_thread_table(thd, &thd->open_tables);
513
  thd->some_tables_deleted=0;
514

unknown's avatar
unknown committed
515
  /* Free tables to hold down open files */
516
  while (open_cache.records > table_cache_size && unused_tables)
unknown's avatar
unknown committed
517 518 519 520 521 522 523
    VOID(hash_delete(&open_cache,(byte*) unused_tables)); /* purecov: tested */
  check_unused();
  if (found_old_table)
  {
    /* Tell threads waiting for refresh that something has happened */
    VOID(pthread_cond_broadcast(&COND_refresh));
  }
524
  if (!lock_in_use)
unknown's avatar
unknown committed
525 526
    VOID(pthread_mutex_unlock(&LOCK_open));
  /*  VOID(pthread_sigmask(SIG_SETMASK,&thd->signals,NULL)); */
527 528 529 530 531 532 533 534 535 536 537

  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
538 539 540
  DBUG_VOID_RETURN;
}

541 542 543 544
/* move one table to free list */

bool close_thread_table(THD *thd, TABLE **table_ptr)
{
545 546
  bool found_old_table= 0;
  TABLE *table= *table_ptr;
547
  DBUG_ENTER("close_thread_table");
548
  DBUG_ASSERT(table->key_read == 0);
unknown's avatar
unknown committed
549
  DBUG_ASSERT(table->file->inited == handler::NONE);
550 551

  *table_ptr=table->next;
552
  if (table->s->version != refresh_version ||
553 554 555 556 557 558 559
      thd->version != refresh_version || !table->db_stat)
  {
    VOID(hash_delete(&open_cache,(byte*) table));
    found_old_table=1;
  }
  else
  {
560
    if (table->s->flush_version != flush_version)
561
    {
562
      table->s->flush_version= flush_version;
563 564 565 566 567
      table->file->extra(HA_EXTRA_FLUSH);
    }
    else
    {
      // Free memory and reset for next loop
unknown's avatar
unknown committed
568
      table->file->reset();
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583
    }
    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
584 585 586 587 588 589
	/* Close and delete temporary tables */

void close_temporary(TABLE *table,bool delete_table)
{
  DBUG_ENTER("close_temporary");
  char path[FN_REFLEN];
590 591
  db_type table_type=table->s->db_type;
  strmov(path,table->s->path);
unknown's avatar
unknown committed
592 593 594 595 596 597 598 599 600 601 602 603
  free_io_cache(table);
  closefrm(table);
  my_free((char*) table,MYF(0));
  if (delete_table)
    rm_temporary_table(table_type, path);
  DBUG_VOID_RETURN;
}


void close_temporary_tables(THD *thd)
{
  TABLE *table,*next;
unknown's avatar
unknown committed
604 605 606
  char *query, *end;
  uint query_buf_size; 
  bool found_user_tables = 0;
unknown's avatar
unknown committed
607

608 609 610
  if (!thd->temporary_tables)
    return;
  
611
  LINT_INIT(end);
unknown's avatar
unknown committed
612
  query_buf_size= 50;   // Enough for DROP ... TABLE IF EXISTS
613

614
  for (table=thd->temporary_tables ; table ; table=table->next)
unknown's avatar
unknown committed
615 616 617 618 619 620
    /*
      We are going to add 4 ` around the db/table names, so 1 does not look
      enough; indeed it is enough, because table->key_length is greater (by 8,
      because of server_id and thread_id) than db||table.
    */
    query_buf_size+= table->s->key_length+1;
621

unknown's avatar
unknown committed
622
  if ((query = alloc_root(thd->mem_root, query_buf_size)))
unknown's avatar
unknown committed
623
    // Better add "if exists", in case a RESET MASTER has been done
unknown's avatar
unknown committed
624
    end=strmov(query, "DROP /*!40005 TEMPORARY */ TABLE IF EXISTS ");
625

unknown's avatar
unknown committed
626 627
  for (table=thd->temporary_tables ; table ; table=next)
  {
unknown's avatar
unknown committed
628
    if (query) // we might be out of memory, but this is not fatal
629
    {
unknown's avatar
unknown committed
630 631 632 633 634
      // skip temporary tables not created directly by the user
      if (table->s->table_name[0] != '#')
	found_user_tables = 1;
      end = strxmov(end,"`",table->s->db,"`.`",
                    table->s->table_name,"`,", NullS);
635
    }
unknown's avatar
unknown committed
636
    next=table->next;
unknown's avatar
unknown committed
637
    close_temporary(table, 1);
unknown's avatar
unknown committed
638
  }
unknown's avatar
unknown committed
639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655
  if (query && found_user_tables && mysql_bin_log.is_open())
  {
    /* The -1 is to remove last ',' */
    thd->clear_error();
    Query_log_event qinfo(thd, query, (ulong)(end-query)-1, 0, FALSE);
    /*
      Imagine the thread had created a temp table, then was doing a SELECT, and
      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);
  }
unknown's avatar
unknown committed
656 657 658 659
  thd->temporary_tables=0;
}


660
/*
661
  Find table in list.
662 663

  SYNOPSIS
664
    find_table_in_list()
665
    table		Pointer to table list
666
    offset		Offset to which list in table structure to use
667 668
    db_name		Data base name
    table_name		Table name
unknown's avatar
VIEW  
unknown committed
669

670 671 672
  NOTES:
    This is called by find_table_in_local_list() and
    find_table_in_global_list().
unknown's avatar
VIEW  
unknown committed
673 674 675 676 677 678

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

679 680 681 682
TABLE_LIST *find_table_in_list(TABLE_LIST *table,
                               uint offset,
                               const char *db_name,
                               const char *table_name)
unknown's avatar
VIEW  
unknown committed
683
{
684
  for (; table; table= *(TABLE_LIST **) ((char*) table + offset))
685
  {
686 687 688 689
    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;
690
  }
unknown's avatar
VIEW  
unknown committed
691 692 693 694
  return table;
}


695
/*
696
  Test that table is unique (It's only exists once in the table list)
697 698 699

  SYNOPSIS
    unique_table()
700
    table                 table which should be checked
701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718
    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
719 720

  RETURN
unknown's avatar
unknown committed
721 722
    found duplicate
    0 if table is unique
723 724
*/

unknown's avatar
unknown committed
725
TABLE_LIST* unique_table(TABLE_LIST *table, TABLE_LIST *table_list)
726
{
unknown's avatar
unknown committed
727
  TABLE_LIST *res;
728
  const char *d_name, *t_name;
unknown's avatar
unknown committed
729 730
  DBUG_ENTER("unique_table");
  DBUG_PRINT("enter", ("table alias: %s", table->alias));
731 732 733 734 735 736 737 738 739 740 741 742

  /*
    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)
743
  {
744 745 746 747 748 749 750 751 752
    /* 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);
753
  }
754 755
  d_name= table->db;
  t_name= table->table_name;
756 757

  DBUG_PRINT("info", ("real table: %s.%s", d_name, t_name));
unknown's avatar
unknown committed
758
  for (;;)
unknown's avatar
unknown committed
759
  {
760
    if (!(res= find_table_in_global_list(table_list, d_name, t_name)) ||
761 762
        (!res->table || res->table != table->table) &&
        (res->select_lex && !res->select_lex->exclude_from_table_unique_test))
763
      break;
764 765 766 767 768
    /*
      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).
    */
769
    table_list= res->next_global;
770 771
    DBUG_PRINT("info",
               ("found same copy of table or table which we should skip"));
unknown's avatar
unknown committed
772
  }
773
  DBUG_RETURN(res);
774 775 776
}


777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830
/*
  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
831 832 833 834 835 836
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
837 838
  int4store(key+key_length,thd->server_id);
  key_length += 4;
unknown's avatar
unknown committed
839
  int4store(key+key_length,thd->variables.pseudo_thread_id);
840
  key_length += 4;
841

unknown's avatar
unknown committed
842 843 844
  prev= &thd->temporary_tables;
  for (table=thd->temporary_tables ; table ; table=table->next)
  {
845 846
    if (table->s->key_length == key_length &&
	!memcmp(table->s->table_cache_key,key,key_length))
unknown's avatar
unknown committed
847 848 849 850 851 852 853 854 855 856 857 858 859 860
      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
861
  close_temporary(table, 1);
862
  if (thd->slave_thread)
863
    --slave_open_temp_tables;
unknown's avatar
unknown committed
864 865 866
  return 0;
}

unknown's avatar
unknown committed
867 868 869 870 871 872 873
/*
  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'.
*/
874

875
bool rename_temporary_table(THD* thd, TABLE *table, const char *db,
unknown's avatar
unknown committed
876 877 878
			    const char *table_name)
{
  char *key;
879 880
  TABLE_SHARE *share= table->s;

unknown's avatar
unknown committed
881
  if (!(key=(char*) alloc_root(&table->mem_root,
unknown's avatar
unknown committed
882
			       (uint) strlen(db)+
unknown's avatar
unknown committed
883
			       (uint) strlen(table_name)+6+4)))
unknown's avatar
unknown committed
884
    return 1;				/* purecov: inspected */
885
  share->key_length= (uint)
unknown's avatar
unknown committed
886 887
    (strmov((char*) (share->table_name= strmov(share->table_cache_key= key,
                                               db)+1),
888 889 890 891 892 893
	    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
894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923
  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];
924
  uint key_length= find->s->key_length;
unknown's avatar
unknown committed
925 926
  TABLE *start=list,**prev,*next;
  prev= &start;
927 928

  memcpy(key, find->s->table_cache_key, key_length);
unknown's avatar
unknown committed
929 930 931
  for (; list ; list=next)
  {
    next=list->next;
932 933
    if (list->s->key_length == key_length &&
	!memcmp(list->s->table_cache_key, key, key_length))
unknown's avatar
unknown committed
934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951
    {
      if (thd->locked_tables)
	mysql_lock_remove(thd, thd->locked_tables,list);
      VOID(hash_delete(&open_cache,(byte*) list)); // Close table
    }
    else
    {
      *prev=list;				// put in use list
      prev= &list->next;
    }
  }
  *prev=0;
  // Notify any 'refresh' threads
  pthread_cond_broadcast(&COND_refresh);
  return start;
}


952
/*
unknown's avatar
unknown committed
953
   When we call the following function we must have a lock on
954
   LOCK_open ; This lock will be unlocked on return.
unknown's avatar
unknown committed
955 956 957 958
*/

void wait_for_refresh(THD *thd)
{
959 960
  safe_mutex_assert_owner(&LOCK_open);

unknown's avatar
unknown committed
961 962 963 964 965 966
  /* 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
967 968
  if (!thd->killed)
    (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
unknown's avatar
unknown committed
969 970 971 972 973 974 975 976 977

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

978

979 980 981 982 983
TABLE *reopen_name_locked_table(THD* thd, TABLE_LIST* table_list)
{
  DBUG_ENTER("reopen_name_locked_table");
  if (thd->killed)
    DBUG_RETURN(0);
984 985
  TABLE *table;
  TABLE_SHARE *share;
unknown's avatar
unknown committed
986
  if (!(table = table_list->table))
987 988 989
    DBUG_RETURN(0);

  char* db = thd->db ? thd->db : table_list->db;
990
  char* table_name = table_list->table_name;
991 992 993 994 995
  char	key[MAX_DBKEY_LENGTH];
  uint	key_length;
  key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;

  pthread_mutex_lock(&LOCK_open);
996
  if (open_unireg_entry(thd, table, db, table_name, table_name, 0,
unknown's avatar
unknown committed
997
                        thd->mem_root) ||
998 999
      !(table->s->table_cache_key= memdup_root(&table->mem_root, (char*) key,
                                               key_length)))
unknown's avatar
unknown committed
1000
  {
1001
    delete table->triggers;
unknown's avatar
unknown committed
1002 1003 1004 1005
    closefrm(table);
    pthread_mutex_unlock(&LOCK_open);
    DBUG_RETURN(0);
  }
1006

1007 1008 1009 1010 1011
  share= table->s;
  share->db= share->table_cache_key;
  share->key_length=key_length;
  share->version=0;
  share->flush_version=0;
1012 1013 1014
  table->in_use = thd;
  check_unused();
  pthread_mutex_unlock(&LOCK_open);
unknown's avatar
unknown committed
1015 1016
  table->next = thd->open_tables;
  thd->open_tables = table;
1017 1018 1019
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
1020
  table->null_row= table->maybe_null= table->force_index= 0;
1021
  table->status=STATUS_NO_RECORD;
1022 1023
  table->keys_in_use_for_query= share->keys_in_use;
  table->used_keys= share->keys_for_keyread;
1024
  DBUG_RETURN(table);
1025 1026
}

unknown's avatar
unknown committed
1027

1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
/*
  Open a table.

  SYNOPSIS
    open_table()
      thd         Thread context
      table_list  Open first table in list
      refresh     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 is no version
                  number checking and 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.

  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
          all other tables and retry the open
    #     Success. Pointer to TABLE object for open table.
*/
unknown's avatar
unknown committed
1052 1053


unknown's avatar
VIEW  
unknown committed
1054
TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
1055
		  bool *refresh, uint flags)
unknown's avatar
unknown committed
1056 1057 1058 1059
{
  reg1	TABLE *table;
  char	key[MAX_DBKEY_LENGTH];
  uint	key_length;
unknown's avatar
VIEW  
unknown committed
1060
  char	*alias= table_list->alias;
unknown's avatar
unknown committed
1061 1062 1063 1064 1065 1066 1067
  DBUG_ENTER("open_table");

  /* find a unused table in the open table cache */
  if (refresh)
    *refresh=0;
  if (thd->killed)
    DBUG_RETURN(0);
unknown's avatar
VIEW  
unknown committed
1068
  key_length= (uint) (strmov(strmov(key, table_list->db)+1,
1069
			     table_list->table_name)-key)+1;
unknown's avatar
unknown committed
1070
  int4store(key + key_length, thd->server_id);
unknown's avatar
unknown committed
1071
  int4store(key + key_length + 4, thd->variables.pseudo_thread_id);
1072

unknown's avatar
VIEW  
unknown committed
1073
  if (!table_list->skip_temporary)
unknown's avatar
unknown committed
1074
  {
unknown's avatar
VIEW  
unknown committed
1075
    for (table= thd->temporary_tables; table ; table=table->next)
unknown's avatar
unknown committed
1076
    {
1077 1078
      if (table->s->key_length == key_length + TMP_TABLE_KEY_EXTRA &&
	  !memcmp(table->s->table_cache_key, key,
unknown's avatar
unknown committed
1079
		  key_length + TMP_TABLE_KEY_EXTRA))
unknown's avatar
unknown committed
1080
      {
1081 1082
	if (table->query_id == thd->query_id ||
            thd->prelocked_mode && table->query_id)
unknown's avatar
VIEW  
unknown committed
1083
	{
1084
	  my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
unknown's avatar
VIEW  
unknown committed
1085 1086 1087 1088 1089
	  DBUG_RETURN(0);
	}
	table->query_id= thd->query_id;
	table->clear_query_id= 1;
	thd->tmp_table_used= 1;
unknown's avatar
unknown committed
1090 1091
        DBUG_PRINT("info",("Using temporary table"));
        goto reset;
unknown's avatar
unknown committed
1092 1093 1094 1095
      }
    }
  }

1096
  if (thd->locked_tables || thd->prelocked_mode)
unknown's avatar
unknown committed
1097
  {						// Using table locks
1098
    TABLE *best_table= 0;
unknown's avatar
unknown committed
1099
    int best_distance= INT_MIN;
1100 1101 1102
    bool check_if_used= thd->prelocked_mode &&
                        ((int) table_list->lock_type >=
                         (int) TL_WRITE_ALLOW_WRITE);
unknown's avatar
unknown committed
1103 1104
    for (table=thd->open_tables; table ; table=table->next)
    {
1105
      if (table->s->key_length == key_length &&
1106
          !memcmp(table->s->table_cache_key, key, key_length))
unknown's avatar
unknown committed
1107
      {
1108 1109
        if (check_if_used && table->query_id &&
            table->query_id != thd->query_id)
1110
        {
1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154
          /*
            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;
            }
          }
1155
        }
unknown's avatar
unknown committed
1156
      }
unknown's avatar
unknown committed
1157
    }
1158 1159 1160 1161 1162 1163 1164
    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
1165 1166 1167 1168 1169 1170 1171 1172
    /*
      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];
      strxnmov(path, FN_REFLEN, mysql_data_home, "/", table_list->db, "/",
1173
               table_list->table_name, reg_ext, NullS);
unknown's avatar
unknown committed
1174 1175 1176
      (void) unpack_filename(path, path);
      if (mysql_frm_type(path) == FRMTYPE_VIEW)
      {
1177 1178
        TABLE tab;// will not be used (because it's VIEW) but have to be passed
        table= &tab;
unknown's avatar
unknown committed
1179 1180
        VOID(pthread_mutex_lock(&LOCK_open));
        if (open_unireg_entry(thd, table, table_list->db,
1181
                              table_list->table_name,
unknown's avatar
unknown committed
1182 1183 1184 1185 1186 1187 1188
                              alias, table_list, mem_root))
        {
          table->next=table->prev=table;
          free_cache_entry(table);
        }
        else
        {
1189
          DBUG_ASSERT(table_list->view != 0);
unknown's avatar
unknown committed
1190 1191 1192 1193 1194 1195
          VOID(pthread_mutex_unlock(&LOCK_open));
          DBUG_RETURN(0); // VIEW
        }
        VOID(pthread_mutex_unlock(&LOCK_open));
      }
    }
1196
    my_error(ER_TABLE_NOT_LOCKED, MYF(0), alias);
unknown's avatar
unknown committed
1197 1198
    DBUG_RETURN(0);
  }
unknown's avatar
unknown committed
1199

unknown's avatar
unknown committed
1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211
  VOID(pthread_mutex_lock(&LOCK_open));

  if (!thd->open_tables)
    thd->version=refresh_version;
  else if (thd->version != refresh_version && refresh)
  {
    /* Someone did a refresh while thread was opening tables */
    *refresh=1;
    VOID(pthread_mutex_unlock(&LOCK_open));
    DBUG_RETURN(0);
  }

1212
  /* close handler tables which are marked for flush */
unknown's avatar
unknown committed
1213 1214
  if (thd->handler_tables)
    mysql_ha_flush(thd, (TABLE_LIST*) NULL, MYSQL_HA_REOPEN_ON_USAGE);
1215

unknown's avatar
unknown committed
1216 1217 1218 1219
  for (table=(TABLE*) hash_search(&open_cache,(byte*) key,key_length) ;
       table && table->in_use ;
       table = (TABLE*) hash_next(&open_cache,(byte*) key,key_length))
  {
1220
    if (table->s->version != refresh_version)
unknown's avatar
unknown committed
1221
    {
1222 1223 1224 1225 1226 1227 1228
      if (flags & MYSQL_LOCK_IGNORE_FLUSH)
      {
        /* Force close at once after usage */
        thd->version= table->s->version;
        continue;
      }

unknown's avatar
unknown committed
1229
      /*
1230 1231
        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
1232
      */
unknown's avatar
unknown committed
1233
      close_old_data_files(thd,thd->open_tables,0,0);
unknown's avatar
unknown committed
1234 1235 1236
      if (table->in_use != thd)
	wait_for_refresh(thd);
      else
unknown's avatar
VIEW  
unknown committed
1237
      {
unknown's avatar
unknown committed
1238
	VOID(pthread_mutex_unlock(&LOCK_open));
unknown's avatar
VIEW  
unknown committed
1239
      }
unknown's avatar
unknown committed
1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
      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;
1255
    table->in_use= thd;
unknown's avatar
unknown committed
1256 1257 1258
  }
  else
  {
1259
    TABLE_SHARE *share;
unknown's avatar
unknown committed
1260
    /* Free cache if too big */
1261
    while (open_cache.records > table_cache_size && unused_tables)
unknown's avatar
unknown committed
1262 1263 1264 1265
      VOID(hash_delete(&open_cache,(byte*) unused_tables)); /* purecov: tested */

    /* make a new table */
    if (!(table=(TABLE*) my_malloc(sizeof(*table),MYF(MY_WME))))
1266 1267
    {
      VOID(pthread_mutex_unlock(&LOCK_open));
unknown's avatar
unknown committed
1268
      DBUG_RETURN(NULL);
1269
    }
1270
    if (open_unireg_entry(thd, table, table_list->db, table_list->table_name,
unknown's avatar
VIEW  
unknown committed
1271 1272
			  alias, table_list, mem_root) ||
	(!table_list->view && 
1273 1274 1275
	 !(table->s->table_cache_key= memdup_root(&table->mem_root,
                                                  (char*) key,
                                                  key_length))))
unknown's avatar
unknown committed
1276 1277 1278 1279 1280 1281
    {
      table->next=table->prev=table;
      free_cache_entry(table);
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(NULL);
    }
unknown's avatar
VIEW  
unknown committed
1282 1283 1284 1285 1286 1287
    if (table_list->view)
    {
      my_free((gptr)table, MYF(0));
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(0); // VIEW
    }
1288 1289 1290 1291 1292
    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
1293
    DBUG_PRINT("info", ("inserting table %p into the cache", table));
unknown's avatar
SCRUM  
unknown committed
1294
    VOID(my_hash_insert(&open_cache,(byte*) table));
unknown's avatar
unknown committed
1295 1296
  }

1297
  check_unused();				// Debugging call
unknown's avatar
VIEW  
unknown committed
1298

unknown's avatar
unknown committed
1299 1300 1301 1302 1303 1304 1305 1306 1307
  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
1308 1309
  if (thd->lex->need_correct_ident())
    table->alias_name_used= my_strcasecmp(table_alias_charset,
1310
                                          table->s->table_name, alias);
unknown's avatar
unknown committed
1311
  /* Fix alias if table name changes */
1312
  if (strcmp(table->alias, alias))
unknown's avatar
unknown committed
1313
  {
unknown's avatar
unknown committed
1314
    uint length=(uint) strlen(alias)+1;
1315 1316 1317
    table->alias= (char*) my_realloc((char*) table->alias, length,
                                     MYF(MY_WME));
    memcpy((char*) table->alias, alias, length);
unknown's avatar
unknown committed
1318 1319 1320 1321 1322
  }
  /* These variables are also set in reopen_table() */
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
1323
  table->null_row= table->maybe_null= table->force_index= 0;
unknown's avatar
unknown committed
1324
  table->status=STATUS_NO_RECORD;
1325
  table->keys_in_use_for_query= table->s->keys_in_use;
1326
  table->insert_values= 0;
1327
  table->used_keys= table->s->keys_for_keyread;
unknown's avatar
unknown committed
1328
  if (table->timestamp_field)
1329
    table->timestamp_field_type= table->timestamp_field->get_auto_set_type();
unknown's avatar
VIEW  
unknown committed
1330
  table_list->updatable= 1; // It is not derived table nor non-updatable VIEW
unknown's avatar
unknown committed
1331
  DBUG_ASSERT(table->key_read == 0);
unknown's avatar
unknown committed
1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342
  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)
  {
1343 1344
    if (table->s->key_length == key_length &&
	!memcmp(table->s->table_cache_key,key,key_length))
unknown's avatar
unknown committed
1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360
      return table;
  }
  return(0);
}


/****************************************************************************
** Reopen an table because the definition has changed. The date file for the
** table is already closed.
** Returns 0 if ok.
** If table can't be reopened, the entry is unchanged.
****************************************************************************/

bool reopen_table(TABLE *table,bool locked)
{
  TABLE tmp;
1361 1362 1363
  char *db= table->s->table_cache_key;
  const char *table_name= table->s->table_name;
  bool error= 1;
unknown's avatar
unknown committed
1364 1365 1366 1367 1368 1369 1370
  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",
1371
		    table->alias);
unknown's avatar
unknown committed
1372 1373 1374
#endif
  if (!locked)
    VOID(pthread_mutex_lock(&LOCK_open));
1375
  safe_mutex_assert_owner(&LOCK_open);
unknown's avatar
unknown committed
1376

1377
  if (open_unireg_entry(table->in_use, &tmp, db, table_name,
1378
			table->alias, 0, table->in_use->mem_root))
unknown's avatar
unknown committed
1379 1380 1381
    goto end;
  free_io_cache(table);

1382 1383
  if (!(tmp.s->table_cache_key= memdup_root(&tmp.mem_root,db,
                                            table->s->key_length)))
unknown's avatar
unknown committed
1384
  {
1385
    delete tmp.triggers;
unknown's avatar
unknown committed
1386 1387 1388
    closefrm(&tmp);				// End of memory
    goto end;
  }
1389
  tmp.s->db= tmp.s->table_cache_key;
unknown's avatar
unknown committed
1390

1391
  /* This list copies variables set by open_table */
unknown's avatar
unknown committed
1392 1393 1394 1395
  tmp.tablenr=		table->tablenr;
  tmp.used_fields=	table->used_fields;
  tmp.const_table=	table->const_table;
  tmp.null_row=		table->null_row;
1396
  tmp.maybe_null=	table->maybe_null;
unknown's avatar
unknown committed
1397
  tmp.status=		table->status;
1398 1399
  tmp.keys_in_use_for_query= tmp.s->keys_in_use;
  tmp.used_keys= 	tmp.s->keys_for_keyread;
1400
  tmp.force_index=	tmp.force_index;
1401 1402

  /* Get state */
1403
  tmp.s->key_length=	table->s->key_length;
1404 1405
  tmp.in_use=    	table->in_use;
  tmp.reginfo.lock_type=table->reginfo.lock_type;
1406 1407
  tmp.s->version=	refresh_version;
  tmp.s->tmp_table=	table->s->tmp_table;
unknown's avatar
unknown committed
1408 1409
  tmp.grant=		table->grant;

1410
  /* Replace table in open list */
1411 1412
  tmp.next=		table->next;
  tmp.prev=		table->prev;
1413

1414
  delete table->triggers;
unknown's avatar
unknown committed
1415 1416 1417
  if (table->file)
    VOID(closefrm(table));		// close file, free everything

1418 1419
  *table= tmp;
  table->s= &table->share_not_to_be_used;
unknown's avatar
unknown committed
1420 1421
  table->file->change_table_ptr(table);

1422
  DBUG_ASSERT(table->alias != 0);
unknown's avatar
unknown committed
1423 1424
  for (field=table->field ; *field ; field++)
  {
unknown's avatar
unknown committed
1425
    (*field)->table= (*field)->orig_table= table;
1426
    (*field)->table_name= &table->alias;
unknown's avatar
unknown committed
1427
  }
1428
  for (key=0 ; key < table->s->keys ; key++)
unknown's avatar
unknown committed
1429
    for (part=0 ; part < table->key_info[key].usable_key_parts ; part++)
unknown's avatar
unknown committed
1430
      table->key_info[key].key_part[part].field->table= table;
unknown's avatar
unknown committed
1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451
  VOID(pthread_cond_broadcast(&COND_refresh));
  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)
  {
1452 1453
    if (!strcmp(table->s->table_name, table_name) &&
	!strcmp(table->s->db, db))
unknown's avatar
unknown committed
1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471
    {
      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");
1472 1473
  safe_mutex_assert_owner(&LOCK_open);

unknown's avatar
unknown committed
1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497
  if (!thd->open_tables)
    DBUG_RETURN(0);

  TABLE *table,*next,**prev;
  TABLE **tables,**tables_ptr;			// For locks
  bool error=0;
  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)))
    {
1498
      my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
unknown's avatar
unknown committed
1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509
      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)
      {
1510
	table->s->version=0;
unknown's avatar
unknown committed
1511 1512 1513 1514 1515 1516 1517 1518 1519
	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;
1520
    if ((lock= mysql_lock_tables(thd, tables, (uint) (tables_ptr - tables), 0)))
unknown's avatar
unknown committed
1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541
    {
      thd->locked_tables=mysql_lock_merge(thd->locked_tables,lock);
    }
    else
      error=1;
  }
  if (get_locks && tables)
  {
    my_afree((gptr) tables);
  }
  VOID(pthread_cond_broadcast(&COND_refresh)); // Signal to refresh
  *prev=0;
  DBUG_RETURN(error);
}

/*
  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
1542 1543
void close_old_data_files(THD *thd, TABLE *table, bool abort_locks,
			  bool send_refresh)
unknown's avatar
unknown committed
1544
{
unknown's avatar
unknown committed
1545 1546
  DBUG_ENTER("close_old_data_files");
  bool found=send_refresh;
unknown's avatar
unknown committed
1547 1548
  for (; table ; table=table->next)
  {
1549
    if (table->s->version != refresh_version)
unknown's avatar
unknown committed
1550 1551 1552
    {
      found=1;
      if (!abort_locks)				// If not from flush tables
1553
	table->s->version= refresh_version;	// Let other threads use table
unknown's avatar
unknown committed
1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568
      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)
    VOID(pthread_cond_broadcast(&COND_refresh)); // Signal to refresh
unknown's avatar
unknown committed
1569
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1570 1571 1572 1573 1574 1575 1576 1577 1578
}


/*
  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
1579
bool table_is_used(TABLE *table, bool wait_for_name_lock)
unknown's avatar
unknown committed
1580 1581 1582
{
  do
  {
1583 1584
    char *key= table->s->table_cache_key;
    uint key_length= table->s->key_length;
unknown's avatar
unknown committed
1585 1586
    for (TABLE *search=(TABLE*) hash_search(&open_cache,
					    (byte*) key,key_length) ;
unknown's avatar
unknown committed
1587 1588 1589 1590
	 search ;
	 search = (TABLE*) hash_next(&open_cache,(byte*) key,key_length))
    {
      if (search->locked_by_flush ||
unknown's avatar
unknown committed
1591
	  search->locked_by_name && wait_for_name_lock ||
1592
	  search->db_stat && search->s->version < refresh_version)
unknown's avatar
unknown committed
1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608
	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
1609
  while (!thd->killed)
unknown's avatar
unknown committed
1610
  {
unknown's avatar
unknown committed
1611 1612
    thd->some_tables_deleted=0;
    close_old_data_files(thd,thd->open_tables,0,dropping_tables != 0);
1613
    mysql_ha_flush(thd, (TABLE_LIST*) NULL, MYSQL_HA_REOPEN_ON_USAGE);
unknown's avatar
unknown committed
1614 1615
    if (!table_is_used(thd->open_tables,1))
      break;
1616
    (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
unknown's avatar
unknown committed
1617 1618 1619 1620 1621 1622 1623
  }
  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
1624
    thd->version= refresh_version;
1625
    result=reopen_tables(thd,0,0);
1626
  }
unknown's avatar
unknown committed
1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639
  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;
1640
  for (table= thd->open_tables; table ; table=next)
unknown's avatar
unknown committed
1641 1642
  {
    next=table->next;
1643 1644
    if (!strcmp(table->s->table_name, table_name) &&
	!strcmp(table->s->db, db))
unknown's avatar
unknown committed
1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667
    {
      mysql_lock_remove(thd, thd->locked_tables,table);
      VOID(hash_delete(&open_cache,(byte*) table));
      found=1;
    }
    else
    {
      *prev=table;
      prev= &table->next;
    }
  }
  *prev=0;
  if (found)
    VOID(pthread_cond_broadcast(&COND_refresh)); // Signal to refresh
  if (thd->locked_tables && thd->locked_tables->table_count == 0)
  {
    my_free((gptr) thd->locked_tables,MYF(0));
    thd->locked_tables=0;
  }
  return found;
}


1668 1669 1670 1671 1672
/*
  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
1673 1674 1675 1676

void abort_locked_tables(THD *thd,const char *db, const char *table_name)
{
  TABLE *table;
1677
  for (table= thd->open_tables; table ; table= table->next)
unknown's avatar
unknown committed
1678
  {
1679 1680
    if (!strcmp(table->s->table_name,table_name) &&
	!strcmp(table->s->db, db))
1681
    {
unknown's avatar
unknown committed
1682
      mysql_lock_abort(thd,table);
1683 1684
      break;
    }
unknown's avatar
unknown committed
1685 1686 1687
  }
}

1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698

/*
  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
1699
    table_desc		TABLE_LIST descriptor (used with views)
unknown's avatar
VIEW  
unknown committed
1700
    mem_root		temporary mem_root for parsing
1701 1702 1703 1704 1705 1706 1707

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

  RETURN
    0	ok
    #	Error
unknown's avatar
unknown committed
1708
*/
1709
static int open_unireg_entry(THD *thd, TABLE *entry, const char *db,
unknown's avatar
VIEW  
unknown committed
1710 1711
			     const char *name, const char *alias,
			     TABLE_LIST *table_desc, MEM_ROOT *mem_root)
unknown's avatar
unknown committed
1712 1713
{
  char path[FN_REFLEN];
1714
  int error;
unknown's avatar
unknown committed
1715
  uint discover_retry_count= 0;
unknown's avatar
unknown committed
1716 1717
  DBUG_ENTER("open_unireg_entry");

1718
  strxmov(path, mysql_data_home, "/", db, "/", name, NullS);
1719
  while ((error= openfrm(thd, path, alias,
unknown's avatar
VIEW  
unknown committed
1720 1721
		         (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
			         HA_GET_INDEX | HA_TRY_READ_ONLY |
1722
                                 NO_ERR_ON_NEW_FRM),
unknown's avatar
VIEW  
unknown committed
1723 1724 1725
		      READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
		      thd->open_options, entry)) &&
      (error != 5 ||
unknown's avatar
unknown committed
1726 1727 1728 1729 1730 1731
       (fn_format(path, path, 0, reg_ext, MY_UNPACK_FILENAME),
        open_new_frm(path, alias, db, name,
                     (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
1732

unknown's avatar
unknown committed
1733
  {
1734
    if (!entry->s || !entry->s->crashed)
unknown's avatar
unknown committed
1735 1736
    {
      /*
1737 1738 1739 1740
        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
1741 1742
      */
      if (discover_retry_count++ != 0)
unknown's avatar
unknown committed
1743
        goto err;
1744
      if (ha_create_table_from_engine(thd, db, name) > 0)
1745 1746 1747
      {
        /* Give right error message */
        thd->clear_error();
unknown's avatar
unknown committed
1748
        DBUG_PRINT("error", ("Discovery of %s/%s failed", db, name));
1749 1750 1751 1752 1753
        my_printf_error(ER_UNKNOWN_ERROR,
                        "Failed to open '%-.64s', error while "
                        "unpacking from engine",
                        MYF(0), name);

unknown's avatar
unknown committed
1754
        goto err;
1755
      }
unknown's avatar
unknown committed
1756

unknown's avatar
unknown committed
1757
      mysql_reset_errors(thd, 1);    // Clear warnings
1758
      thd->clear_error();            // Clear error message
unknown's avatar
unknown committed
1759 1760
      continue;
    }
1761

unknown's avatar
unknown committed
1762
    // Code below is for repairing a crashed file
1763
    TABLE_LIST table_list;
unknown's avatar
unknown committed
1764
    bzero((char*) &table_list, sizeof(table_list)); // just for safe
1765
    table_list.db=(char*) db;
1766
    table_list.table_name=(char*) name;
unknown's avatar
unknown committed
1767

1768 1769
    safe_mutex_assert_owner(&LOCK_open);

1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782
    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
1783 1784
    thd->clear_error();				// Clear error message
    error= 0;
1785
    if (openfrm(thd, path, alias,
1786 1787 1788 1789
		(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,
1790
		entry) || ! entry->file ||
1791 1792
	(entry->file->is_crashed() && entry->file->check_and_repair(thd)))
    {
unknown's avatar
unknown committed
1793
      /* Give right error message */
unknown's avatar
unknown committed
1794
      thd->clear_error();
1795
      my_error(ER_NOT_KEYFILE, MYF(0), name, my_errno);
unknown's avatar
unknown committed
1796
      sql_print_error("Couldn't repair table: %s.%s",db,name);
1797 1798
      if (entry->file)
	closefrm(entry);
1799 1800
      error=1;
    }
1801
    else
unknown's avatar
unknown committed
1802
      thd->clear_error();			// Clear error message
unknown's avatar
unknown committed
1803
    pthread_mutex_lock(&LOCK_open);
1804
    unlock_table_name(thd,&table_list);
unknown's avatar
unknown committed
1805

1806 1807
    if (error)
      goto err;
unknown's avatar
unknown committed
1808 1809
    break;
  }
unknown's avatar
VIEW  
unknown committed
1810 1811 1812 1813

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

1814 1815 1816 1817 1818 1819 1820 1821 1822
  /*
    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;

1823
  if (Table_triggers_list::check_n_load(thd, db, name, entry, 0))
1824 1825
    goto err;

unknown's avatar
unknown committed
1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840
  /*
    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);
1841
        Query_log_event qinfo(thd, query, (ulong)(end-query), 0, FALSE);
unknown's avatar
unknown committed
1842 1843 1844 1845 1846 1847 1848 1849 1850 1851
        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
1852
        sql_print_error("When opening HEAP table, could not allocate \
unknown's avatar
unknown committed
1853
memory to write 'DELETE FROM `%s`.`%s`' to the binary log",db,name);
1854
        delete entry->triggers;
unknown's avatar
unknown committed
1855 1856 1857 1858 1859
        if (entry->file)
          closefrm(entry);
        goto err;
      }
    }
unknown's avatar
unknown committed
1860 1861
  }
  DBUG_RETURN(0);
1862
err:
1863
  /* Hide "Table doesn't exist" errors if table belong to view */
unknown's avatar
unknown committed
1864 1865
  if (thd->net.last_errno == ER_NO_SUCH_TABLE &&
      table_desc && table_desc->belong_to_view)
1866
  {
unknown's avatar
unknown committed
1867
    TABLE_LIST *view= table_desc->belong_to_view;
1868 1869 1870
    thd->clear_error();
    my_error(ER_VIEW_INVALID, MYF(0), view->view_db.str, view->view_name.str);
  }
1871
  DBUG_RETURN(1);
unknown's avatar
unknown committed
1872 1873
}

1874

unknown's avatar
unknown committed
1875 1876 1877 1878 1879 1880
/*
  Open all tables in list

  SYNOPSIS
    open_tables()
    thd - thread handler
1881
    start - list of tables in/out
unknown's avatar
unknown committed
1882
    counter - number of opened tables will be return using this parameter
1883 1884 1885
    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
1886

1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897
  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
1898 1899 1900 1901 1902
  RETURN
    0  - OK
    -1 - error
*/

1903
int open_tables(THD *thd, TABLE_LIST **start, uint *counter, uint flags)
unknown's avatar
unknown committed
1904 1905 1906 1907
{
  TABLE_LIST *tables;
  bool refresh;
  int result=0;
unknown's avatar
VIEW  
unknown committed
1908
  MEM_ROOT new_frm_mem;
1909 1910 1911
  /* Also used for indicating that prelocking is need */
  TABLE_LIST **query_tables_last_own;
  DBUG_ENTER("open_tables");
unknown's avatar
VIEW  
unknown committed
1912 1913 1914 1915 1916
  /*
    temporary mem_root for new .frm parsing.
    TODO: variables for size
  */
  init_alloc_root(&new_frm_mem, 8024, 8024);
unknown's avatar
unknown committed
1917

1918
  thd->current_tablenr= 0;
unknown's avatar
unknown committed
1919
 restart:
unknown's avatar
unknown committed
1920
  *counter= 0;
1921
  query_tables_last_own= 0;
unknown's avatar
unknown committed
1922
  thd->proc_info="Opening tables";
1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941

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

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

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

    NOTE: The above notes may be out of date. Please wait for psergey to 
          document new prelocked behavior.
1945
  */
1946
  
1947 1948
  if (!thd->prelocked_mode && !thd->lex->requires_prelocking() && 
      thd->lex->sroutines_list.elements)
1949
  {
1950
    bool first_no_prelocking, need_prelocking;
1951
    TABLE_LIST **save_query_tables_last= thd->lex->query_tables_last;
1952 1953

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

1956 1957 1958
    if ((sp_cache_routines_and_add_tables(thd, thd->lex,
                                         first_no_prelocking) ||
        *start) && need_prelocking)
1959 1960 1961 1962 1963 1964 1965
    {
      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
1966
  {
unknown's avatar
unknown committed
1967 1968 1969 1970 1971 1972
    /*
      Ignore placeholders for derived tables. After derived tables
      processing, link to created temporary table will be put here.
     */
    if (tables->derived)
      continue;
1973 1974 1975 1976 1977 1978
    if (tables->schema_table)
    {
      if (!mysql_schema_table(thd, thd->lex, tables))
        continue;
      DBUG_RETURN(-1);
    }
unknown's avatar
unknown committed
1979
    (*counter)++;
1980
    
unknown's avatar
unknown committed
1981
    if (!tables->table &&
1982
	!(tables->table= open_table(thd, tables, &new_frm_mem, &refresh, flags)))
unknown's avatar
unknown committed
1983
    {
unknown's avatar
VIEW  
unknown committed
1984
      free_root(&new_frm_mem, MYF(MY_KEEP_PREALLOC));
1985

unknown's avatar
VIEW  
unknown committed
1986 1987
      if (tables->view)
      {
1988
        /* VIEW placeholder */
unknown's avatar
VIEW  
unknown committed
1989
	(*counter)--;
1990 1991 1992 1993 1994 1995 1996

        /* 
          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
1997 1998 1999
          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.
2000
        */
unknown's avatar
unknown committed
2001
        if (query_tables_last_own == &(tables->next_global) &&
2002 2003 2004
            tables->view->query_tables)
          query_tables_last_own= tables->view->query_tables_last;
        
2005 2006 2007 2008 2009
        /*
          Again if needed we have to get cache all routines used by this view
          and add tables used by them to table list.
        */
        if (!thd->prelocked_mode && !thd->lex->requires_prelocking() &&
2010
            tables->view->sroutines.records)
2011 2012 2013 2014
        {
          /* We have at least one table in TL here */
          if (!query_tables_last_own)
            query_tables_last_own= thd->lex->query_tables_last;
2015 2016
          sp_cache_routines_and_add_tables_for_view(thd, thd->lex,
                                                    tables->view);
2017 2018
        }
        /* Cleanup hashes because destructo for this LEX is never called */
2019
        hash_free(&tables->view->sroutines);
2020
	continue;
unknown's avatar
VIEW  
unknown committed
2021 2022
      }

unknown's avatar
unknown committed
2023 2024 2025 2026
      if (refresh)				// Refresh in progress
      {
	/* close all 'old' tables used by this thread */
	pthread_mutex_lock(&LOCK_open);
2027 2028
	// if query_id is not reset, we will get an error
	// re-opening a temp table
unknown's avatar
unknown committed
2029 2030 2031
	thd->version=refresh_version;
	TABLE **prev_table= &thd->open_tables;
	bool found=0;
2032 2033 2034 2035 2036 2037
        /*
          QQ: What we should do if we have started building of table list
          for prelocking ??? Probably throw it away ? But before we should
          mark all temporary tables as free? How about locked ?
        */
	for (TABLE_LIST *tmp= *start; tmp; tmp= tmp->next_global)
unknown's avatar
unknown committed
2038
	{
2039
	  /* Close normal (not temporary) changed tables */
2040
	  if (tmp->table && ! tmp->table->s->tmp_table)
unknown's avatar
unknown committed
2041
	  {
2042
	    if (tmp->table->s->version != refresh_version ||
unknown's avatar
unknown committed
2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056
		! tmp->table->db_stat)
	    {
	      VOID(hash_delete(&open_cache,(byte*) tmp->table));
	      tmp->table=0;
	      found=1;
	    }
	    else
	    {
	      *prev_table= tmp->table;		// Relink open list
	      prev_table= &tmp->table->next;
	    }
	  }
	}
	*prev_table=0;
2057
	pthread_mutex_unlock(&LOCK_open);
unknown's avatar
unknown committed
2058 2059 2060 2061 2062 2063 2064
	if (found)
	  VOID(pthread_cond_broadcast(&COND_refresh)); // Signal to refresh
	goto restart;
      }
      result= -1;				// Fatal error
      break;
    }
unknown's avatar
VIEW  
unknown committed
2065
    else
2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080
    {
      /*
        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)
            query_tables_last_own= thd->lex->query_tables_last;
2081 2082
        sp_cache_routines_and_add_tables_for_triggers(thd, thd->lex,
                                                      tables->table->triggers);
2083
      }
unknown's avatar
VIEW  
unknown committed
2084
      free_root(&new_frm_mem, MYF(MY_KEEP_PREALLOC));
2085
    }
unknown's avatar
VIEW  
unknown committed
2086

2087
    if (tables->lock_type != TL_UNLOCK && ! thd->locked_tables)
unknown's avatar
unknown committed
2088 2089 2090 2091
      tables->table->reginfo.lock_type=tables->lock_type;
    tables->table->grant= tables->grant;
  }
  thd->proc_info=0;
2092
  free_root(&new_frm_mem, MYF(0));              // Free pre-alloced block
2093 2094 2095 2096

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

unknown's avatar
unknown committed
2097 2098 2099 2100
  DBUG_RETURN(result);
}


unknown's avatar
unknown committed
2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123
/*
  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)
  {
2124
    my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),table->alias);
unknown's avatar
unknown committed
2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144
    DBUG_RETURN(1);
  }
  if ((error=table->file->start_stmt(thd)))
  {
    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

2145 2146 2147 2148 2149
  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
2150 2151 2152 2153 2154 2155 2156 2157 2158
  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
2159 2160 2161 2162 2163 2164 2165
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";
2166
  thd->current_tablenr= 0;
2167 2168
  /* open_ltable can be used only for BASIC TABLEs */
  table_list->required_type= FRMTYPE_TABLE;
2169
  while (!(table= open_table(thd, table_list, thd->mem_root, &refresh, 0)) &&
2170
         refresh)
2171
    ;
unknown's avatar
unknown committed
2172

unknown's avatar
unknown committed
2173 2174
  if (table)
  {
unknown's avatar
unknown committed
2175
#if defined( __WIN__) || defined(OS2)
2176
    /* Win32 can't drop a file that is open */
unknown's avatar
unknown committed
2177
    if (lock_type == TL_WRITE_ALLOW_READ)
2178 2179 2180
    {
      lock_type= TL_WRITE;
    }
unknown's avatar
unknown committed
2181
#endif /* __WIN__ || OS2 */
unknown's avatar
unknown committed
2182 2183
    table_list->lock_type= lock_type;
    table_list->table=	   table;
unknown's avatar
unknown committed
2184 2185 2186
    table->grant= table_list->grant;
    if (thd->locked_tables)
    {
unknown's avatar
unknown committed
2187 2188 2189 2190 2191
      if (check_lock_and_start_stmt(thd, table, lock_type))
	table= 0;
    }
    else
    {
2192
      DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
unknown's avatar
unknown committed
2193
      if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)
2194
	if (! (thd->lock= mysql_lock_tables(thd, &table_list->table, 1, 0)))
unknown's avatar
unknown committed
2195
	  table= 0;
unknown's avatar
unknown committed
2196 2197 2198 2199 2200 2201
    }
  }
  thd->proc_info=0;
  DBUG_RETURN(table);
}

unknown's avatar
unknown committed
2202

unknown's avatar
unknown committed
2203
/*
unknown's avatar
unknown committed
2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216
  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
2217
    The lock will automaticaly be freed by close_thread_tables()
unknown's avatar
unknown committed
2218 2219
*/

unknown's avatar
unknown committed
2220
int simple_open_n_lock_tables(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
2221
{
unknown's avatar
unknown committed
2222 2223
  DBUG_ENTER("simple_open_n_lock_tables");
  uint counter;
2224 2225
  if (open_tables(thd, &tables, &counter, 0) ||
      lock_tables(thd, tables, counter))
unknown's avatar
unknown committed
2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240
    DBUG_RETURN(-1);				/* purecov: inspected */
  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
2241 2242
    FALSE - ok
    TRUE  - error
unknown's avatar
unknown committed
2243 2244

  NOTE
2245
    The lock will automaticaly be freed by close_thread_tables()
unknown's avatar
unknown committed
2246 2247
*/

unknown's avatar
unknown committed
2248
bool open_and_lock_tables(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
2249 2250
{
  uint counter;
unknown's avatar
unknown committed
2251
  DBUG_ENTER("open_and_lock_tables");
2252
  if (open_tables(thd, &tables, &counter, 0) ||
unknown's avatar
unknown committed
2253
      lock_tables(thd, tables, counter) ||
unknown's avatar
unknown committed
2254 2255 2256
      mysql_handle_derived(thd->lex, &mysql_derived_prepare) ||
      (thd->fill_derived_tables() &&
       mysql_handle_derived(thd->lex, &mysql_derived_filling)))
unknown's avatar
unknown committed
2257
    DBUG_RETURN(TRUE); /* purecov: inspected */
unknown's avatar
unknown committed
2258
  DBUG_RETURN(0);
unknown's avatar
unknown committed
2259 2260 2261
}


2262 2263 2264 2265 2266 2267
/*
  Open all tables in list and process derived tables

  SYNOPSIS
    open_normal_and_derived_tables
    thd		- thread handler
2268
    tables	- list of tables for open
2269 2270 2271
    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.
2272 2273 2274 2275 2276 2277 2278 2279 2280 2281

  RETURN
    FALSE - ok
    TRUE  - error

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

2282
bool open_normal_and_derived_tables(THD *thd, TABLE_LIST *tables, uint flags)
2283 2284 2285
{
  uint counter;
  DBUG_ENTER("open_normal_and_derived_tables");
unknown's avatar
unknown committed
2286
  DBUG_ASSERT(!thd->fill_derived_tables());
2287
  if (open_tables(thd, &tables, &counter, flags) ||
unknown's avatar
unknown committed
2288 2289 2290
      mysql_handle_derived(thd->lex, &mysql_derived_prepare))
    DBUG_RETURN(TRUE); /* purecov: inspected */
  DBUG_RETURN(0);
2291 2292 2293
}


2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314
/*
  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
2315 2316 2317 2318 2319 2320 2321
/*
  Lock all tables in list

  SYNOPSIS
    lock_tables()
    thd			Thread handler
    tables		Tables to lock
unknown's avatar
unknown committed
2322
    count		umber of opened tables
unknown's avatar
unknown committed
2323

2324 2325 2326 2327 2328
  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.

2329 2330 2331 2332
    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
2333 2334 2335 2336 2337
  RETURN VALUES
   0	ok
   -1	Error
*/

unknown's avatar
unknown committed
2338
int lock_tables(THD *thd, TABLE_LIST *tables, uint count)
unknown's avatar
unknown committed
2339
{
unknown's avatar
unknown committed
2340
  TABLE_LIST *table;
2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353

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

unknown's avatar
unknown committed
2354
  if (!tables)
2355
    DBUG_RETURN(0);
unknown's avatar
unknown committed
2356

2357 2358 2359 2360 2361 2362 2363 2364 2365 2366
  /*
    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
2367
  {
2368
    DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
unknown's avatar
unknown committed
2369
    TABLE **start,**ptr;
2370

2371
    if (!(ptr=start=(TABLE**) thd->alloc(sizeof(TABLE*)*count)))
2372
      DBUG_RETURN(-1);
unknown's avatar
VIEW  
unknown committed
2373
    for (table= tables; table; table= table->next_global)
unknown's avatar
unknown committed
2374
    {
unknown's avatar
unknown committed
2375
      if (!table->placeholder() && !table->schema_table)
unknown's avatar
unknown committed
2376 2377
	*(ptr++)= table->table;
    }
2378 2379 2380 2381 2382 2383 2384 2385

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

2386
    if (! (thd->lock= mysql_lock_tables(thd, start, (uint) (ptr - start), 0)))
2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432
    {
      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);
2433
      DBUG_PRINT("info",("prelocked_mode= PRELOCKED"));
2434 2435
      thd->prelocked_mode= PRELOCKED;
    }
unknown's avatar
unknown committed
2436
  }
unknown's avatar
unknown committed
2437 2438
  else
  {
2439 2440
    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
2441
    {
2442
      if (!table->placeholder() && !table->schema_table &&
unknown's avatar
unknown committed
2443
	  check_lock_and_start_stmt(thd, table->table, table->lock_type))
unknown's avatar
unknown committed
2444
      {
unknown's avatar
unknown committed
2445
	ha_rollback_stmt(thd);
2446
	DBUG_RETURN(-1);
unknown's avatar
unknown committed
2447 2448
      }
    }
2449 2450 2451 2452 2453 2454 2455 2456
    /*
      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);
2457
      DBUG_PRINT("info", ("thd->prelocked_mode= PRELOCKED_UNDER_LOCK_TABLES"));
2458 2459
      thd->prelocked_mode= PRELOCKED_UNDER_LOCK_TABLES;
    }
unknown's avatar
unknown committed
2460
  }
2461
  DBUG_RETURN(0);
unknown's avatar
unknown committed
2462 2463
}

unknown's avatar
unknown committed
2464

unknown's avatar
unknown committed
2465
/*
unknown's avatar
unknown committed
2466 2467 2468
  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
2469 2470 2471 2472 2473 2474
*/

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

unknown's avatar
unknown committed
2478 2479 2480 2481 2482 2483 2484
  /*
    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
2485
  if (!(tmp_table=(TABLE*) my_malloc(sizeof(*tmp_table)+(uint) strlen(db)+
unknown's avatar
unknown committed
2486
				     (uint) strlen(table_name)+6+4,
unknown's avatar
unknown committed
2487 2488 2489
				     MYF(MY_WME))))
    DBUG_RETURN(0);				/* purecov: inspected */

2490
  if (openfrm(thd, path, table_name,
unknown's avatar
unknown committed
2491
	      (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE | HA_GET_INDEX),
unknown's avatar
unknown committed
2492
	      READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
2493
	      ha_open_options,
unknown's avatar
unknown committed
2494 2495
	      tmp_table))
  {
2496
    my_free((char*) tmp_table,MYF(0));
unknown's avatar
unknown committed
2497 2498 2499
    DBUG_RETURN(0);
  }

2500
  share= tmp_table->s;
unknown's avatar
unknown committed
2501
  tmp_table->reginfo.lock_type=TL_WRITE;	 // Simulate locked
2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513
  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
2514
	    thd->variables.pseudo_thread_id);
2515
  share->key_length+= 4;
2516

unknown's avatar
unknown committed
2517 2518 2519 2520
  if (link_in_list)
  {
    tmp_table->next=thd->temporary_tables;
    thd->temporary_tables=tmp_table;
unknown's avatar
unknown committed
2521 2522
    if (thd->slave_thread)
      slave_open_temp_tables++;
unknown's avatar
unknown committed
2523 2524 2525 2526 2527 2528 2529 2530
  }
  DBUG_RETURN(tmp_table);
}


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

unknown's avatar
unknown committed
2533 2534 2535 2536 2537 2538 2539
  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
  handler *file=get_new_handler((TABLE*) 0, base);
  if (file && file->delete_table(path))
unknown's avatar
unknown committed
2540
  {
unknown's avatar
unknown committed
2541
    error=1;
unknown's avatar
unknown committed
2542 2543
    sql_print_warning("Could not remove tmp table: '%s', error: %d",
                      path, my_errno);
unknown's avatar
unknown committed
2544
  }
unknown's avatar
unknown committed
2545
  delete file;
2546
  DBUG_RETURN(error);
unknown's avatar
unknown committed
2547 2548 2549 2550
}


/*****************************************************************************
unknown's avatar
unknown committed
2551 2552 2553 2554 2555 2556
* 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
2557 2558
******************************************************************************/

unknown's avatar
unknown committed
2559
/* Special Field pointers as return values of find_field_in_XXX functions. */
unknown's avatar
unknown committed
2560 2561
Field *not_found_field= (Field*) 0x1;
Field *view_ref_found= (Field*) 0x2; 
unknown's avatar
VIEW  
unknown committed
2562

unknown's avatar
unknown committed
2563 2564
#define WRONG_GRANT (Field*) -1

unknown's avatar
unknown committed
2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579
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
2580 2581

/*
unknown's avatar
unknown committed
2582
  Find a field by name in a view that uses merge algorithm.
unknown's avatar
VIEW  
unknown committed
2583 2584

  SYNOPSIS
unknown's avatar
unknown committed
2585
    find_field_in_view()
unknown's avatar
VIEW  
unknown committed
2586
    thd				thread handler
unknown's avatar
unknown committed
2587
    table_list			view to search for 'name'
unknown's avatar
VIEW  
unknown committed
2588
    name			name of field
2589
    item_name                   name of item if it will be created (VIEW)
unknown's avatar
VIEW  
unknown committed
2590
    length			length of name
unknown's avatar
unknown committed
2591 2592 2593
    ref				expression substituted in VIEW should be passed
                                using this reference (return view_ref_found)
    check_grants		do check columns grants for view?
unknown's avatar
unknown committed
2594
    register_tree_change        TRUE if ref is not stack variable and we
unknown's avatar
unknown committed
2595
                                need register changes in item tree
unknown's avatar
VIEW  
unknown committed
2596 2597 2598 2599

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

unknown's avatar
unknown committed
2603 2604 2605 2606 2607
static Field *
find_field_in_view(THD *thd, TABLE_LIST *table_list,
                   const char *name, const char *item_name,
                   uint length, Item **ref, bool check_grants,
                   bool register_tree_change)
unknown's avatar
VIEW  
unknown committed
2608
{
unknown's avatar
unknown committed
2609 2610 2611 2612 2613 2614
  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);
2615 2616
  Query_arena *arena, backup;  
  
unknown's avatar
unknown committed
2617 2618 2619
  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
2620
  {
unknown's avatar
unknown committed
2621
    if (!my_strcasecmp(system_charset_info, field_it.name(), name))
2622
    {
unknown's avatar
unknown committed
2623 2624 2625 2626 2627 2628 2629
      if (table_list->schema_table_reformed)
        /*
          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*) (field_it.item()))->field);
unknown's avatar
VIEW  
unknown committed
2630
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
2631 2632 2633 2634 2635 2636
      if (check_grants &&
          check_grant_column(thd, &table_list->grant,
                             table_list->view_db.str,
                             table_list->view_name.str,
                             name, length))
        DBUG_RETURN(WRONG_GRANT);
unknown's avatar
VIEW  
unknown committed
2637
#endif
2638 2639 2640
      // in PS use own arena or data will be freed after prepare
      if (register_tree_change)
        arena= thd->activate_stmt_arena_if_needed(&backup);
unknown's avatar
unknown committed
2641
      Item *item= field_it.create_item(thd);
2642 2643 2644
      if (register_tree_change && arena)
        thd->restore_active_arena(arena, &backup);
      
unknown's avatar
unknown committed
2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683
      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.
      */
      if (*ref && !(*ref)->is_autogenerated_name)
        item->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
      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
    check_grants	 [in]  do check columns grants?
    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

2684 2685 2686 2687 2688 2689
  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
2690
  RETURN
2691 2692 2693
    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
2694 2695 2696 2697 2698
*/

static Field *
find_field_in_natural_join(THD *thd, TABLE_LIST *table_ref, const char *name,
                           uint length, Item **ref, bool check_grants,
2699 2700
                           bool register_tree_change,
                           TABLE_LIST **actual_table)
unknown's avatar
unknown committed
2701
{
2702 2703 2704 2705
  List_iterator_fast<Natural_join_column>
    field_it(*(table_ref->join_columns));
  Natural_join_column *nj_col;
  Field *found_field;
2706 2707
  Query_arena *arena, backup;

unknown's avatar
unknown committed
2708
  DBUG_ENTER("find_field_in_natural_join");
2709
  DBUG_PRINT("enter", ("field name: '%s', ref 0x%lx",
unknown's avatar
unknown committed
2710 2711
		       name, (ulong) ref));
  DBUG_ASSERT(table_ref->is_natural_join && table_ref->join_columns);
2712
  DBUG_ASSERT(*actual_table == NULL);
unknown's avatar
unknown committed
2713

2714
  LINT_INIT(found_field);
unknown's avatar
unknown committed
2715

2716
  for (;;)
unknown's avatar
unknown committed
2717
  {
2718 2719 2720
    if (!(nj_col= field_it++))
      DBUG_RETURN(NULL);

unknown's avatar
unknown committed
2721 2722
    if (!my_strcasecmp(system_charset_info, nj_col->name(), name))
      break;
unknown's avatar
VIEW  
unknown committed
2723
  }
unknown's avatar
unknown committed
2724

unknown's avatar
VIEW  
unknown committed
2725
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
2726
  if (check_grants && nj_col->check_grants(thd, name, length))
2727
    DBUG_RETURN(WRONG_GRANT);
unknown's avatar
VIEW  
unknown committed
2728
#endif
unknown's avatar
unknown committed
2729 2730 2731 2732 2733 2734 2735

  if (nj_col->view_field)
  {
    /*
      The found field is a view field, we do as in find_field_in_view()
      and return a pointer to pointer to the Item of that field.
    */
2736 2737 2738
    if (register_tree_change)
      arena= thd->activate_stmt_arena_if_needed(&backup);

unknown's avatar
unknown committed
2739
    Item *item= nj_col->create_item(thd);
2740 2741 2742 2743

    if (register_tree_change && arena)
      thd->restore_active_arena(arena, &backup);

unknown's avatar
unknown committed
2744 2745 2746 2747
    if (!item)
      DBUG_RETURN(NULL);
    DBUG_ASSERT(nj_col->table_field == NULL);
    if (nj_col->table_ref->schema_table_reformed)
2748
    {
unknown's avatar
unknown committed
2749 2750 2751 2752 2753 2754
      /*
        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);
2755
    }
unknown's avatar
unknown committed
2756 2757 2758 2759 2760 2761 2762 2763 2764 2765
    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);
2766
    DBUG_ASSERT(nj_col->table_ref->table == nj_col->table_field->table);
unknown's avatar
unknown committed
2767 2768 2769 2770 2771 2772 2773
    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
2774 2775
}

2776

unknown's avatar
VIEW  
unknown committed
2777
/*
unknown's avatar
unknown committed
2778
  Find field by name in a base table or a view with temp table algorithm.
unknown's avatar
VIEW  
unknown committed
2779 2780

  SYNOPSIS
unknown's avatar
unknown committed
2781
    find_field_in_table()
unknown's avatar
VIEW  
unknown committed
2782
    thd				thread handler
unknown's avatar
unknown committed
2783
    table			table where to search for the field
unknown's avatar
VIEW  
unknown committed
2784 2785 2786 2787
    name			name of field
    length			length of name
    check_grants		do check columns grants?
    allow_rowid			do allow finding of "_rowid" field?
unknown's avatar
unknown committed
2788 2789
    cached_field_index_ptr	cached position in field list (used to speedup
                                lookup for fields in prepared tables)
unknown's avatar
VIEW  
unknown committed
2790 2791

  RETURN
2792 2793
    0	field is not found
    #	pointer to field
unknown's avatar
VIEW  
unknown committed
2794 2795
*/

unknown's avatar
unknown committed
2796 2797 2798 2799
Field *
find_field_in_table(THD *thd, TABLE *table, const char *name, uint length,
                    bool check_grants, bool allow_rowid,
                    uint *cached_field_index_ptr)
unknown's avatar
unknown committed
2800
{
unknown's avatar
unknown committed
2801 2802
  Field **field_ptr, *field;
  uint cached_field_index= *cached_field_index_ptr;
2803 2804
  DBUG_ENTER("find_field_in_table");
  DBUG_PRINT("enter", ("table: '%s', field name: '%s'", table->alias, name));
unknown's avatar
unknown committed
2805 2806

  /* We assume here that table->field < NO_CACHED_FIELD_INDEX = UINT_MAX */
2807
  if (cached_field_index < table->s->fields &&
unknown's avatar
unknown committed
2808 2809 2810
      !my_strcasecmp(system_charset_info, 
                     table->field[cached_field_index]->field_name, name))
    field_ptr= table->field + cached_field_index;
2811 2812 2813
  else if (table->s->name_hash.records)
    field_ptr= (Field**) hash_search(&table->s->name_hash, (byte*) name,
                                     length);
unknown's avatar
unknown committed
2814 2815 2816
  else
  {
    if (!(field_ptr= table->field))
unknown's avatar
unknown committed
2817
      DBUG_RETURN((Field *)0);
unknown's avatar
unknown committed
2818 2819 2820 2821 2822 2823
    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
2824
  {
unknown's avatar
unknown committed
2825 2826
    *cached_field_index_ptr= field_ptr - table->field;
    field= *field_ptr;
unknown's avatar
unknown committed
2827 2828 2829
  }
  else
  {
unknown's avatar
unknown committed
2830 2831 2832
    if (!allow_rowid ||
        my_strcasecmp(system_charset_info, name, "_rowid") ||
        !(field=table->rowid_field))
unknown's avatar
unknown committed
2833
      DBUG_RETURN((Field*) 0);
unknown's avatar
unknown committed
2834 2835
  }

unknown's avatar
unknown committed
2836 2837
  update_field_dependencies(thd, field, table);

unknown's avatar
unknown committed
2838
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
VIEW  
unknown committed
2839
  if (check_grants && check_grant_column(thd, &table->grant,
2840 2841
					 table->s->db,
					 table->s->table_name, name, length))
2842
    field= WRONG_GRANT;
unknown's avatar
unknown committed
2843
#endif
unknown's avatar
unknown committed
2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 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 2896
  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
    item_name              [in]  name of item if it will be created (VIEW)
    table_name             [in]  optional table name that qualifies the field
    db_name                [in]  optional database name that qualifies the
    length		   [in]  field length of name
    ref		       [in/out] if 'name' is resolved to a view field, ref
                                 is set to point to the found view field
    check_grants_table	   [in]  do check columns grants for table?
    check_grants_view	   [in]  do check columns grants for view?
    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.

  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,
                        const char *name, const char *item_name,
                        const char *table_name, const char *db_name,
                        uint length, Item **ref,
                        bool check_grants_table, bool check_grants_view,
                        bool allow_rowid, uint *cached_field_index_ptr,
                        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
    are the same as the table we are going to search for the field.
unknown's avatar
unknown committed
2897 2898 2899
    This is done differently for NATURAL/USING joins or nested joins that
    are operands of NATURAL/USING joins because there we can't simply
    compare the qualifying table and database names with the ones of
unknown's avatar
unknown committed
2900 2901
    'table_list' because each field in such a join may originate from a
    different table.
2902 2903
    TODO: Ensure that table_name, db_name and tables->db always points to
          something !
unknown's avatar
unknown committed
2904
  */
unknown's avatar
unknown committed
2905
  if (!(table_list->nested_join && table_list->join_columns) &&
2906 2907
      table_name && table_name[0] &&
      (my_strcasecmp(table_alias_charset, table_list->alias, table_name) ||
unknown's avatar
unknown committed
2908 2909 2910 2911
       (db_name && db_name[0] && table_list->db && table_list->db[0] &&
        strcmp(db_name, table_list->db))))
    DBUG_RETURN(0);

2912
  *actual_table= NULL;
unknown's avatar
unknown committed
2913 2914 2915
  if (table_list->field_translation)
  {
    if ((fld= find_field_in_view(thd, table_list, name, item_name, length,
2916 2917
                                 ref, check_grants_view,
                                 register_tree_change)))
unknown's avatar
unknown committed
2918 2919
      *actual_table= table_list;
  }
unknown's avatar
unknown committed
2920
  else if (table_list->nested_join && table_list->join_columns)
2921
  {
unknown's avatar
unknown committed
2922 2923 2924 2925 2926
    /*
      If this is a NATURAL/USING join, or an operand of such join which is a
      join itself, and the field name is qualified, then search for the field
      in the operands of the join.
    */
2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947
    if (table_name && table_name[0])
    {
      /*
        Qualified field; Search for it in the tables used by the natural join.
      */
      List_iterator<TABLE_LIST> it(table_list->nested_join->join_list);
      TABLE_LIST *table;
      while ((table= it++))
      {
        if ((fld= find_field_in_table_ref(thd, table, name, item_name,
                                          table_name, db_name, length, ref,
                                          check_grants_table,
                                          check_grants_view,
                                          allow_rowid, cached_field_index_ptr,
                                          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
2948 2949 2950
      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.
2951 2952
    */
    fld= find_field_in_natural_join(thd, table_list, name, length, ref,
unknown's avatar
unknown committed
2953 2954 2955
                                    /* TIMOUR_TODO: check this with Sanja */
                                    check_grants_table || check_grants_view,
                                    register_tree_change, actual_table);
2956
  }
unknown's avatar
unknown committed
2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970
  else
  {
    if ((fld= find_field_in_table(thd, table_list->table, name, length,
                                  check_grants_table, allow_rowid,
                                  cached_field_index_ptr)))
      *actual_table= table_list;
#ifndef NO_EMBEDDED_ACCESS_CHECKS
    /* check for views with temporary table algorithm */
    if (check_grants_view && table_list->view &&
        fld && fld != WRONG_GRANT &&
        check_grant_column(thd, &table_list->grant,
                           table_list->view_db.str,
                           table_list->view_name.str,
                           name, length))
2971
    fld= WRONG_GRANT;
unknown's avatar
unknown committed
2972 2973 2974 2975
#endif
  }

  DBUG_RETURN(fld);
unknown's avatar
unknown committed
2976 2977
}

2978

2979 2980 2981 2982 2983
/*
  Find field in table list.

  SYNOPSIS
    find_field_in_tables()
unknown's avatar
unknown committed
2984 2985 2986 2987 2988 2989
    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
2990
                          point to the found view field
unknown's avatar
unknown committed
2991
    report_error	  Degree of error reporting:
2992 2993
                          - IGNORE_ERRORS then do not report any error
                          - IGNORE_EXCEPT_NON_UNIQUE report only non-unique
unknown's avatar
unknown committed
2994
                            fields, suppress all other errors
2995 2996 2997 2998
                          - 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
2999 3000
    register_tree_change  TRUE if ref is not a stack variable and we
                          to need register changes in item tree
3001 3002

  RETURN VALUES
3003 3004 3005
    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.
3006 3007 3008 3009 3010
    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
3011
*/
unknown's avatar
unknown committed
3012 3013

Field *
unknown's avatar
unknown committed
3014 3015
find_field_in_tables(THD *thd, Item_ident *item,
                     TABLE_LIST *first_table, TABLE_LIST *last_table,
3016
		     Item **ref, find_item_error_report_type report_error,
3017
                     bool check_privileges, bool register_tree_change)
unknown's avatar
unknown committed
3018 3019
{
  Field *found=0;
unknown's avatar
unknown committed
3020 3021 3022
  const char *db= item->db_name;
  const char *table_name= item->table_name;
  const char *name= item->field_name;
unknown's avatar
unknown committed
3023
  uint length=(uint) strlen(name);
3024
  char name_buff[NAME_LEN+1];
unknown's avatar
unknown committed
3025 3026
  TABLE_LIST *cur_table= first_table;
  TABLE_LIST *actual_table;
unknown's avatar
unknown committed
3027 3028 3029 3030 3031 3032 3033 3034 3035
  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
3036

unknown's avatar
unknown committed
3037 3038 3039
  if (item->cached_table)
  {
    /*
unknown's avatar
unknown committed
3040 3041
      This shortcut is used by prepared statements. We assume that
      TABLE_LIST *first_table is not changed during query execution (which
3042
      is true for all queries except RENAME but luckily RENAME doesn't
unknown's avatar
unknown committed
3043
      use fields...) so we can rely on reusing pointer to its member.
unknown's avatar
unknown committed
3044
      With this optimization we also miss case when addition of one more
3045
      field makes some prepared query ambiguous and so erroneous, but we
unknown's avatar
unknown committed
3046 3047
      accept this trade off.
    */
unknown's avatar
unknown committed
3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059
    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,
                                 test(table_ref->table->
                                      grant.want_privilege) &&
                                 check_privileges,
                                 1, &(item->cached_field_index));
3060
    else
unknown's avatar
unknown committed
3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071
      found= find_field_in_table_ref(thd, table_ref, name, item->name,
                                     NULL, NULL, length, ref,
                                     (table_ref->table &&
                                      test(table_ref->table->grant.
                                           want_privilege) &&
                                      check_privileges),
                                     (test(table_ref->grant.want_privilege) &&
                                      check_privileges),
                                     1, &(item->cached_field_index),
                                     register_tree_change,
                                     &actual_table);
unknown's avatar
unknown committed
3072 3073 3074
    if (found)
    {
      if (found == WRONG_GRANT)
3075
	return (Field*) 0;
3076 3077
      {
        SELECT_LEX *current_sel= thd->lex->current_select;
unknown's avatar
unknown committed
3078
        SELECT_LEX *last_select= table_ref->select_lex;
unknown's avatar
unknown committed
3079 3080
        /*
          If the field was an outer referencee, mark all selects using this
unknown's avatar
unknown committed
3081
          sub query as dependent on the outer query
unknown's avatar
unknown committed
3082
        */
3083
        if (current_sel != last_select)
unknown's avatar
unknown committed
3084
          mark_select_range_as_dependent(thd, last_select, current_sel,
3085 3086
                                         found, *ref, item);
      }
unknown's avatar
unknown committed
3087 3088 3089 3090
      return found;
    }
  }

3091 3092 3093
  if (db && lower_case_table_names)
  {
    /*
unknown's avatar
unknown committed
3094
      convert database to lower case for comparison.
3095 3096 3097 3098
      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
3099
    my_casedn_str(files_charset_info, name_buff);
3100 3101
    db= name_buff;
  }
unknown's avatar
unknown committed
3102

3103 3104 3105 3106 3107
  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
3108
  {
unknown's avatar
unknown committed
3109
    Field *cur_field= find_field_in_table_ref(thd, cur_table, name, item->name,
unknown's avatar
unknown committed
3110
                                              table_name, db,
3111
                                              length, ref,
unknown's avatar
unknown committed
3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123
                                              (cur_table->table &&
                                               test(cur_table->table->grant.
                                                    want_privilege) &&
                                               check_privileges),
                                              (test(cur_table->grant.
                                                    want_privilege)
                                               && check_privileges),
                                              allow_rowid,
                                              &(item->cached_field_index),
                                              register_tree_change,
                                              &actual_table);
    if (cur_field)
3124
    {
unknown's avatar
unknown committed
3125
      if (cur_field == WRONG_GRANT)
unknown's avatar
unknown committed
3126
	return (Field*) 0;
unknown's avatar
unknown committed
3127 3128 3129 3130 3131 3132 3133 3134

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

3135 3136 3137 3138 3139
      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
3140
      if (db)
3141 3142
        return cur_field;

unknown's avatar
unknown committed
3143 3144
      if (found)
      {
3145 3146
        if (report_error == REPORT_ALL_ERRORS ||
            report_error == IGNORE_EXCEPT_NON_UNIQUE)
3147
          my_error(ER_NON_UNIQ_ERROR, MYF(0),
unknown's avatar
unknown committed
3148
                   table_name ? item->full_name() : name, thd->where);
unknown's avatar
unknown committed
3149 3150
	return (Field*) 0;
      }
unknown's avatar
unknown committed
3151
      found= cur_field;
unknown's avatar
unknown committed
3152 3153
    }
  }
3154

unknown's avatar
unknown committed
3155 3156
  if (found)
    return found;
3157 3158 3159 3160 3161 3162 3163 3164

  /*
    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
3165
  if (table_name && (cur_table == first_table) &&
3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176
      (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);
  }
3177
  else
unknown's avatar
unknown committed
3178
  {
3179 3180 3181 3182 3183
    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
3184
  }
3185
  return found;
unknown's avatar
unknown committed
3186 3187
}

3188 3189 3190

/*
  Find Item in list of items (find_field_in_tables analog)
3191 3192 3193 3194

  TODO
    is it better return only counter?

3195 3196
  SYNOPSIS
    find_item_in_list()
3197 3198 3199
    find			Item to find
    items			List of items
    counter			To return number of found item
3200
    report_error
3201 3202 3203 3204 3205
      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
3206 3207 3208 3209
    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.

3210
  RETURN VALUES
3211 3212 3213 3214 3215
    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
3216
                        found field
3217 3218
*/

3219
/* Special Item pointer to serve as a return value from find_item_in_list(). */
unknown's avatar
unknown committed
3220
Item **not_found_item= (Item**) 0x1;
3221 3222


unknown's avatar
unknown committed
3223
Item **
3224
find_item_in_list(Item *find, List<Item> &items, uint *counter,
3225
                  find_item_error_report_type report_error, bool *unaliased)
unknown's avatar
unknown committed
3226 3227
{
  List_iterator<Item> li(items);
3228
  Item **found=0, **found_unaliased= 0, *item;
3229
  const char *db_name=0;
unknown's avatar
unknown committed
3230 3231
  const char *field_name=0;
  const char *table_name=0;
3232 3233
  bool found_unaliased_non_uniq= 0;
  uint unaliased_counter;
3234

3235 3236
  LINT_INIT(unaliased_counter);                 // Dependent on found_unaliased

3237 3238
  *unaliased= FALSE;

unknown's avatar
unknown committed
3239 3240 3241 3242
  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;
3243
    db_name=    ((Item_ident*) find)->db_name;
unknown's avatar
unknown committed
3244 3245
  }

3246
  for (uint i= 0; (item=li++); i++)
unknown's avatar
unknown committed
3247 3248 3249
  {
    if (field_name && item->type() == Item::FIELD_ITEM)
    {
3250
      Item_field *item_field= (Item_field*) item;
3251

unknown's avatar
unknown committed
3252 3253 3254 3255 3256 3257
      /*
	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
      */ 
3258 3259 3260 3261
      if (!item_field->name)
        continue;

      if (table_name)
unknown's avatar
unknown committed
3262
      {
3263 3264 3265
        /*
          If table name is specified we should find field 'field_name' in
          table 'table_name'. According to SQL-standard we should ignore
3266 3267 3268 3269 3270
          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.
3271

3272
          We use strcmp for table names and database names as these may be
3273 3274
          case sensitive. In cases where they are not case sensitive, they
          are always in lower case.
3275 3276

	  item_field->field_name and item_field->table_name can be 0x0 if
3277
	  item is not fix_field()'ed yet.
3278
        */
3279 3280
        if (item_field->field_name && item_field->table_name &&
	    !my_strcasecmp(system_charset_info, item_field->field_name,
3281 3282 3283 3284 3285
                           field_name) &&
            !strcmp(item_field->table_name, table_name) &&
            (!db_name || (item_field->db_name &&
                          !strcmp(item_field->db_name, db_name))))
        {
3286
          if (found_unaliased)
3287
          {
3288 3289 3290 3291 3292 3293 3294
            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.
            */
3295
            if (report_error != IGNORE_ERRORS)
3296 3297
              my_error(ER_NON_UNIQ_ERROR, MYF(0),
                       find->full_name(), current_thd->where);
3298 3299
            return (Item**) 0;
          }
3300 3301
          found_unaliased= li.ref();
          unaliased_counter= i;
3302 3303
          if (db_name)
            break;                              // Perfect match
3304 3305 3306
        }
      }
      else if (!my_strcasecmp(system_charset_info, item_field->name,
3307
                              field_name))
3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320
      {
        /*
          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)
3321 3322
            my_error(ER_NON_UNIQ_ERROR, MYF(0),
                     find->full_name(), current_thd->where);
3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347
          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
3348 3349
      }
    }
3350
    else if (!table_name && (item->eq(find,0) ||
3351
			     find->name && item->name &&
3352 3353
			     !my_strcasecmp(system_charset_info, 
					    item->name,find->name)))
unknown's avatar
unknown committed
3354
    {
3355 3356
      found= li.ref();
      *counter= i;
unknown's avatar
unknown committed
3357 3358 3359
      break;
    }
  }
3360 3361 3362 3363 3364
  if (!found)
  {
    if (found_unaliased_non_uniq)
    {
      if (report_error != IGNORE_ERRORS)
3365 3366
        my_error(ER_NON_UNIQ_ERROR, MYF(0),
                 find->full_name(), current_thd->where);
3367 3368 3369 3370 3371 3372
      return (Item **) 0;
    }
    if (found_unaliased)
    {
      found= found_unaliased;
      *counter= unaliased_counter;
3373
      *unaliased= TRUE;
3374 3375
    }
  }
3376 3377
  if (found)
    return found;
3378
  if (report_error != REPORT_EXCEPT_NOT_FOUND)
3379 3380
  {
    if (report_error == REPORT_ALL_ERRORS)
3381 3382
      my_error(ER_BAD_FIELD_ERROR, MYF(0),
               find->full_name(), current_thd->where);
3383 3384 3385 3386
    return (Item **) 0;
  }
  else
    return (Item **) not_found_item;
unknown's avatar
unknown committed
3387 3388
}

unknown's avatar
unknown committed
3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438

/*
  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;
    if (!strncmp(find, curr_str->ptr(), find_length))
      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
3439 3440
    FALSE  if all OK
    TRUE   otherwise
unknown's avatar
unknown committed
3441 3442 3443 3444 3445 3446
*/

static bool
set_new_item_local_context(THD *thd, Item_ident *item, TABLE_LIST *table_ref)
{
  Name_resolution_context *context;
3447
  if (!(context= new (thd->mem_root) Name_resolution_context))
unknown's avatar
unknown committed
3448 3449
    return TRUE;
  context->init();
3450 3451
  context->first_name_resolution_table=
    context->last_name_resolution_table= table_ref;
unknown's avatar
unknown committed
3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483
  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
3484 3485
    TRUE   error when some common column is non-unique, or out of memory
    FALSE  OK
unknown's avatar
unknown committed
3486 3487 3488 3489 3490 3491 3492 3493
*/

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;
3494
  const char *field_name_1;
unknown's avatar
unknown committed
3495
  Query_arena *arena, backup;
3496
  bool add_columns= TRUE;
unknown's avatar
unknown committed
3497 3498 3499
  bool result= TRUE;

  DBUG_ENTER("mark_common_columns");
3500
  DBUG_PRINT("info", ("operand_1: %s  operand_2: %s",
unknown's avatar
unknown committed
3501 3502
                      table_ref_1->alias, table_ref_2->alias));

3503
  *found_using_fields= 0;
unknown's avatar
unknown committed
3504
  arena= thd->activate_stmt_arena_if_needed(&backup);
unknown's avatar
unknown committed
3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525

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

  for (it_1.set(table_ref_1); !it_1.end_of_fields(); it_1.next())
  {
    bool is_created_1;
3526
    bool found= FALSE;
unknown's avatar
unknown committed
3527 3528 3529 3530 3531 3532 3533 3534
    if (!(nj_col_1= it_1.get_or_create_column_ref(thd, &is_created_1)))
      goto err;
    field_name_1= nj_col_1->name();

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

3535 3536 3537 3538 3539 3540 3541
    /*
      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
3542 3543 3544 3545 3546
    nj_col_2= NULL;
    for (it_2.set(table_ref_2); !it_2.end_of_fields(); it_2.next())
    {
      bool is_created_2;
      Natural_join_column *cur_nj_col_2;
3547
      const char *cur_field_name_2;
unknown's avatar
unknown committed
3548 3549
      if (!(cur_nj_col_2= it_2.get_or_create_column_ref(thd, &is_created_2)))
        goto err;
3550
      cur_field_name_2= cur_nj_col_2->name();
unknown's avatar
unknown committed
3551 3552 3553 3554 3555

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

unknown's avatar
unknown committed
3556 3557 3558 3559 3560 3561 3562
      /*
        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
3563 3564
      if (!my_strcasecmp(system_charset_info, field_name_1, cur_field_name_2))
      {
unknown's avatar
unknown committed
3565
        if (found || cur_nj_col_2->is_common)
unknown's avatar
unknown committed
3566 3567 3568 3569 3570 3571 3572 3573
        {
          my_error(ER_NON_UNIQ_ERROR, MYF(0), field_name_1, thd->where);
          goto err;
        }
        nj_col_2= cur_nj_col_2;
        found= TRUE;
      }
    }
3574
    /* Force it_2.set() to use table_ref_2->join_columns. */
unknown's avatar
unknown committed
3575 3576 3577
    table_ref_2->is_join_columns_complete= TRUE;
    add_columns= FALSE;
    if (!found)
3578
      continue;                                 // No matching field
unknown's avatar
unknown committed
3579 3580 3581 3582 3583 3584 3585 3586

    /*
      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 ||
3587
          test_if_string_in_list(field_name_1, using_fields)))
unknown's avatar
unknown committed
3588 3589 3590 3591 3592 3593
    {
      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;
3594 3595 3596 3597 3598
      Item_func_eq *eq_cond;

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

unknown's avatar
unknown committed
3599
      /*
3600
        The following assert checks that the two created items are of
unknown's avatar
unknown committed
3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624
        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.
      */
3625 3626
      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
3627 3628
        goto err;

3629 3630
      if (!(eq_cond= new Item_func_eq(item_ident_1, item_ident_2)))
        goto err;                               /* Out of memory. */
unknown's avatar
unknown committed
3631 3632 3633 3634 3635 3636

      /*
        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.
       */
3637 3638 3639
      add_join_on((table_ref_1->outer_join & JOIN_TYPE_RIGHT ?
                   table_ref_1 : table_ref_2),
                  eq_cond);
unknown's avatar
unknown committed
3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672

      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);
    }
  }
  table_ref_1->is_join_columns_complete= TRUE;

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

err:
  if (arena)
unknown's avatar
unknown committed
3673
    thd->restore_active_arena(arena, &backup);
unknown's avatar
unknown committed
3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709
  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
3710 3711
    TRUE    error: Some common column is ambiguous
    FALSE   OK
unknown's avatar
unknown committed
3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725
*/

static bool
store_natural_using_join_columns(THD *thd, TABLE_LIST *natural_using_join,
                                 TABLE_LIST *table_ref_1,
                                 TABLE_LIST *table_ref_2,
                                 List<String> *using_fields,
                                 uint found_using_fields)
{
  Field_iterator_table_ref it_1, it_2;
  Natural_join_column *nj_col_1, *nj_col_2;
  bool is_created;
  Query_arena *arena, backup;
  bool result= TRUE;
3726
  List<Natural_join_column> *non_join_columns;
unknown's avatar
unknown committed
3727 3728
  DBUG_ENTER("store_natural_using_join_columns");

3729 3730
  DBUG_ASSERT(!natural_using_join->join_columns);

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

3733 3734
  if (!(non_join_columns= new List<Natural_join_column>) ||
      !(natural_using_join->join_columns= new List<Natural_join_column>))
unknown's avatar
unknown committed
3735 3736 3737 3738 3739 3740 3741
    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())
  {
    if (!(nj_col_1= it_1.get_or_create_column_ref(thd, &is_created)))
      goto err;
3742 3743 3744 3745
    /*
      The following assert checks that mark_common_columns() was run and
      we created the list table_ref_1->join_columns.
    */
unknown's avatar
unknown committed
3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767
    DBUG_ASSERT(!is_created);
    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++))
    {
3768
      const char *using_field_name_ptr= using_field_name->c_ptr();
unknown's avatar
unknown committed
3769 3770 3771
      List_iterator_fast<Natural_join_column>
        it(*(natural_using_join->join_columns));
      Natural_join_column *common_field;
3772 3773

      for (;;)
unknown's avatar
unknown committed
3774
      {
3775 3776 3777 3778 3779 3780 3781
        /* 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
3782 3783
        if (!my_strcasecmp(system_charset_info,
                           common_field->name(), using_field_name_ptr))
3784
          break;                                // Found match
unknown's avatar
unknown committed
3785 3786 3787 3788 3789 3790 3791 3792 3793
      }
    }
  }

  /* 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())
  {
    if (!(nj_col_2= it_2.get_or_create_column_ref(thd, &is_created)))
      goto err;
3794 3795 3796 3797
    /*
      The following assert checks that mark_common_columns() was run and
      we created the list table_ref_2->join_columns.
    */
unknown's avatar
unknown committed
3798 3799 3800 3801
    DBUG_ASSERT(!is_created);
    if (!nj_col_2->is_common)
      non_join_columns->push_back(nj_col_2);
    else
3802
    {
unknown's avatar
unknown committed
3803 3804
      /* Reset the common columns for the next call to mark_common_columns. */
      nj_col_2->is_common= FALSE;
3805
    }
unknown's avatar
unknown committed
3806 3807 3808 3809 3810 3811 3812 3813 3814 3815
  }

  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
3816
    thd->restore_active_arena(arena, &backup);
unknown's avatar
unknown committed
3817 3818 3819
  DBUG_RETURN(result);
}

3820

unknown's avatar
unknown committed
3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846
/*
  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
3847 3848
    TRUE   Error
    FALSE  OK
unknown's avatar
unknown committed
3849 3850 3851 3852 3853 3854 3855
*/

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
3856 3857 3858
  Query_arena *arena, backup;
  bool result= TRUE;

unknown's avatar
unknown committed
3859
  DBUG_ENTER("store_top_level_join_columns");
3860

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

unknown's avatar
unknown committed
3863 3864 3865 3866 3867 3868
  /* 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;
3869

unknown's avatar
unknown committed
3870 3871
    while (cur_left_neighbor)
    {
3872
      TABLE_LIST *cur_table_ref= cur_left_neighbor;
unknown's avatar
unknown committed
3873
      cur_left_neighbor= nested_it++;
3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894
      /*
        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
3895
        goto err;
3896
      cur_right_neighbor= cur_table_ref;
unknown's avatar
unknown committed
3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926
    }
  }

  /*
    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
3927
      goto err;
unknown's avatar
unknown committed
3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938

    /*
      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
3939
      goto err;
unknown's avatar
unknown committed
3940 3941 3942 3943 3944 3945 3946 3947 3948

    /*
      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
3949 3950 3951 3952 3953
    /* 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
3954 3955 3956
    /* Change this table reference to become a leaf for name resolution. */
    if (left_neighbor)
    {
3957
      TABLE_LIST *last_leaf_on_the_left;
unknown's avatar
unknown committed
3958 3959 3960 3961 3962
      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)
    {
3963
      TABLE_LIST *first_leaf_on_the_right;
unknown's avatar
unknown committed
3964 3965 3966 3967 3968 3969
      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
3970 3971 3972 3973
  result= FALSE; /* All is OK. */

err:
  if (arena)
unknown's avatar
unknown committed
3974
    thd->restore_active_arena(arena, &backup);
unknown's avatar
unknown committed
3975
  DBUG_RETURN(result);
unknown's avatar
unknown committed
3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999
}


/*
  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
4000 4001
    TRUE   Error
    FALSE  OK
unknown's avatar
unknown committed
4002
*/
4003 4004
static bool setup_natural_join_row_types(THD *thd,
                                         List<TABLE_LIST> *from_clause,
unknown's avatar
unknown committed
4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017
                                         Name_resolution_context *context)
{
  thd->where= "from clause";
  if (from_clause->elements == 0)
    return FALSE; /* We come here in the case of UNIONs. */

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

  List_iterator_fast<TABLE_LIST> table_ref_it(*from_clause);
  TABLE_LIST *table_ref; /* Current table reference. */
  /* Table reference to the left of the current. */
4018
  TABLE_LIST *left_neighbor;
unknown's avatar
unknown committed
4019 4020 4021
  /* Table reference to the right of the current. */
  TABLE_LIST *right_neighbor= NULL;

4022 4023
  /* Note that tables in the list are in reversed order */
  for (left_neighbor= table_ref_it++; left_neighbor ; )
unknown's avatar
unknown committed
4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041
  {
    table_ref= left_neighbor;
    left_neighbor= table_ref_it++;
    if (store_top_level_join_columns(thd, table_ref,
                                     left_neighbor, right_neighbor))
      return TRUE;
    if (left_neighbor)
    {
      TABLE_LIST *first_leaf_on_the_right;
      first_leaf_on_the_right= table_ref->first_leaf_for_name_resolution();
      left_neighbor->next_name_resolution_table= first_leaf_on_the_right;
    }
    right_neighbor= table_ref;
  }

  /*
    Store the top-most, left-most NATURAL/USING join, so that we start
    the search from that one instead of context->table_list. At this point
4042
    right_neighbor points to the left-most top-level table reference in the
unknown's avatar
unknown committed
4043 4044 4045 4046 4047 4048 4049 4050 4051 4052
    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
4053
/****************************************************************************
4054
** Expand all '*' in given fields
unknown's avatar
unknown committed
4055 4056
****************************************************************************/

4057 4058 4059
int setup_wild(THD *thd, TABLE_LIST *tables, List<Item> &fields,
	       List<Item> *sum_func_list,
	       uint wild_num)
unknown's avatar
unknown committed
4060
{
4061
  if (!wild_num)
4062
    return(0);
4063

4064
  Item *item;
unknown's avatar
unknown committed
4065
  List_iterator<Item> it(fields);
unknown's avatar
unknown committed
4066
  Query_arena *arena, backup;
4067
  DBUG_ENTER("setup_wild");
unknown's avatar
unknown committed
4068 4069

  /*
4070 4071
    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
4072
  */
unknown's avatar
unknown committed
4073
  arena= thd->activate_stmt_arena_if_needed(&backup);
4074

unknown's avatar
unknown committed
4075
  while (wild_num && (item= it++))
unknown's avatar
VIEW  
unknown committed
4076
  {
4077 4078
    if (item->type() == Item::FIELD_ITEM &&
        ((Item_field*) item)->field_name &&
4079 4080
	((Item_field*) item)->field_name[0] == '*' &&
	!((Item_field*) item)->field)
4081
    {
4082
      uint elem= fields.elements;
unknown's avatar
VIEW  
unknown committed
4083
      bool any_privileges= ((Item_field *) item)->any_privileges;
unknown's avatar
unknown committed
4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094
      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));
      }
4095 4096
      else if (insert_fields(thd, ((Item_field*) item)->context,
                             ((Item_field*) item)->db_name,
unknown's avatar
unknown committed
4097
                             ((Item_field*) item)->table_name, &it,
4098
                             any_privileges))
unknown's avatar
unknown committed
4099 4100
      {
	if (arena)
unknown's avatar
unknown committed
4101
	  thd->restore_active_arena(arena, &backup);
4102
	DBUG_RETURN(-1);
unknown's avatar
unknown committed
4103
      }
4104
      if (sum_func_list)
4105 4106 4107 4108 4109 4110 4111 4112
      {
	/*
	  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;
      }
4113
      wild_num--;
4114 4115
    }
  }
unknown's avatar
unknown committed
4116 4117 4118 4119 4120 4121 4122
  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
4123
    thd->restore_active_arena(arena, &backup);
unknown's avatar
unknown committed
4124
  }
4125
  DBUG_RETURN(0);
4126 4127
}

4128 4129 4130 4131
/****************************************************************************
** Check that all given fields exists and fill struct with current data
****************************************************************************/

4132
bool setup_fields(THD *thd, Item **ref_pointer_array,
unknown's avatar
unknown committed
4133 4134
                  List<Item> &fields, bool set_query_id,
                  List<Item> *sum_func_list, bool allow_sum_func)
4135 4136
{
  reg2 Item *item;
unknown's avatar
unknown committed
4137
  bool save_set_query_id= thd->set_query_id;
4138 4139 4140 4141 4142 4143 4144
  List_iterator<Item> it(fields);
  DBUG_ENTER("setup_fields");

  thd->set_query_id=set_query_id;
  thd->allow_sum_func= allow_sum_func;
  thd->where="field list";

4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158
  /*
    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
4159 4160
  Item **ref= ref_pointer_array;
  while ((item= it++))
4161
  {
4162
    if (!item->fixed && item->fix_fields(thd, it.ref()) ||
unknown's avatar
unknown committed
4163
	(item= *(it.ref()))->check_cols(1))
unknown's avatar
unknown committed
4164
    {
unknown's avatar
unknown committed
4165
      thd->set_query_id= save_set_query_id;
unknown's avatar
unknown committed
4166
      DBUG_RETURN(TRUE); /* purecov: inspected */
unknown's avatar
unknown committed
4167
    }
unknown's avatar
unknown committed
4168 4169
    if (ref)
      *(ref++)= item;
4170 4171
    if (item->with_sum_func && item->type() != Item::SUM_FUNC_ITEM &&
	sum_func_list)
4172
      item->split_sum_func(thd, ref_pointer_array, *sum_func_list);
unknown's avatar
unknown committed
4173
    thd->used_tables|= item->used_tables();
4174
  }
unknown's avatar
unknown committed
4175
  thd->set_query_id= save_set_query_id;
4176
  DBUG_RETURN(test(thd->net.report_error));
4177
}
4178

4179

4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194
/*
  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)
  {
unknown's avatar
unknown committed
4195
    if (table->view && table->effective_algorithm == VIEW_ALGORITHM_MERGE)
4196 4197 4198 4199 4200 4201 4202 4203 4204 4205
      list= make_leaves_list(list, table->ancestor);
    else
    {
      *list= table;
      list= &table->next_leaf;
    }
  }
  return list;
}

4206
/*
unknown's avatar
unknown committed
4207 4208 4209 4210
  prepare tables

  SYNOPSIS
    setup_tables()
unknown's avatar
unknown committed
4211
    thd		  Thread handler
4212
    context       name resolution contest to setup table list there
unknown's avatar
unknown committed
4213 4214
    from_clause   Top-level list of table references in the FROM clause
    tables	  Table list (select_lex->table_list)
unknown's avatar
unknown committed
4215
    conds	  Condition of current SELECT (can be changed by VIEW)
unknown's avatar
unknown committed
4216
    leaves        List of join table leaves list (select_lex->leaf_tables)
unknown's avatar
unknown committed
4217 4218
    refresh       It is onle refresh for subquery
    select_insert It is SELECT ... INSERT command
unknown's avatar
unknown committed
4219

unknown's avatar
unknown committed
4220 4221
  NOTE
    Check also that the 'used keys' and 'ignored keys' exists and set up the
unknown's avatar
unknown committed
4222 4223 4224 4225
    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.
4226

unknown's avatar
unknown committed
4227 4228
    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
4229

unknown's avatar
unknown committed
4230
  RETURN
unknown's avatar
unknown committed
4231
    FALSE ok;  In this case *map will includes the chosen index
unknown's avatar
unknown committed
4232
    TRUE  error
4233 4234
*/

4235
bool setup_tables(THD *thd, Name_resolution_context *context,
unknown's avatar
unknown committed
4236 4237
                  List<TABLE_LIST> *from_clause, TABLE_LIST *tables,
                  Item **conds, TABLE_LIST **leaves, bool select_insert)
4238
{
unknown's avatar
unknown committed
4239
  uint tablenr= 0;
4240
  DBUG_ENTER("setup_tables");
4241

unknown's avatar
unknown committed
4242
  context->table_list= context->first_name_resolution_table= tables;
4243

unknown's avatar
unknown committed
4244 4245
  /*
    this is used for INSERT ... SELECT.
4246
    For select we setup tables except first (and its underlying tables)
unknown's avatar
unknown committed
4247 4248 4249 4250
  */
  TABLE_LIST *first_select_table= (select_insert ?
                                   tables->next_local:
                                   0);
4251 4252 4253
  if (!(*leaves))
    make_leaves_list(leaves, tables);

unknown's avatar
unknown committed
4254 4255
  TABLE_LIST *table_list;
  for (table_list= *leaves;
unknown's avatar
VIEW  
unknown committed
4256
       table_list;
4257
       table_list= table_list->next_leaf, tablenr++)
unknown's avatar
unknown committed
4258
  {
unknown's avatar
unknown committed
4259
    TABLE *table= table_list->table;
unknown's avatar
unknown committed
4260
    if (first_select_table &&
4261
        table_list->top_table() == first_select_table)
unknown's avatar
unknown committed
4262 4263 4264 4265 4266
    {
      /* new counting for SELECT of INSERT ... SELECT command */
      first_select_table= 0;
      tablenr= 0;
    }
unknown's avatar
unknown committed
4267
    setup_table_map(table, table_list, tablenr);
4268
    table->used_keys= table->s->keys_for_keyread;
unknown's avatar
unknown committed
4269
    if (table_list->use_index)
unknown's avatar
unknown committed
4270
    {
4271 4272 4273
      key_map map;
      get_key_map_from_key_list(&map, table, table_list->use_index);
      if (map.is_set_all())
4274
	DBUG_RETURN(1);
unknown's avatar
unknown committed
4275
      table->keys_in_use_for_query=map;
unknown's avatar
unknown committed
4276
    }
unknown's avatar
unknown committed
4277
    if (table_list->ignore_index)
unknown's avatar
unknown committed
4278
    {
4279 4280 4281
      key_map map;
      get_key_map_from_key_list(&map, table, table_list->ignore_index);
      if (map.is_set_all())
4282
	DBUG_RETURN(1);
4283
      table->keys_in_use_for_query.subtract(map);
unknown's avatar
unknown committed
4284
    }
4285
    table->used_keys.intersect(table->keys_in_use_for_query);
unknown's avatar
unknown committed
4286 4287 4288 4289
  }
  if (tablenr > MAX_TABLES)
  {
    my_error(ER_TOO_MANY_TABLES,MYF(0),MAX_TABLES);
4290
    DBUG_RETURN(1);
unknown's avatar
unknown committed
4291
  }
unknown's avatar
unknown committed
4292
  for (table_list= tables;
4293 4294
       table_list;
       table_list= table_list->next_local)
4295
  {
4296 4297 4298
    if (table_list->ancestor)
    {
      DBUG_ASSERT(table_list->view);
unknown's avatar
unknown committed
4299
      Query_arena *arena= thd->stmt_arena, backup;
4300 4301 4302 4303
      bool res;
      if (arena->is_conventional())
        arena= 0;                                   // For easier test
      else
unknown's avatar
unknown committed
4304
        thd->set_n_backup_active_arena(arena, &backup);
4305 4306
      res= table_list->setup_ancestor(thd);
      if (arena)
unknown's avatar
unknown committed
4307
        thd->restore_active_arena(arena, &backup);
4308 4309 4310
      if (res)
        DBUG_RETURN(1);
    }
4311
  }
unknown's avatar
unknown committed
4312 4313 4314 4315 4316

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

4317
  DBUG_RETURN(0);
unknown's avatar
unknown committed
4318
}
4319

unknown's avatar
unknown committed
4320

4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335
/*
   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,
4336
                               List<String> *index_list)
unknown's avatar
unknown committed
4337
{
unknown's avatar
unknown committed
4338
  List_iterator_fast<String> it(*index_list);
unknown's avatar
unknown committed
4339 4340
  String *name;
  uint pos;
4341 4342

  map->clear_all();
unknown's avatar
unknown committed
4343 4344
  while ((name=it++))
  {
4345 4346 4347
    if (table->s->keynames.type_names == 0 ||
        (pos= find_type(&table->s->keynames, name->ptr(),
                        name->length(), 1)) <=
4348
        0)
unknown's avatar
unknown committed
4349
    {
unknown's avatar
unknown committed
4350
      my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), name->c_ptr(),
unknown's avatar
unknown committed
4351
	       table->s->table_name);
4352
      map->set_all();
4353
      return 1;
unknown's avatar
unknown committed
4354
    }
4355
    map->set_bit(pos-1);
unknown's avatar
unknown committed
4356
  }
4357
  return 0;
unknown's avatar
unknown committed
4358 4359
}

4360

4361 4362 4363 4364 4365 4366
/*
  Drops in all fields instead of current '*' field

  SYNOPSIS
    insert_fields()
    thd			Thread handler
4367
    context             Context for name resolution
4368 4369 4370 4371 4372 4373 4374
    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
4375
    0	ok     'it' is updated to point at last inserted
unknown's avatar
unknown committed
4376
    1	error.  Error message is generated but not sent to client
4377
*/
unknown's avatar
unknown committed
4378

unknown's avatar
unknown committed
4379
bool
4380
insert_fields(THD *thd, Name_resolution_context *context, const char *db_name,
unknown's avatar
VIEW  
unknown committed
4381
	      const char *table_name, List_iterator<Item> *it,
4382
              bool any_privileges)
unknown's avatar
unknown committed
4383
{
unknown's avatar
unknown committed
4384 4385
  Field_iterator_table_ref field_iterator;
  bool found;
unknown's avatar
unknown committed
4386
  char name_buff[NAME_LEN+1];
unknown's avatar
unknown committed
4387
  DBUG_ENTER("insert_fields");
unknown's avatar
unknown committed
4388
  DBUG_PRINT("arena", ("stmt arena: 0x%lx", (ulong)thd->stmt_arena));
unknown's avatar
unknown committed
4389

4390 4391
  if (db_name && lower_case_table_names)
  {
unknown's avatar
unknown committed
4392 4393 4394 4395 4396
    /*
      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
4397
    strmake(name_buff, db_name, sizeof(name_buff)-1);
unknown's avatar
unknown committed
4398
    my_casedn_str(files_charset_info, name_buff);
unknown's avatar
unknown committed
4399
    db_name= name_buff;
4400 4401
  }

unknown's avatar
unknown committed
4402
  found= FALSE;
4403 4404 4405 4406 4407 4408 4409 4410

  /*
    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);
4411
       tables;
4412 4413 4414
       tables= (table_name ? tables->next_local :
                tables->next_name_resolution_table)
       )
unknown's avatar
unknown committed
4415
  {
4416 4417 4418
    Field *field;
    TABLE *table= tables->table;

unknown's avatar
unknown committed
4419 4420
    DBUG_ASSERT(tables->is_leaf_for_name_resolution());

4421 4422 4423 4424
    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
4425

unknown's avatar
unknown committed
4426
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
4427 4428 4429 4430 4431 4432 4433
    /* 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(),
4434 4435
                                  field_iterator.db_name(),
                                  field_iterator.table_name(),
unknown's avatar
unknown committed
4436 4437 4438
                                  &field_iterator))
        DBUG_RETURN(TRUE);
    }
unknown's avatar
unknown committed
4439
#endif
unknown's avatar
VIEW  
unknown committed
4440 4441


unknown's avatar
unknown committed
4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464
    /*
      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)
4465
      {
unknown's avatar
unknown committed
4466
        found= TRUE;
4467
        it->replace(item); /* Replace '*' with the first found item. */
4468
      }
unknown's avatar
VIEW  
unknown committed
4469
      else
unknown's avatar
unknown committed
4470 4471 4472 4473 4474 4475 4476
        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,
4477 4478 4479
        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
4480 4481
      */
      if (any_privileges)
4482
      {
unknown's avatar
unknown committed
4483 4484 4485 4486
        DBUG_ASSERT(tables->field_translation == NULL && table ||
                    tables->is_natural_join);
        DBUG_ASSERT(item->type() == Item::FIELD_ITEM);
        Item_field *fld= (Item_field*) item;
4487
        const char *field_table_name= field_iterator.table_name();
4488

unknown's avatar
unknown committed
4489 4490 4491 4492
        if (!tables->schema_table && 
            !(fld->have_privileges=
              (get_column_grant(thd, field_iterator.grant(),
                                field_iterator.db_name(),
4493
                                field_table_name, fld->field_name) &
unknown's avatar
unknown committed
4494 4495 4496 4497
               VIEW_ANY_ACL)))
        {
          my_error(ER_COLUMNACCESS_DENIED_ERROR, MYF(0), "ANY",
                   thd->priv_user, thd->host_or_ip,
4498
                   fld->field_name, field_table_name);
unknown's avatar
unknown committed
4499 4500
          DBUG_RETURN(TRUE);
        }
4501
      }
unknown's avatar
unknown committed
4502
#endif
4503

unknown's avatar
unknown committed
4504
      if ((field= field_iterator.field()))
unknown's avatar
unknown committed
4505
      {
unknown's avatar
unknown committed
4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517
        /*
          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
4518
        {
unknown's avatar
unknown committed
4519 4520 4521
          bool is_created;
          TABLE *field_table;
          /*
4522
            In this case we are sure that the column ref will not be created
unknown's avatar
unknown committed
4523
            because it was already created and stored with the natural join.
4524
          */
unknown's avatar
unknown committed
4525
          Natural_join_column *nj_col;
4526 4527
          if (!(nj_col= field_iterator.get_or_create_column_ref(thd,
                                                                &is_created)))
unknown's avatar
unknown committed
4528 4529 4530 4531
            DBUG_RETURN(TRUE);
          DBUG_ASSERT(nj_col->table_field && !is_created);
          field_table= nj_col->table_ref->table;
          if (field_table)
unknown's avatar
VIEW  
unknown committed
4532
          {
unknown's avatar
unknown committed
4533 4534 4535
            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
4536
          }
unknown's avatar
unknown committed
4537
        }
unknown's avatar
unknown committed
4538
      }
unknown's avatar
unknown committed
4539 4540 4541 4542 4543 4544
      else
      {
        thd->used_tables|= item->used_tables();
        item->walk(&Item::reset_query_id_processor,
                   (byte *)(&thd->query_id));
      }
unknown's avatar
unknown committed
4545
    }
unknown's avatar
unknown committed
4546 4547 4548 4549 4550 4551 4552 4553
    /*
      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
4554
  }
4555
  if (found)
unknown's avatar
unknown committed
4556
    DBUG_RETURN(FALSE);
4557

unknown's avatar
unknown committed
4558
  /*
4559 4560 4561
    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
4562
  */
4563
  if (!table_name)
unknown's avatar
unknown committed
4564
    my_message(ER_NO_TABLES_USED, ER(ER_NO_TABLES_USED), MYF(0));
4565 4566
  else
    my_error(ER_BAD_TABLE_ERROR, MYF(0), table_name);
unknown's avatar
unknown committed
4567 4568

  DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
4569 4570 4571 4572
}


/*
unknown's avatar
unknown committed
4573
  Fix all conditions and outer join expressions.
4574 4575 4576 4577

  SYNOPSIS
    setup_conds()
    thd     thread handler
unknown's avatar
unknown committed
4578 4579 4580 4581 4582 4583 4584 4585 4586 4587
    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
4588 4589
*/

4590 4591
int setup_conds(THD *thd, TABLE_LIST *tables, TABLE_LIST *leaves,
                COND **conds)
unknown's avatar
unknown committed
4592
{
unknown's avatar
unknown committed
4593
  SELECT_LEX *select_lex= thd->lex->current_select;
unknown's avatar
unknown committed
4594
  Query_arena *arena= thd->stmt_arena, backup;
unknown's avatar
unknown committed
4595
  TABLE_LIST *table= NULL;	// For HP compilers
4596 4597 4598 4599 4600 4601 4602 4603 4604 4605
  /*
    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
4606
  DBUG_ENTER("setup_conds");
unknown's avatar
unknown committed
4607

unknown's avatar
unknown committed
4608
  if (select_lex->conds_processed_with_permanent_arena ||
unknown's avatar
unknown committed
4609
      arena->is_conventional())
unknown's avatar
unknown committed
4610 4611
    arena= 0;                                   // For easier test

unknown's avatar
unknown committed
4612
  thd->set_query_id=1;
unknown's avatar
unknown committed
4613
  select_lex->cond_count= 0;
unknown's avatar
VIEW  
unknown committed
4614

4615 4616 4617 4618 4619 4620
  for (table= tables; table; table= table->next_local)
  {
    if (table->prepare_where(thd, conds, FALSE))
      goto err_no_arena;
  }

unknown's avatar
unknown committed
4621 4622 4623
  if (*conds)
  {
    thd->where="where clause";
4624
    if (!(*conds)->fixed && (*conds)->fix_fields(thd, conds) ||
unknown's avatar
unknown committed
4625
	(*conds)->check_cols(1))
4626
      goto err_no_arena;
unknown's avatar
unknown committed
4627 4628
  }

unknown's avatar
unknown committed
4629 4630 4631 4632
  /*
    Apply fix_fields() to all ON clauses at all levels of nesting,
    including the ones inside view definitions.
  */
unknown's avatar
merge  
unknown committed
4633
  for (table= leaves; table; table= table->next_leaf)
unknown's avatar
unknown committed
4634
  {
unknown's avatar
unknown committed
4635 4636
    TABLE_LIST *embedded; /* The table at the current level of nesting. */
    TABLE_LIST *embedding= table; /* The parent nested table reference. */
4637
    do
unknown's avatar
VIEW  
unknown committed
4638
    {
4639 4640
      embedded= embedding;
      if (embedded->on_expr)
4641
      {
4642 4643
        /* Make a join an a expression */
        thd->where="on clause";
unknown's avatar
VIEW  
unknown committed
4644
        if (!embedded->on_expr->fixed &&
4645
            embedded->on_expr->fix_fields(thd, &embedded->on_expr) ||
4646
	    embedded->on_expr->check_cols(1))
4647
	  goto err_no_arena;
unknown's avatar
unknown committed
4648
        select_lex->cond_count++;
4649
      }
4650
      embedding= embedded->embedding;
unknown's avatar
unknown committed
4651
    }
4652 4653
    while (embedding &&
           embedding->nested_join->join_list.head() == embedded);
4654 4655 4656 4657

    /* process CHECK OPTION */
    if (it_is_update)
    {
unknown's avatar
unknown committed
4658
      TABLE_LIST *view= table->top_table();
4659 4660 4661 4662 4663 4664 4665
      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
4666
  }
unknown's avatar
unknown committed
4667

unknown's avatar
unknown committed
4668
  if (!thd->stmt_arena->is_conventional())
unknown's avatar
unknown committed
4669 4670 4671 4672 4673 4674 4675 4676 4677 4678
  {
    /*
      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;
  }
4679
  DBUG_RETURN(test(thd->net.report_error));
unknown's avatar
unknown committed
4680 4681 4682

err:
  if (arena)
unknown's avatar
unknown committed
4683
    thd->restore_active_arena(arena, &backup);
4684
err_no_arena:
unknown's avatar
unknown committed
4685
  DBUG_RETURN(1);
unknown's avatar
unknown committed
4686 4687 4688 4689 4690 4691 4692 4693
}


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

unknown's avatar
unknown committed
4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709

/*
  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
4710
static bool
unknown's avatar
unknown committed
4711 4712
fill_record(THD * thd, List<Item> &fields, List<Item> &values,
            bool ignore_errors)
unknown's avatar
unknown committed
4713
{
unknown's avatar
unknown committed
4714
  List_iterator_fast<Item> f(fields),v(values);
unknown's avatar
unknown committed
4715 4716 4717 4718 4719 4720 4721
  Item *value;
  Item_field *field;
  DBUG_ENTER("fill_record");

  while ((field=(Item_field*) f++))
  {
    value=v++;
4722 4723
    Field *rfield= field->field;
    TABLE *table= rfield->table;
unknown's avatar
unknown committed
4724
    if (rfield == table->next_number_field)
unknown's avatar
unknown committed
4725
      table->auto_increment_field_not_null= TRUE;
unknown's avatar
unknown committed
4726
    if ((value->save_in_field(rfield, 0) < 0) && !ignore_errors)
unknown's avatar
unknown committed
4727 4728 4729 4730
    {
      my_message(ER_UNKNOWN_ERROR, ER(ER_UNKNOWN_ERROR), MYF(0));
      DBUG_RETURN(TRUE);
    }
unknown's avatar
unknown committed
4731
  }
unknown's avatar
unknown committed
4732
  DBUG_RETURN(thd->net.report_error);
unknown's avatar
unknown committed
4733 4734 4735
}


unknown's avatar
unknown committed
4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770
/*
  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
4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787
/*
  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
4788
{
unknown's avatar
unknown committed
4789
  List_iterator_fast<Item> v(values);
unknown's avatar
unknown committed
4790 4791 4792 4793 4794 4795 4796
  Item *value;
  DBUG_ENTER("fill_record");

  Field *field;
  while ((field = *ptr++))
  {
    value=v++;
4797
    TABLE *table= field->table;
unknown's avatar
unknown committed
4798
    if (field == table->next_number_field)
unknown's avatar
unknown committed
4799
      table->auto_increment_field_not_null= TRUE;
4800
    if (value->save_in_field(field, 0) == -1)
unknown's avatar
unknown committed
4801
      DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
4802
  }
unknown's avatar
unknown committed
4803
  DBUG_RETURN(thd->net.report_error);
unknown's avatar
unknown committed
4804 4805 4806
}


unknown's avatar
unknown committed
4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841
/*
  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
4842 4843
static void mysql_rm_tmp_tables(void)
{
unknown's avatar
unknown committed
4844 4845
  uint i, idx;
  char	filePath[FN_REFLEN], *tmpdir;
unknown's avatar
unknown committed
4846 4847 4848 4849
  MY_DIR *dirp;
  FILEINFO *file;
  DBUG_ENTER("mysql_rm_tmp_tables");

unknown's avatar
unknown committed
4850 4851 4852
  for (i=0; i<=mysql_tmpdir_list.max; i++)
  {
    tmpdir=mysql_tmpdir_list.list[i];
unknown's avatar
unknown committed
4853
  /* See if the directory exists */
unknown's avatar
unknown committed
4854 4855
    if (!(dirp = my_dir(tmpdir,MYF(MY_WME | MY_DONT_SORT))))
      continue;
unknown's avatar
unknown committed
4856

unknown's avatar
unknown committed
4857
    /* Remove all SQLxxx tables from directory */
unknown's avatar
unknown committed
4858

unknown's avatar
unknown committed
4859
  for (idx=0 ; idx < (uint) dirp->number_off_files ; idx++)
unknown's avatar
unknown committed
4860 4861
  {
    file=dirp->dir_entry+idx;
unknown's avatar
unknown committed
4862 4863 4864 4865 4866 4867

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

unknown's avatar
unknown committed
4868 4869
    if (!bcmp(file->name,tmp_file_prefix,tmp_file_prefix_length))
    {
unknown's avatar
unknown committed
4870 4871
        sprintf(filePath,"%s%s",tmpdir,file->name);
        VOID(my_delete(filePath,MYF(MY_WME)));
unknown's avatar
unknown committed
4872 4873 4874
    }
  }
  my_dirend(dirp);
unknown's avatar
unknown committed
4875
  }
unknown's avatar
unknown committed
4876 4877 4878 4879 4880 4881 4882 4883 4884 4885
  DBUG_VOID_RETURN;
}



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

/*
4886 4887 4888 4889 4890 4891 4892 4893 4894 4895
  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
4896 4897
*/

4898
void remove_db_from_cache(const char *db)
unknown's avatar
unknown committed
4899 4900 4901 4902
{
  for (uint idx=0 ; idx < open_cache.records ; idx++)
  {
    TABLE *table=(TABLE*) hash_element(&open_cache,idx);
4903
    if (!strcmp(table->s->db, db))
unknown's avatar
unknown committed
4904
    {
4905
      table->s->version= 0L;			/* Free when thread is ready */
unknown's avatar
unknown committed
4906 4907 4908 4909
      if (!table->in_use)
	relink_unused(table);
    }
  }
4910
  while (unused_tables && !unused_tables->s->version)
unknown's avatar
unknown committed
4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928
    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
4929 4930 4931 4932 4933
  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
4934 4935 4936
  PREREQUISITES
    Lock on LOCK_open()

unknown's avatar
unknown committed
4937 4938 4939 4940
  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
4941 4942
*/

4943
bool remove_table_from_cache(THD *thd, const char *db, const char *table_name,
unknown's avatar
unknown committed
4944
                             uint flags)
unknown's avatar
unknown committed
4945 4946 4947 4948
{
  char key[MAX_DBKEY_LENGTH];
  uint key_length;
  TABLE *table;
unknown's avatar
unknown committed
4949
  bool result=0, signalled= 0;
unknown's avatar
unknown committed
4950 4951
  DBUG_ENTER("remove_table_from_cache");

unknown's avatar
unknown committed
4952

unknown's avatar
unknown committed
4953
  key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
unknown's avatar
unknown committed
4954
  for (;;)
unknown's avatar
unknown committed
4955
  {
unknown's avatar
unknown committed
4956 4957 4958 4959 4960
    result= signalled= 0;

    for (table=(TABLE*) hash_search(&open_cache,(byte*) key,key_length) ;
         table;
         table = (TABLE*) hash_next(&open_cache,(byte*) key,key_length))
unknown's avatar
unknown committed
4961
    {
unknown's avatar
unknown committed
4962
      THD *in_use;
4963
      table->s->version=0L;		/* Free when thread is ready */
unknown's avatar
unknown committed
4964
      if (!(in_use=table->in_use))
unknown's avatar
unknown committed
4965
      {
unknown's avatar
unknown committed
4966 4967
        DBUG_PRINT("info",("Table was not in use"));
        relink_unused(table);
unknown's avatar
unknown committed
4968
      }
unknown's avatar
unknown committed
4969
      else if (in_use != thd)
4970
      {
unknown's avatar
unknown committed
4971 4972 4973 4974 4975 4976 4977
        in_use->some_tables_deleted=1;
        if (table->db_stat)
  	  result=1;
        /* Kill delayed insert threads */
        if ((in_use->system_thread & SYSTEM_THREAD_DELAYED_INSERT) &&
            ! in_use->killed)
        {
4978
	  in_use->killed= THD::KILL_CONNECTION;
unknown's avatar
unknown committed
4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997
	  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
4998
	    signalled|= mysql_lock_abort_for_thread(thd, thd_table);
unknown's avatar
unknown committed
4999
        }
5000
      }
unknown's avatar
unknown committed
5001
      else
unknown's avatar
unknown committed
5002
        result= result || (flags & RTFC_OWNED_BY_THD_FLAG);
unknown's avatar
unknown committed
5003
    }
unknown's avatar
unknown committed
5004
    while (unused_tables && !unused_tables->s->version)
unknown's avatar
unknown committed
5005
      VOID(hash_delete(&open_cache,(byte*) unused_tables));
unknown's avatar
unknown committed
5006
    if (result && (flags & RTFC_WAIT_OTHER_THREAD_FLAG))
unknown's avatar
unknown committed
5007
    {
unknown's avatar
unknown committed
5008
      if (!(flags & RTFC_CHECK_KILLED_FLAG) || !thd->killed)
5009
      {
unknown's avatar
unknown committed
5010
        dropping_tables++;
unknown's avatar
unknown committed
5011 5012 5013 5014
        if (likely(signalled))
          (void) pthread_cond_wait(&COND_refresh, &LOCK_open);
        else
        {
unknown's avatar
unknown committed
5015
          struct timespec abstime;
unknown's avatar
unknown committed
5016 5017 5018 5019 5020 5021 5022 5023 5024 5025
          /*
            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
5026 5027
          set_timespec(abstime, 10);
          pthread_cond_timedwait(&COND_refresh, &LOCK_open, &abstime);
unknown's avatar
unknown committed
5028
        }
unknown's avatar
unknown committed
5029 5030
        dropping_tables--;
        continue;
5031
      }
unknown's avatar
unknown committed
5032
    }
unknown's avatar
unknown committed
5033
    break;
unknown's avatar
unknown committed
5034 5035 5036 5037
  }
  DBUG_RETURN(result);
}

5038
int setup_ftfuncs(SELECT_LEX *select_lex)
unknown's avatar
unknown committed
5039
{
5040 5041
  List_iterator<Item_func_match> li(*(select_lex->ftfunc_list)),
                                 lj(*(select_lex->ftfunc_list));
5042
  Item_func_match *ftf, *ftf2;
unknown's avatar
unknown committed
5043 5044

  while ((ftf=li++))
5045
  {
unknown's avatar
unknown committed
5046 5047
    if (ftf->fix_index())
      return 1;
5048 5049
    lj.rewind();
    while ((ftf2=lj++) != ftf)
5050
    {
5051
      if (ftf->eq(ftf2,1) && !ftf2->master)
5052 5053 5054
        ftf2->master=ftf;
    }
  }
unknown's avatar
unknown committed
5055 5056 5057

  return 0;
}
5058

5059

5060
int init_ftfuncs(THD *thd, SELECT_LEX *select_lex, bool no_order)
5061
{
5062
  if (select_lex->ftfunc_list->elements)
5063
  {
5064
    List_iterator<Item_func_match> li(*(select_lex->ftfunc_list));
unknown's avatar
unknown committed
5065 5066 5067
    Item_func_match *ifm;
    DBUG_PRINT("info",("Performing FULLTEXT search"));
    thd->proc_info="FULLTEXT initialization";
5068

unknown's avatar
unknown committed
5069 5070 5071
    while ((ifm=li++))
      ifm->init_search(no_order);
  }
5072 5073
  return 0;
}
unknown's avatar
VIEW  
unknown committed
5074 5075 5076 5077 5078 5079 5080 5081 5082


/*
  open new .frm format table

  SYNOPSIS
    open_new_frm()
    path	  path to .frm
    alias	  alias for table
5083 5084
    db            database
    table_name    name of table
unknown's avatar
VIEW  
unknown committed
5085 5086 5087 5088 5089 5090 5091 5092
    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
*/
5093

unknown's avatar
VIEW  
unknown committed
5094
static my_bool
5095 5096 5097
open_new_frm(const char *path, const char *alias,
             const char *db, const char *table_name,
             uint db_stat, uint prgflag,
unknown's avatar
VIEW  
unknown committed
5098 5099 5100 5101
	     uint ha_open_flags, TABLE *outparam, TABLE_LIST *table_desc,
	     MEM_ROOT *mem_root)
{
  LEX_STRING pathstr;
5102 5103 5104 5105
  File_parser *parser;
  DBUG_ENTER("open_new_frm");

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

5108
  if ((parser= sql_parse_prepare(&pathstr, mem_root, 1)))
unknown's avatar
VIEW  
unknown committed
5109
  {
5110
    if (is_equal(&view_type, parser->type()))
unknown's avatar
VIEW  
unknown committed
5111
    {
5112
      if (table_desc == 0 || table_desc->required_type == FRMTYPE_TABLE)
unknown's avatar
VIEW  
unknown committed
5113
      {
unknown's avatar
unknown committed
5114
        my_error(ER_WRONG_OBJECT, MYF(0), db, table_name, "BASE TABLE");
5115
        goto err;
unknown's avatar
VIEW  
unknown committed
5116
      }
5117 5118
      if (mysql_make_view(parser, table_desc))
        goto err;
unknown's avatar
VIEW  
unknown committed
5119 5120 5121 5122 5123
    }
    else
    {
      /* only VIEWs are supported now */
      my_error(ER_FRM_UNKNOWN_TYPE, MYF(0), path,  parser->type()->str);
5124
      goto err;
unknown's avatar
VIEW  
unknown committed
5125
    }
5126
    DBUG_RETURN(0);
unknown's avatar
VIEW  
unknown committed
5127
  }
unknown's avatar
unknown committed
5128
 
5129 5130 5131
err:
  bzero(outparam, sizeof(TABLE));	// do not run repair
  DBUG_RETURN(1);
unknown's avatar
VIEW  
unknown committed
5132
}
5133 5134 5135 5136 5137 5138


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