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

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

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

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


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

#include "mysql_priv.h"
21
#include "sql_select.h"
22
#include "sp_head.h"
23
#include "sp.h"
24
#include "sql_trigger.h"
bk@work.mysql.com's avatar
bk@work.mysql.com committed
25 26 27 28 29 30 31 32 33 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 */

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua 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);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
38 39
static void free_cache_entry(TABLE *entry);
static void mysql_rm_tmp_tables(void);
40 41 42 43 44
static bool open_new_frm(THD *thd, const char *path, const char *alias,
                         const char *db, const char *table_name,
                         uint db_stat, uint prgflag,
                         uint ha_open_flags, TABLE *outparam,
                         TABLE_LIST *table_desc, MEM_ROOT *mem_root);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
45

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

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
54
bool table_cache_init(void)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
55 56
{
  mysql_rm_tmp_tables();
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com 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;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
60 61 62 63 64
}

void table_cache_free(void)
{
  DBUG_ENTER("table_cache_free");
65
  close_cached_tables((THD*) 0,0,(TABLE_LIST*) 0);
bk@work.mysql.com's avatar
bk@work.mysql.com 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 */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
107 108 109 110 111 112 113
			count)); /* purecov: inspected */
  }
}
#else
#define check_unused()
#endif

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi 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;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
162

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
}
bk@work.mysql.com's avatar
bk@work.mysql.com 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;
bk@work.mysql.com's avatar
bk@work.mysql.com 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
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
222 223 224 225

static void free_cache_entry(TABLE *table)
{
  DBUG_ENTER("free_cache_entry");
226
  safe_mutex_assert_owner(&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com 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() */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
246 247 248

void free_io_cache(TABLE *table)
{
249
  DBUG_ENTER("free_io_cache");
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
250
  if (table->sort.io_cache)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
251
  {
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi 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;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
255
  }
256
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com 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.
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
265

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

  VOID(pthread_mutex_lock(&LOCK_open));
274
  if (!tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
275
  {
276 277
    while (unused_tables)
    {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
278
#ifdef EXTRA_DEBUG
279 280
      if (hash_delete(&open_cache,(byte*) unused_tables))
	printf("Warning: Couldn't delete open table from hash\n");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
281
#else
282
      VOID(hash_delete(&open_cache,(byte*) unused_tables));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
283
#endif
284 285
    }
    refresh_version++;				// Force close of open tables
bk@work.mysql.com's avatar
bk@work.mysql.com committed
286
  }
287
  else
bk@work.mysql.com's avatar
bk@work.mysql.com committed
288
  {
289
    bool found=0;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
290
    for (TABLE_LIST *table= tables; table; table= table->next_local)
291
    {
292
      if (remove_table_from_cache(thd, table->db, table->table_name,
293
                                  RTFC_OWNED_BY_THD_FLAG))
294 295 296 297
	found=1;
    }
    if (!found)
      if_wait_for_refresh=0;			// Nothing to wait for
bk@work.mysql.com's avatar
bk@work.mysql.com committed
298
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
299
#ifndef EMBEDDED_LIBRARY
300 301
  if (!tables)
    kill_delayed_threads();
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
302
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com 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";

313
    close_old_data_files(thd,thd->open_tables,1,1);
314 315
    mysql_ha_flush(thd, tables, MYSQL_HA_REOPEN_ON_USAGE | MYSQL_HA_FLUSH_ALL,
                   TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
316 317
    bool found=1;
    /* Wait until all threads has closed all the tables we had locked */
318 319
    DBUG_PRINT("info",
	       ("Waiting for others threads to close their open tables"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
320 321 322 323 324 325
    while (found && ! thd->killed)
    {
      found=0;
      for (uint idx=0 ; idx < open_cache.records ; idx++)
      {
	TABLE *table=(TABLE*) hash_element(&open_cache,idx);
326
	if ((table->s->version) < refresh_version && table->db_stat)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
	{
	  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;
342
    /* Set version for table */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
343
    for (TABLE *table=thd->open_tables; table ; table= table->next)
344
      table->s->version= refresh_version;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
345 346 347 348 349 350 351 352 353 354 355 356 357 358
  }
  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);
}


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

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

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

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


/*
  Close all tables used by the current substatement, or all tables
  used by this thread if we are on the upper level.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
384

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

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

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

405
void close_thread_tables(THD *thd, bool lock_in_use, bool skip_derived)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
406
{
407
  bool found_old_table;
408
  prelocked_mode_type prelocked_mode= thd->prelocked_mode;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
409 410
  DBUG_ENTER("close_thread_tables");

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

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

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
504
  /* VOID(pthread_sigmask(SIG_SETMASK,&thd->block_signals,NULL)); */
505
  if (!lock_in_use)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
506
    VOID(pthread_mutex_lock(&LOCK_open));
507
  safe_mutex_assert_owner(&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
508

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

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
516
  /* Free tables to hold down open files */
517
  while (open_cache.records > table_cache_size && unused_tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
518 519 520 521 522 523 524
    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));
  }
525
  if (!lock_in_use)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
526 527
    VOID(pthread_mutex_unlock(&LOCK_open));
  /*  VOID(pthread_sigmask(SIG_SETMASK,&thd->signals,NULL)); */
528 529 530 531 532 533 534 535 536 537 538

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
539 540 541
  DBUG_VOID_RETURN;
}

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

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

  *table_ptr=table->next;
553
  if (table->s->version != refresh_version ||
554 555 556 557 558 559 560
      thd->version != refresh_version || !table->db_stat)
  {
    VOID(hash_delete(&open_cache,(byte*) table));
    found_old_table=1;
  }
  else
  {
561
    if (table->s->flush_version != flush_version)
562
    {
563
      table->s->flush_version= flush_version;
564 565 566 567 568
      table->file->extra(HA_EXTRA_FLUSH);
    }
    else
    {
      // Free memory and reset for next loop
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
569
      table->file->reset();
570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
    }
    table->in_use=0;
    if (unused_tables)
    {
      table->next=unused_tables;		/* Link in last */
      table->prev=unused_tables->prev;
      unused_tables->prev=table;
      table->prev->next=table;
    }
    else
      unused_tables=table->next=table->prev=table;
  }
  DBUG_RETURN(found_old_table);
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
585 586 587 588 589 590
	/* Close and delete temporary tables */

void close_temporary(TABLE *table,bool delete_table)
{
  DBUG_ENTER("close_temporary");
  char path[FN_REFLEN];
591 592
  db_type table_type=table->s->db_type;
  strmov(path,table->s->path);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
593 594 595 596 597 598 599 600 601 602 603 604
  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;
605 606 607
  char *query, *end;
  uint query_buf_size; 
  bool found_user_tables = 0;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
608

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

615
  for (table=thd->temporary_tables ; table ; table=table->next)
616 617 618 619 620 621
    /*
      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;
622

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
627 628
  for (table=thd->temporary_tables ; table ; table=next)
  {
629
    if (query) // we might be out of memory, but this is not fatal
630
    {
631 632 633 634 635
      // 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);
636
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
637
    next=table->next;
monty@mysql.com's avatar
monty@mysql.com committed
638
    close_temporary(table, 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
639
  }
640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656
  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);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
657 658 659 660
  thd->temporary_tables=0;
}


661
/*
662
  Find table in list.
663 664

  SYNOPSIS
665
    find_table_in_list()
666
    table		Pointer to table list
667
    offset		Offset to which list in table structure to use
668 669
    db_name		Data base name
    table_name		Table name
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
670

671 672 673
  NOTES:
    This is called by find_table_in_local_list() and
    find_table_in_global_list().
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
674 675 676 677 678 679

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

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


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

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

  RETURN
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
722 723
    found duplicate
    0 if table is unique
724 725
*/

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
726
TABLE_LIST* unique_table(TABLE_LIST *table, TABLE_LIST *table_list)
727
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
728
  TABLE_LIST *res;
729
  const char *d_name, *t_name;
serg@serg.mylan's avatar
serg@serg.mylan committed
730 731
  DBUG_ENTER("unique_table");
  DBUG_PRINT("enter", ("table alias: %s", table->alias));
732 733 734 735 736 737 738 739 740 741 742 743

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

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


bk@work.mysql.com's avatar
bk@work.mysql.com committed
832 833 834 835 836 837
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;

guilhem@mysql.com's avatar
guilhem@mysql.com committed
838 839
  int4store(key+key_length,thd->server_id);
  key_length += 4;
840
  int4store(key+key_length,thd->variables.pseudo_thread_id);
841
  key_length += 4;
842

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

guilhem@mysql.com's avatar
guilhem@mysql.com committed
868 869 870 871 872 873 874
/*
  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'.
*/
875

876
bool rename_temporary_table(THD* thd, TABLE *table, const char *db,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
877 878 879
			    const char *table_name)
{
  char *key;
880 881
  TABLE_SHARE *share= table->s;

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

  memcpy(key, find->s->table_cache_key, key_length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
930 931 932
  for (; list ; list=next)
  {
    next=list->next;
933 934
    if (list->s->key_length == key_length &&
	!memcmp(list->s->table_cache_key, key, key_length))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952
    {
      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;
}


953
/*
bk@work.mysql.com's avatar
bk@work.mysql.com committed
954
   When we call the following function we must have a lock on
955
   LOCK_open ; This lock will be unlocked on return.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
956 957 958 959
*/

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

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

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

979

980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998
/*
  Open table which is already name-locked by this thread.

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

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

  RETURN VALUE
    FALSE - Success
    TRUE  - Error
*/

bool reopen_name_locked_table(THD* thd, TABLE_LIST* table_list)
999
{
1000
  TABLE *table= table_list->table;
1001
  TABLE_SHARE *share;
1002 1003 1004 1005 1006 1007
  char *db= table_list->db;
  char *table_name= table_list->table_name;
  char key[MAX_DBKEY_LENGTH];
  uint key_length;
  TABLE orig_table;
  DBUG_ENTER("reopen_name_locked_table");
1008

1009 1010 1011 1012 1013 1014
  safe_mutex_assert_owner(&LOCK_open);

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

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

1017
  if (open_unireg_entry(thd, table, db, table_name, table_name, 0,
monty@mysql.com's avatar
monty@mysql.com committed
1018
                        thd->mem_root) ||
1019 1020
      !(table->s->table_cache_key= memdup_root(&table->mem_root, (char*) key,
                                               key_length)))
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1021
  {
1022 1023 1024 1025 1026 1027 1028 1029 1030
    intern_close_table(table);
    /*
      If there was an error during opening of table (for example if it
      does not exist) '*table' object can be wiped out. To be able
      properly release name-lock in this case we should restore this
      object to its original state.
    */
    *table= orig_table;
    DBUG_RETURN(TRUE);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1031
  }
1032

1033 1034 1035 1036 1037
  share= table->s;
  share->db= share->table_cache_key;
  share->key_length=key_length;
  share->version=0;
  share->flush_version=0;
1038 1039
  table->in_use = thd;
  check_unused();
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
1040 1041
  table->next = thd->open_tables;
  thd->open_tables = table;
1042 1043 1044
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
1045
  table->null_row= table->maybe_null= table->force_index= 0;
1046
  table->status=STATUS_NO_RECORD;
1047 1048
  table->keys_in_use_for_query= share->keys_in_use;
  table->used_keys= share->keys_for_keyread;
1049
  DBUG_RETURN(FALSE);
1050 1051
}

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

1053 1054 1055 1056 1057
/*
  Open a table.

  SYNOPSIS
    open_table()
1058 1059 1060 1061 1062 1063 1064 1065 1066 1067
    thd                 Thread context.
    table_list          Open first table in list.
    refresh      INOUT  Pointer to memory that will be set to 1 if
                        we need to close all tables and reopen them.
                        If this is a NULL pointer, then the table is not
                        put in the thread-open-list.
    flags               Bitmap of flags to modify how open works:
                          MYSQL_LOCK_IGNORE_FLUSH - Open table even if
                          someone has done a flush or namelock on it.
                          No version number checking is done.
1068 1069 1070 1071 1072 1073

  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
1074
          all other tables and retry the open.
1075 1076
    #     Success. Pointer to TABLE object for open table.
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1077 1078


bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1079
TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
1080
		  bool *refresh, uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1081 1082 1083 1084
{
  reg1	TABLE *table;
  char	key[MAX_DBKEY_LENGTH];
  uint	key_length;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1085
  char	*alias= table_list->alias;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1086 1087 1088 1089 1090
  DBUG_ENTER("open_table");

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

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1096 1097
  if (thd->killed)
    DBUG_RETURN(0);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1098
  key_length= (uint) (strmov(strmov(key, table_list->db)+1,
1099
			     table_list->table_name)-key)+1;
guilhem@mysql.com's avatar
guilhem@mysql.com committed
1100
  int4store(key + key_length, thd->server_id);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1101
  int4store(key + key_length + 4, thd->variables.pseudo_thread_id);
1102

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1103
  if (!table_list->skip_temporary)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1104
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1105
    for (table= thd->temporary_tables; table ; table=table->next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1106
    {
1107 1108
      if (table->s->key_length == key_length + TMP_TABLE_KEY_EXTRA &&
	  !memcmp(table->s->table_cache_key, key,
monty@mysql.com's avatar
monty@mysql.com committed
1109
		  key_length + TMP_TABLE_KEY_EXTRA))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1110
      {
1111 1112
	if (table->query_id == thd->query_id ||
            thd->prelocked_mode && table->query_id)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1113
	{
1114
	  my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1115 1116 1117 1118 1119
	  DBUG_RETURN(0);
	}
	table->query_id= thd->query_id;
	table->clear_query_id= 1;
	thd->tmp_table_used= 1;
monty@mysql.com's avatar
monty@mysql.com committed
1120 1121
        DBUG_PRINT("info",("Using temporary table"));
        goto reset;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1122 1123 1124 1125
      }
    }
  }

1126
  if (thd->locked_tables || thd->prelocked_mode)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1127
  {						// Using table locks
1128
    TABLE *best_table= 0;
1129
    int best_distance= INT_MIN;
1130 1131 1132
    bool check_if_used= thd->prelocked_mode &&
                        ((int) table_list->lock_type >=
                         (int) TL_WRITE_ALLOW_WRITE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1133 1134
    for (table=thd->open_tables; table ; table=table->next)
    {
1135
      if (table->s->key_length == key_length &&
1136
          !memcmp(table->s->table_cache_key, key, key_length))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1137
      {
1138 1139
        if (check_if_used && table->query_id &&
            table->query_id != thd->query_id)
1140
        {
1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184
          /*
            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;
            }
          }
1185
        }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1186
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1187
    }
1188 1189 1190 1191 1192 1193 1194
    if (best_table)
    {
      table= best_table;
      table->query_id= thd->query_id;
      DBUG_PRINT("info",("Using locked table"));
      goto reset;
    }
1195 1196 1197 1198 1199 1200 1201
    /*
      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];
1202
      db_type not_used;
1203
      strxnmov(path, FN_REFLEN, mysql_data_home, "/", table_list->db, "/",
1204
               table_list->table_name, reg_ext, NullS);
1205
      (void) unpack_filename(path, path);
1206
      if (mysql_frm_type(thd, path, &not_used) == FRMTYPE_VIEW)
1207
      {
1208 1209 1210 1211 1212
        /*
          Will not be used (because it's VIEW) but has to be passed.
          Also we will not free it (because it is a stack variable).
        */
        TABLE tab;
1213
        table= &tab;
1214
        VOID(pthread_mutex_lock(&LOCK_open));
1215 1216 1217
        if (!open_unireg_entry(thd, table, table_list->db,
                               table_list->table_name,
                               alias, table_list, mem_root))
1218
        {
1219
          DBUG_ASSERT(table_list->view != 0);
1220 1221 1222 1223 1224 1225
          VOID(pthread_mutex_unlock(&LOCK_open));
          DBUG_RETURN(0); // VIEW
        }
        VOID(pthread_mutex_unlock(&LOCK_open));
      }
    }
1226
    my_error(ER_TABLE_NOT_LOCKED, MYF(0), alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1227 1228
    DBUG_RETURN(0);
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1229

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1230 1231 1232 1233
  VOID(pthread_mutex_lock(&LOCK_open));

  if (!thd->open_tables)
    thd->version=refresh_version;
1234 1235
  else if ((thd->version != refresh_version) &&
           ! (flags & MYSQL_LOCK_IGNORE_FLUSH))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1236 1237
  {
    /* Someone did a refresh while thread was opening tables */
1238 1239
    if (refresh)
      *refresh=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1240 1241 1242 1243
    VOID(pthread_mutex_unlock(&LOCK_open));
    DBUG_RETURN(0);
  }

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1248 1249 1250 1251
  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))
  {
1252
    if (table->s->version != refresh_version)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1253
    {
1254 1255 1256 1257 1258 1259 1260
      if (flags & MYSQL_LOCK_IGNORE_FLUSH)
      {
        /* Force close at once after usage */
        thd->version= table->s->version;
        continue;
      }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1261
      /*
1262 1263
        There is a refresh in progress for this table
        Wait until the table is freed or the thread is killed.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1264
      */
1265
      close_old_data_files(thd,thd->open_tables,0,0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1266 1267 1268
      if (table->in_use != thd)
	wait_for_refresh(thd);
      else
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1269
      {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1270
	VOID(pthread_mutex_unlock(&LOCK_open));
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1271
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286
      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;
1287
    table->in_use= thd;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1288 1289 1290
  }
  else
  {
1291
    TABLE_SHARE *share;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1292
    /* Free cache if too big */
1293
    while (open_cache.records > table_cache_size && unused_tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1294 1295 1296 1297
      VOID(hash_delete(&open_cache,(byte*) unused_tables)); /* purecov: tested */

    /* make a new table */
    if (!(table=(TABLE*) my_malloc(sizeof(*table),MYF(MY_WME))))
1298 1299
    {
      VOID(pthread_mutex_unlock(&LOCK_open));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1300
      DBUG_RETURN(NULL);
1301
    }
1302
    if (open_unireg_entry(thd, table, table_list->db, table_list->table_name,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1303 1304
			  alias, table_list, mem_root) ||
	(!table_list->view && 
1305 1306 1307
	 !(table->s->table_cache_key= memdup_root(&table->mem_root,
                                                  (char*) key,
                                                  key_length))))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1308 1309 1310 1311 1312 1313
    {
      table->next=table->prev=table;
      free_cache_entry(table);
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(NULL);
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1314 1315 1316 1317 1318 1319
    if (table_list->view)
    {
      my_free((gptr)table, MYF(0));
      VOID(pthread_mutex_unlock(&LOCK_open));
      DBUG_RETURN(0); // VIEW
    }
1320 1321 1322 1323 1324
    share= table->s;
    share->db=            share->table_cache_key;
    share->key_length=    key_length;
    share->version=       refresh_version;
    share->flush_version= flush_version;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1325
    DBUG_PRINT("info", ("inserting table %p into the cache", table));
hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
1326
    VOID(my_hash_insert(&open_cache,(byte*) table));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1327 1328
  }

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1331 1332 1333 1334 1335 1336 1337 1338 1339
  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:
1340 1341
  if (thd->lex->need_correct_ident())
    table->alias_name_used= my_strcasecmp(table_alias_charset,
1342
                                          table->s->table_name, alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1343
  /* Fix alias if table name changes */
1344
  if (strcmp(table->alias, alias))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1345
  {
1346
    uint length=(uint) strlen(alias)+1;
1347 1348 1349
    table->alias= (char*) my_realloc((char*) table->alias, length,
                                     MYF(MY_WME));
    memcpy((char*) table->alias, alias, length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1350 1351 1352 1353 1354
  }
  /* These variables are also set in reopen_table() */
  table->tablenr=thd->current_tablenr++;
  table->used_fields=0;
  table->const_table=0;
1355
  table->null_row= table->maybe_null= table->force_index= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1356
  table->status=STATUS_NO_RECORD;
1357
  table->keys_in_use_for_query= table->s->keys_in_use;
1358
  table->insert_values= 0;
1359
  table->used_keys= table->s->keys_for_keyread;
1360 1361
  table->fulltext_searched= 0;
  table->file->ft_handler= 0;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1362
  if (table->timestamp_field)
1363
    table->timestamp_field_type= table->timestamp_field->get_auto_set_type();
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1364
  table_list->updatable= 1; // It is not derived table nor non-updatable VIEW
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
1365
  DBUG_ASSERT(table->key_read == 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376
  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)
  {
1377 1378
    if (table->s->key_length == key_length &&
	!memcmp(table->s->table_cache_key,key,key_length))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394
      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;
1395 1396 1397
  char *db= table->s->table_cache_key;
  const char *table_name= table->s->table_name;
  bool error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1398 1399 1400 1401 1402 1403 1404
  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",
1405
		    table->alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1406 1407 1408
#endif
  if (!locked)
    VOID(pthread_mutex_lock(&LOCK_open));
1409
  safe_mutex_assert_owner(&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1410

1411
  if (open_unireg_entry(table->in_use, &tmp, db, table_name,
1412
			table->alias, 0, table->in_use->mem_root))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1413 1414 1415
    goto end;
  free_io_cache(table);

1416 1417
  if (!(tmp.s->table_cache_key= memdup_root(&tmp.mem_root,db,
                                            table->s->key_length)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1418
  {
1419
    delete tmp.triggers;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1420 1421 1422
    closefrm(&tmp);				// End of memory
    goto end;
  }
1423
  tmp.s->db= tmp.s->table_cache_key;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1424

1425
  /* This list copies variables set by open_table */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1426 1427 1428 1429
  tmp.tablenr=		table->tablenr;
  tmp.used_fields=	table->used_fields;
  tmp.const_table=	table->const_table;
  tmp.null_row=		table->null_row;
1430
  tmp.maybe_null=	table->maybe_null;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1431
  tmp.status=		table->status;
1432 1433
  tmp.keys_in_use_for_query= tmp.s->keys_in_use;
  tmp.used_keys= 	tmp.s->keys_for_keyread;
1434 1435

  /* Get state */
1436
  tmp.s->key_length=	table->s->key_length;
1437 1438
  tmp.in_use=    	table->in_use;
  tmp.reginfo.lock_type=table->reginfo.lock_type;
1439 1440
  tmp.s->version=	refresh_version;
  tmp.s->tmp_table=	table->s->tmp_table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1441 1442
  tmp.grant=		table->grant;

1443
  /* Replace table in open list */
1444 1445
  tmp.next=		table->next;
  tmp.prev=		table->prev;
1446

1447
  delete table->triggers;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1448 1449 1450
  if (table->file)
    VOID(closefrm(table));		// close file, free everything

1451 1452
  *table= tmp;
  table->s= &table->share_not_to_be_used;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1453 1454
  table->file->change_table_ptr(table);

1455
  DBUG_ASSERT(table->alias != 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1456 1457
  for (field=table->field ; *field ; field++)
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1458
    (*field)->table= (*field)->orig_table= table;
1459
    (*field)->table_name= &table->alias;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1460
  }
1461
  for (key=0 ; key < table->s->keys ; key++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1462
    for (part=0 ; part < table->key_info[key].usable_key_parts ; part++)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1463
      table->key_info[key].key_part[part].field->table= table;
1464 1465 1466
  if (table->triggers)
    table->triggers->set_table(table);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487
  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)
  {
1488 1489
    if (!strcmp(table->s->table_name, table_name) &&
	!strcmp(table->s->db, db))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507
    {
      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");
1508 1509
  safe_mutex_assert_owner(&LOCK_open);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1510 1511 1512 1513 1514
  if (!thd->open_tables)
    DBUG_RETURN(0);

  TABLE *table,*next,**prev;
  TABLE **tables,**tables_ptr;			// For locks
1515
  bool error=0, not_used;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533
  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)))
    {
1534
      my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545
      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)
      {
1546
	table->s->version=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1547 1548 1549 1550 1551 1552 1553 1554 1555
	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;
1556 1557
    if ((lock= mysql_lock_tables(thd, tables, (uint) (tables_ptr - tables),
                                 0, &not_used)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578
    {
      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.
*/

1579 1580
void close_old_data_files(THD *thd, TABLE *table, bool abort_locks,
			  bool send_refresh)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1581
{
1582 1583
  DBUG_ENTER("close_old_data_files");
  bool found=send_refresh;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1584 1585
  for (; table ; table=table->next)
  {
1586
    if (table->s->version != refresh_version)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1587 1588 1589
    {
      found=1;
      if (!abort_locks)				// If not from flush tables
1590
	table->s->version= refresh_version;	// Let other threads use table
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605
      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
1606
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1607 1608 1609 1610 1611 1612 1613 1614 1615
}


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

1616
bool table_is_used(TABLE *table, bool wait_for_name_lock)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1617 1618 1619
{
  do
  {
1620 1621
    char *key= table->s->table_cache_key;
    uint key_length= table->s->key_length;
1622 1623
    for (TABLE *search=(TABLE*) hash_search(&open_cache,
					    (byte*) key,key_length) ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1624 1625 1626 1627
	 search ;
	 search = (TABLE*) hash_next(&open_cache,(byte*) key,key_length))
    {
      if (search->locked_by_flush ||
1628
	  search->locked_by_name && wait_for_name_lock ||
1629
	  search->db_stat && search->s->version < refresh_version)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645
	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);
1646
  while (!thd->killed)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1647
  {
1648 1649
    thd->some_tables_deleted=0;
    close_old_data_files(thd,thd->open_tables,0,dropping_tables != 0);
1650
    mysql_ha_flush(thd, (TABLE_LIST*) NULL, MYSQL_HA_REOPEN_ON_USAGE, TRUE);
1651 1652
    if (!table_is_used(thd->open_tables,1))
      break;
1653
    (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1654 1655 1656 1657 1658 1659 1660
  }
  if (thd->killed)
    result= 1;					// aborted
  else
  {
    /* Now we can open all tables without any interference */
    thd->proc_info="Reopen tables";
antony@ltantony.mysql.com's avatar
antony@ltantony.mysql.com committed
1661
    thd->version= refresh_version;
1662
    result=reopen_tables(thd,0,0);
1663
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676
  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;
1677
  for (table= thd->open_tables; table ; table=next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1678 1679
  {
    next=table->next;
1680 1681
    if (!strcmp(table->s->table_name, table_name) &&
	!strcmp(table->s->db, db))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704
    {
      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;
}


1705 1706 1707 1708 1709
/*
  If we have the table open, which only happens when a LOCK TABLE has been
  done on the table, change the lock type to a lock that will abort all
  other threads trying to get the lock.
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1710 1711 1712 1713

void abort_locked_tables(THD *thd,const char *db, const char *table_name)
{
  TABLE *table;
1714
  for (table= thd->open_tables; table ; table= table->next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1715
  {
1716 1717
    if (!strcmp(table->s->table_name,table_name) &&
	!strcmp(table->s->db, db))
1718
    {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1719
      mysql_lock_abort(thd,table);
1720 1721
      break;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1722 1723 1724
  }
}

1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735

/*
  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
1736
    table_desc		TABLE_LIST descriptor (used with views)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1737
    mem_root		temporary mem_root for parsing
1738 1739 1740 1741 1742 1743 1744

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

  RETURN
    0	ok
    #	Error
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1745
*/
1746
static int open_unireg_entry(THD *thd, TABLE *entry, const char *db,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1747 1748
			     const char *name, const char *alias,
			     TABLE_LIST *table_desc, MEM_ROOT *mem_root)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1749 1750
{
  char path[FN_REFLEN];
1751
  int error;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1752
  uint discover_retry_count= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1753 1754
  DBUG_ENTER("open_unireg_entry");

1755
  strxmov(path, mysql_data_home, "/", db, "/", name, NullS);
1756
  while ((error= openfrm(thd, path, alias,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1757 1758
		         (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
			         HA_GET_INDEX | HA_TRY_READ_ONLY |
1759
                                 NO_ERR_ON_NEW_FRM),
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1760 1761 1762
		      READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
		      thd->open_options, entry)) &&
      (error != 5 ||
1763
       (fn_format(path, path, 0, reg_ext, MY_UNPACK_FILENAME),
1764
        open_new_frm(thd, path, alias, db, name,
1765 1766 1767 1768
                     (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))))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1769

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1770
  {
1771
    if (!entry->s || !entry->s->crashed)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1772 1773
    {
      /*
1774 1775 1776 1777
        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.
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1778 1779
      */
      if (discover_retry_count++ != 0)
monty@mysql.com's avatar
monty@mysql.com committed
1780
        goto err;
1781
      if (ha_create_table_from_engine(thd, db, name) > 0)
1782 1783 1784
      {
        /* Give right error message */
        thd->clear_error();
1785
        DBUG_PRINT("error", ("Discovery of %s/%s failed", db, name));
1786 1787 1788 1789 1790
        my_printf_error(ER_UNKNOWN_ERROR,
                        "Failed to open '%-.64s', error while "
                        "unpacking from engine",
                        MYF(0), name);

monty@mysql.com's avatar
monty@mysql.com committed
1791
        goto err;
1792
      }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1793

monty@mysql.com's avatar
monty@mysql.com committed
1794
      mysql_reset_errors(thd, 1);    // Clear warnings
1795
      thd->clear_error();            // Clear error message
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1796 1797
      continue;
    }
1798

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1799
    // Code below is for repairing a crashed file
1800
    TABLE_LIST table_list;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1801
    bzero((char*) &table_list, sizeof(table_list)); // just for safe
1802
    table_list.db=(char*) db;
1803
    table_list.table_name=(char*) name;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1804

1805 1806
    safe_mutex_assert_owner(&LOCK_open);

1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819
    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);
1820 1821
    thd->clear_error();				// Clear error message
    error= 0;
1822
    if (openfrm(thd, path, alias,
1823 1824 1825 1826
		(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,
1827
		entry) || ! entry->file ||
1828 1829
	(entry->file->is_crashed() && entry->file->check_and_repair(thd)))
    {
1830
      /* Give right error message */
1831
      thd->clear_error();
1832
      my_error(ER_NOT_KEYFILE, MYF(0), name, my_errno);
serg@serg.mylan's avatar
serg@serg.mylan committed
1833
      sql_print_error("Couldn't repair table: %s.%s",db,name);
1834 1835
      if (entry->file)
	closefrm(entry);
1836 1837
      error=1;
    }
1838
    else
1839
      thd->clear_error();			// Clear error message
1840
    pthread_mutex_lock(&LOCK_open);
1841
    unlock_table_name(thd,&table_list);
1842

1843 1844
    if (error)
      goto err;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1845 1846
    break;
  }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1847 1848 1849 1850

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

1851 1852 1853 1854 1855 1856 1857 1858 1859
  /*
    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;

1860
  if (Table_triggers_list::check_n_load(thd, db, name, entry, 0))
1861 1862
    goto err;

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877
  /*
    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);
1878
        Query_log_event qinfo(thd, query, (ulong)(end-query), 0, FALSE);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1879 1880 1881 1882 1883 1884 1885 1886 1887 1888
        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).
        */
serg@serg.mylan's avatar
serg@serg.mylan committed
1889
        sql_print_error("When opening HEAP table, could not allocate \
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1890
memory to write 'DELETE FROM `%s`.`%s`' to the binary log",db,name);
1891
        delete entry->triggers;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1892 1893 1894 1895 1896
        if (entry->file)
          closefrm(entry);
        goto err;
      }
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1897 1898
  }
  DBUG_RETURN(0);
1899
err:
1900
  /* Hide "Table doesn't exist" errors if table belong to view */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1901 1902
  if (thd->net.last_errno == ER_NO_SUCH_TABLE &&
      table_desc && table_desc->belong_to_view)
1903
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1904
    TABLE_LIST *view= table_desc->belong_to_view;
1905 1906 1907
    thd->clear_error();
    my_error(ER_VIEW_INVALID, MYF(0), view->view_db.str, view->view_name.str);
  }
1908
  DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1909 1910
}

1911

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1912 1913 1914 1915 1916 1917
/*
  Open all tables in list

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

1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934
  NOTE
    Unless we are already in prelocked mode, this function will also precache
    all SP/SFs explicitly or implicitly (via views and triggers) used by the
    query and add tables needed for their execution to table list. If resulting
    tables list will be non empty it will mark query as requiring precaching.
    Prelocked mode will be enabled for such query during lock_tables() call.

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

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1935 1936 1937 1938 1939
  RETURN
    0  - OK
    -1 - error
*/

1940
int open_tables(THD *thd, TABLE_LIST **start, uint *counter, uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1941 1942 1943 1944
{
  TABLE_LIST *tables;
  bool refresh;
  int result=0;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1945
  MEM_ROOT new_frm_mem;
1946 1947 1948
  /* Also used for indicating that prelocking is need */
  TABLE_LIST **query_tables_last_own;
  DBUG_ENTER("open_tables");
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1949 1950 1951 1952 1953
  /*
    temporary mem_root for new .frm parsing.
    TODO: variables for size
  */
  init_alloc_root(&new_frm_mem, 8024, 8024);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1954

1955
  thd->current_tablenr= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1956
 restart:
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1957
  *counter= 0;
1958
  query_tables_last_own= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1959
  thd->proc_info="Opening tables";
1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978

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

1980
    NOTE: The above notes may be out of date. Please wait for psergey to
1981
          document new prelocked behavior.
1982
  */
1983 1984

  if (!thd->prelocked_mode && !thd->lex->requires_prelocking() &&
1985
      thd->lex->sroutines_list.elements)
1986
  {
1987
    bool first_no_prelocking, need_prelocking, tabs_changed;
1988
    TABLE_LIST **save_query_tables_last= thd->lex->query_tables_last;
1989 1990

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

1993 1994
    if (sp_cache_routines_and_add_tables(thd, thd->lex,
                                         first_no_prelocking,
1995
                                         &tabs_changed))
1996
    {
1997 1998 1999 2000 2001 2002
      /*
        Serious error during reading stored routines from mysql.proc table.
        Something's wrong with the table or its contents, and an error has
        been emitted; we must abort.
      */
      result= -1;
2003 2004 2005
      goto err;
    }
    else if ((tabs_changed || *start) && need_prelocking)
2006 2007 2008 2009 2010 2011 2012
    {
      query_tables_last_own= save_query_tables_last;
      *start= thd->lex->query_tables;
    }
  }

  for (tables= *start; tables ;tables= tables->next_global)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2013
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2014 2015 2016
    /*
      Ignore placeholders for derived tables. After derived tables
      processing, link to created temporary table will be put here.
2017 2018
      If this is derived table for view then we still want to process
      routines used by this view.
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2019 2020
     */
    if (tables->derived)
2021 2022 2023
    {
      if (tables->view)
        goto process_view_routines;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2024
      continue;
2025
    }
2026 2027 2028 2029 2030 2031
    if (tables->schema_table)
    {
      if (!mysql_schema_table(thd, thd->lex, tables))
        continue;
      DBUG_RETURN(-1);
    }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2032
    (*counter)++;
2033
    
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2034
    if (!tables->table &&
2035
	!(tables->table= open_table(thd, tables, &new_frm_mem, &refresh, flags)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2036
    {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2037
      free_root(&new_frm_mem, MYF(MY_KEEP_PREALLOC));
2038

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2039 2040
      if (tables->view)
      {
2041
        /* VIEW placeholder */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2042
	(*counter)--;
2043

2044
        /*
2045 2046 2047 2048 2049
          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
2050 2051 2052
          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.
2053
        */
2054
        if (query_tables_last_own == &(tables->next_global) &&
2055 2056
            tables->view->query_tables)
          query_tables_last_own= tables->view->query_tables_last;
2057
        /*
2058 2059
          Let us free memory used by 'sroutines' hash here since we never
          call destructor for this LEX.
2060
        */
2061
        hash_free(&tables->view->sroutines);
2062
	goto process_view_routines;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2063 2064
      }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2065 2066 2067 2068
      if (refresh)				// Refresh in progress
      {
	/* close all 'old' tables used by this thread */
	pthread_mutex_lock(&LOCK_open);
2069 2070
	// if query_id is not reset, we will get an error
	// re-opening a temp table
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2071 2072 2073
	thd->version=refresh_version;
	TABLE **prev_table= &thd->open_tables;
	bool found=0;
2074
	for (TABLE_LIST *tmp= *start; tmp; tmp= tmp->next_global)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2075
	{
2076
	  /* Close normal (not temporary) changed tables */
2077
	  if (tmp->table && ! tmp->table->s->tmp_table)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2078
	  {
2079
	    if (tmp->table->s->version != refresh_version ||
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093
		! 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;
2094
	pthread_mutex_unlock(&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2095 2096
	if (found)
	  VOID(pthread_cond_broadcast(&COND_refresh)); // Signal to refresh
2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108
        /*
          Let us prepare for recalculation of set of prelocked tables.
          First we pretend that we have finished calculation which we
          were doing currently. Then we restore list of tables to be
          opened and set of used routines to the state in which they were
          before first open_tables() call for this statement (i.e. before
          we have calculated current set of tables for prelocking).
        */
        if (query_tables_last_own)
          thd->lex->mark_as_requiring_prelocking(query_tables_last_own);
        thd->lex->chop_off_not_own_tables();
        sp_remove_not_own_routines(thd->lex);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2109 2110 2111 2112 2113
	goto restart;
      }
      result= -1;				// Fatal error
      break;
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2114
    else
2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128
    {
      /*
        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)
2129 2130
          query_tables_last_own= thd->lex->query_tables_last;
        if (sp_cache_routines_and_add_tables_for_triggers(thd, thd->lex,
2131
                                                   tables->table->triggers))
2132
        {
2133 2134 2135 2136 2137 2138
          /*
            Serious error during reading stored routines from mysql.proc table.
            Something's wrong with the table or its contents, and an error has
            been emitted; we must abort.
          */
          result= -1;
2139 2140
          goto err;
        }
2141
      }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2142
      free_root(&new_frm_mem, MYF(MY_KEEP_PREALLOC));
2143
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2144

2145
    if (tables->lock_type != TL_UNLOCK && ! thd->locked_tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2146 2147
      tables->table->reginfo.lock_type=tables->lock_type;
    tables->table->grant= tables->grant;
2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160

process_view_routines:
    /*
      Again we may need cache all routines used by this view and add
      tables used by them to table list.
    */
    if (tables->view && !thd->prelocked_mode &&
        !thd->lex->requires_prelocking() &&
        tables->view->sroutines_list.elements)
    {
      /* We have at least one table in TL here. */
      if (!query_tables_last_own)
        query_tables_last_own= thd->lex->query_tables_last;
2161
      if (sp_cache_routines_and_add_tables_for_view(thd, thd->lex,
2162
                                                    tables->view))
2163
      {
2164 2165 2166 2167 2168 2169
        /*
          Serious error during reading stored routines from mysql.proc table.
          Something's wrong with the table or its contents, and an error has
          been emitted; we must abort.
        */
        result= -1;
2170 2171
        goto err;
      }
2172
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2173
  }
2174 2175

 err:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2176
  thd->proc_info=0;
2177
  free_root(&new_frm_mem, MYF(0));              // Free pre-alloced block
2178 2179 2180 2181

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2182 2183 2184 2185
  DBUG_RETURN(result);
}


2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208
/*
  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)
  {
2209
    my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),table->alias);
2210 2211
    DBUG_RETURN(1);
  }
serg@serg.mylan's avatar
serg@serg.mylan committed
2212
  if ((error=table->file->start_stmt(thd, lock_type)))
2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229
  {
    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

2230 2231 2232 2233 2234
  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.

2235 2236 2237 2238 2239 2240 2241 2242 2243
  RETURN VALUES
    table		Opened table
    0			Error
  
    If ok, the following are also set:
      table_list->lock_type 	lock_type
      table_list->table		table
*/

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2244 2245 2246 2247 2248 2249 2250
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";
2251
  thd->current_tablenr= 0;
2252 2253
  /* open_ltable can be used only for BASIC TABLEs */
  table_list->required_type= FRMTYPE_TABLE;
2254
  while (!(table= open_table(thd, table_list, thd->mem_root, &refresh, 0)) &&
2255
         refresh)
2256
    ;
2257

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2258 2259
  if (table)
  {
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2260
#if defined( __WIN__) || defined(OS2)
2261
    /* Win32 can't drop a file that is open */
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2262
    if (lock_type == TL_WRITE_ALLOW_READ)
2263 2264 2265
    {
      lock_type= TL_WRITE;
    }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2266
#endif /* __WIN__ || OS2 */
2267 2268
    table_list->lock_type= lock_type;
    table_list->table=	   table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2269 2270 2271
    table->grant= table_list->grant;
    if (thd->locked_tables)
    {
2272 2273 2274 2275 2276
      if (check_lock_and_start_stmt(thd, table, lock_type))
	table= 0;
    }
    else
    {
2277
      DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
2278
      if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)
2279 2280
	if (! (thd->lock= mysql_lock_tables(thd, &table_list->table, 1, 0,
                                            &refresh)))
2281
	  table= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2282 2283 2284 2285 2286 2287
    }
  }
  thd->proc_info=0;
  DBUG_RETURN(table);
}

2288

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2289
/*
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302
  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
2303
    The lock will automaticaly be freed by close_thread_tables()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2304 2305
*/

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2306
int simple_open_n_lock_tables(THD *thd, TABLE_LIST *tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2307
{
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2308
  uint counter;
2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321
  bool need_reopen;
  DBUG_ENTER("simple_open_n_lock_tables");

  for ( ; ; ) 
  {
    if (open_tables(thd, &tables, &counter, 0))
      DBUG_RETURN(-1);
    if (!lock_tables(thd, tables, counter, &need_reopen))
      break;
    if (!need_reopen)
      DBUG_RETURN(-1);
    close_tables_for_reopen(thd, tables);
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335
  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
2336 2337
    FALSE - ok
    TRUE  - error
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2338 2339

  NOTE
2340
    The lock will automaticaly be freed by close_thread_tables()
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2341 2342
*/

2343
bool open_and_lock_tables(THD *thd, TABLE_LIST *tables)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2344 2345
{
  uint counter;
2346
  bool need_reopen;
monty@mysql.com's avatar
monty@mysql.com committed
2347
  DBUG_ENTER("open_and_lock_tables");
2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359

  for ( ; ; ) 
  {
    if (open_tables(thd, &tables, &counter, 0))
      DBUG_RETURN(-1);
    if (!lock_tables(thd, tables, counter, &need_reopen))
      break;
    if (!need_reopen)
      DBUG_RETURN(-1);
    close_tables_for_reopen(thd, tables);
  }
  if (mysql_handle_derived(thd->lex, &mysql_derived_prepare) ||
2360 2361
      (thd->fill_derived_tables() &&
       mysql_handle_derived(thd->lex, &mysql_derived_filling)))
2362
    DBUG_RETURN(TRUE); /* purecov: inspected */
monty@mysql.com's avatar
monty@mysql.com committed
2363
  DBUG_RETURN(0);
monty@mysql.com's avatar
monty@mysql.com committed
2364 2365 2366
}


2367 2368 2369 2370 2371 2372
/*
  Open all tables in list and process derived tables

  SYNOPSIS
    open_normal_and_derived_tables
    thd		- thread handler
2373
    tables	- list of tables for open
2374 2375 2376
    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.
2377 2378 2379 2380 2381 2382 2383 2384 2385 2386

  RETURN
    FALSE - ok
    TRUE  - error

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

2387
bool open_normal_and_derived_tables(THD *thd, TABLE_LIST *tables, uint flags)
2388 2389 2390
{
  uint counter;
  DBUG_ENTER("open_normal_and_derived_tables");
monty@mysql.com's avatar
monty@mysql.com committed
2391
  DBUG_ASSERT(!thd->fill_derived_tables());
2392
  if (open_tables(thd, &tables, &counter, flags) ||
monty@mysql.com's avatar
monty@mysql.com committed
2393 2394 2395
      mysql_handle_derived(thd->lex, &mysql_derived_prepare))
    DBUG_RETURN(TRUE); /* purecov: inspected */
  DBUG_RETURN(0);
2396 2397 2398
}


2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419
/*
  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;
}


2420 2421 2422 2423 2424 2425 2426
/*
  Lock all tables in list

  SYNOPSIS
    lock_tables()
    thd			Thread handler
    tables		Tables to lock
2427 2428 2429 2430 2431 2432
    count		Number of opened tables
    need_reopen         Out parameter which if TRUE indicates that some
                        tables were dropped or altered during this call
                        and therefore invoker should reopen tables and
                        try to lock them once again (in this case
                        lock_tables() will also return error).
2433

2434 2435 2436 2437 2438
  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.

2439 2440 2441 2442
    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.

2443 2444 2445 2446 2447
  RETURN VALUES
   0	ok
   -1	Error
*/

2448
int lock_tables(THD *thd, TABLE_LIST *tables, uint count, bool *need_reopen)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2449
{
2450
  TABLE_LIST *table;
2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463

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

2464 2465
  *need_reopen= FALSE;

2466
  if (!tables)
2467
    DBUG_RETURN(0);
2468

2469 2470 2471 2472 2473 2474 2475 2476 2477 2478
  /*
    We need this extra check for thd->prelocked_mode because we want to avoid
    attempts to lock tables in substatements. Checking for thd->locked_tables
    is not enough in some situations. For example for SP containing
    "drop table t3; create temporary t3 ..; insert into t3 ...;"
    thd->locked_tables may be 0 after drop tables, and without this extra
    check insert will try to lock temporary table t3, that will lead
    to memory leak...
  */
  if (!thd->locked_tables && !thd->prelocked_mode)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2479
  {
2480
    DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2481
    TABLE **start,**ptr;
2482

2483
    if (!(ptr=start=(TABLE**) thd->alloc(sizeof(TABLE*)*count)))
2484
      DBUG_RETURN(-1);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2485
    for (table= tables; table; table= table->next_global)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2486
    {
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
2487
      if (!table->placeholder() && !table->schema_table)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2488 2489
	*(ptr++)= table->table;
    }
2490 2491 2492 2493 2494 2495 2496 2497

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

2498 2499 2500
    if (! (thd->lock= mysql_lock_tables(thd, start, (uint) (ptr - start),
                                        MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN,
                                        need_reopen)))
2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546
    {
      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);
2547
      DBUG_PRINT("info",("prelocked_mode= PRELOCKED"));
2548 2549
      thd->prelocked_mode= PRELOCKED;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2550
  }
2551 2552
  else
  {
2553 2554
    TABLE_LIST *first_not_own= thd->lex->first_not_own_table();
    for (table= tables; table != first_not_own; table= table->next_global)
2555
    {
2556
      if (!table->placeholder() && !table->schema_table &&
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2557
	  check_lock_and_start_stmt(thd, table->table, table->lock_type))
2558
      {
2559
	ha_rollback_stmt(thd);
2560
	DBUG_RETURN(-1);
2561 2562
      }
    }
2563 2564 2565 2566 2567 2568 2569 2570
    /*
      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);
2571
      DBUG_PRINT("info", ("thd->prelocked_mode= PRELOCKED_UNDER_LOCK_TABLES"));
2572 2573
      thd->prelocked_mode= PRELOCKED_UNDER_LOCK_TABLES;
    }
2574
  }
2575
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2576 2577
}

2578

2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600
/*
  Prepare statement for reopening of tables and recalculation of set of
  prelocked tables.

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

*/

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


bk@work.mysql.com's avatar
bk@work.mysql.com committed
2601
/*
2602 2603 2604
  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 ...
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2605 2606 2607 2608 2609 2610
*/

TABLE *open_temporary_table(THD *thd, const char *path, const char *db,
			    const char *table_name, bool link_in_list)
{
  TABLE *tmp_table;
2611
  TABLE_SHARE *share;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2612
  DBUG_ENTER("open_temporary_table");
2613

2614 2615 2616 2617 2618 2619 2620
  /*
    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
  */
2621
  if (!(tmp_table=(TABLE*) my_malloc(sizeof(*tmp_table)+(uint) strlen(db)+
guilhem@mysql.com's avatar
guilhem@mysql.com committed
2622
				     (uint) strlen(table_name)+6+4,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2623 2624 2625
				     MYF(MY_WME))))
    DBUG_RETURN(0);				/* purecov: inspected */

2626
  if (openfrm(thd, path, table_name,
2627
	      (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE | HA_GET_INDEX),
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2628
	      READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
2629
	      ha_open_options,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2630 2631
	      tmp_table))
  {
2632
    my_free((char*) tmp_table,MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2633 2634 2635
    DBUG_RETURN(0);
  }

2636
  share= tmp_table->s;
2637
  tmp_table->reginfo.lock_type=TL_WRITE;	 // Simulate locked
2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649
  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,
2650
	    thd->variables.pseudo_thread_id);
2651
  share->key_length+= 4;
2652

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2653 2654 2655 2656
  if (link_in_list)
  {
    tmp_table->next=thd->temporary_tables;
    thd->temporary_tables=tmp_table;
2657 2658
    if (thd->slave_thread)
      slave_open_temp_tables++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2659 2660 2661 2662 2663 2664 2665 2666
  }
  DBUG_RETURN(tmp_table);
}


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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2669 2670 2671 2672 2673
  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
2674
  handler *file= get_new_handler((TABLE*) 0, current_thd->mem_root, base);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2675
  if (file && file->delete_table(path))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2676
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2677
    error=1;
serg@serg.mylan's avatar
serg@serg.mylan committed
2678 2679
    sql_print_warning("Could not remove tmp table: '%s', error: %d",
                      path, my_errno);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2680
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2681
  delete file;
2682
  DBUG_RETURN(error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2683 2684 2685 2686
}


/*****************************************************************************
2687 2688 2689 2690 2691 2692
* The following find_field_in_XXX procedures implement the core of the
* name resolution functionality. The entry point to resolve a column name in a
* list of tables is 'find_field_in_tables'. It calls 'find_field_in_table_ref'
* for each table reference. In turn, depending on the type of table reference,
* 'find_field_in_table_ref' calls one of the 'find_field_in_XXX' procedures
* below specific for the type of table reference.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2693 2694
******************************************************************************/

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

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

2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715
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;
  }
}

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2716 2717

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

  SYNOPSIS
2721
    find_field_in_view()
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2722
    thd				thread handler
2723
    table_list			view to search for 'name'
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2724 2725
    name			name of field
    length			length of name
2726
    item_name                   name of item if it will be created (VIEW)
2727 2728
    ref				expression substituted in VIEW should be passed
                                using this reference (return view_ref_found)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2729
    register_tree_change        TRUE if ref is not stack variable and we
2730
                                need register changes in item tree
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2731 2732 2733 2734

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

2738 2739
static Field *
find_field_in_view(THD *thd, TABLE_LIST *table_list,
2740 2741
                   const char *name, uint length,
                   const char *item_name, Item **ref,
2742
                   bool register_tree_change)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2743
{
2744 2745 2746 2747 2748 2749
  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);
2750 2751
  Query_arena *arena, backup;  
  
2752 2753 2754
  DBUG_ASSERT(table_list->schema_table_reformed ||
              (ref != 0 && table_list->view != 0));
  for (; !field_it.end_of_fields(); field_it.next())
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2755
  {
2756
    if (!my_strcasecmp(system_charset_info, field_it.name(), name))
2757
    {
2758 2759 2760
      // in PS use own arena or data will be freed after prepare
      if (register_tree_change)
        arena= thd->activate_stmt_arena_if_needed(&backup);
2761 2762 2763 2764
      /*
        create_item() may, or may not create a new Item, depending on
        the column reference. See create_view_field() for details.
      */
2765
      Item *item= field_it.create_item(thd);
2766 2767 2768
      if (register_tree_change && arena)
        thd->restore_active_arena(arena, &backup);
      
2769 2770 2771 2772 2773 2774
      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.
2775
       We need to set alias on both ref itself and on ref real item.
2776 2777
      */
      if (*ref && !(*ref)->is_autogenerated_name)
2778
      {
2779 2780
        item->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
2781 2782 2783
        item->real_item()->set_name((*ref)->name, (*ref)->name_length,
                       system_charset_info);
      }
2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811
      if (register_tree_change)
        thd->change_item_tree(ref, item);
      else
        *ref= item;
      DBUG_RETURN((Field*) view_ref_found);
    }
  }
  DBUG_RETURN(0);
}


/*
  Find field by name in a NATURAL/USING join table reference.

  SYNOPSIS
    find_field_in_natural_join()
    thd			 [in]  thread handler
    table_ref            [in]  table reference to search
    name		 [in]  name of field
    length		 [in]  length of name
    ref                  [in/out] if 'name' is resolved to a view field, ref is
                               set to point to the found view field
    register_tree_change [in]  TRUE if ref is not stack variable and we
                               need register changes in item tree
    actual_table         [out] the original table reference where the field
                               belongs - differs from 'table_list' only for
                               NATURAL/USING joins

2812 2813 2814 2815 2816 2817
  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.

2818
  RETURN
2819 2820 2821
    NULL        if the field was not found
    WRONG_GRANT if no access rights to the found field
    #           Pointer to the found Field
2822 2823 2824 2825
*/

static Field *
find_field_in_natural_join(THD *thd, TABLE_LIST *table_ref, const char *name,
2826
                           uint length, Item **ref, bool register_tree_change,
2827
                           TABLE_LIST **actual_table)
2828
{
2829 2830 2831 2832
  List_iterator_fast<Natural_join_column>
    field_it(*(table_ref->join_columns));
  Natural_join_column *nj_col;
  Field *found_field;
2833
  Query_arena *arena, backup;
2834
  DBUG_ENTER("find_field_in_natural_join");
2835
  DBUG_PRINT("enter", ("field name: '%s', ref 0x%lx",
2836 2837
		       name, (ulong) ref));
  DBUG_ASSERT(table_ref->is_natural_join && table_ref->join_columns);
2838
  DBUG_ASSERT(*actual_table == NULL);
2839

2840
  LINT_INIT(found_field);
2841

2842
  for (;;)
2843
  {
2844 2845 2846
    if (!(nj_col= field_it++))
      DBUG_RETURN(NULL);

2847 2848
    if (!my_strcasecmp(system_charset_info, nj_col->name(), name))
      break;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2849
  }
2850 2851 2852

  if (nj_col->view_field)
  {
monty@mysql.com's avatar
monty@mysql.com committed
2853
    Item *item;
2854 2855
    if (register_tree_change)
      arena= thd->activate_stmt_arena_if_needed(&backup);
2856 2857 2858 2859
    /*
      create_item() may, or may not create a new Item, depending on the
      column reference. See create_view_field() for details.
    */
monty@mysql.com's avatar
monty@mysql.com committed
2860
    item= nj_col->create_item(thd);
2861 2862 2863
    if (register_tree_change && arena)
      thd->restore_active_arena(arena, &backup);

2864 2865 2866 2867
    if (!item)
      DBUG_RETURN(NULL);
    DBUG_ASSERT(nj_col->table_field == NULL);
    if (nj_col->table_ref->schema_table_reformed)
2868
    {
2869 2870 2871 2872 2873 2874
      /*
        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);
2875
    }
2876 2877 2878 2879 2880 2881 2882 2883 2884 2885
    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);
2886
    DBUG_ASSERT(nj_col->table_ref->table == nj_col->table_field->table);
2887 2888 2889 2890 2891 2892 2893
    found_field= nj_col->table_field;
    update_field_dependencies(thd, found_field, nj_col->table_ref->table);
  }

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

2896

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2897
/*
2898
  Find field by name in a base table or a view with temp table algorithm.
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2899 2900

  SYNOPSIS
2901
    find_field_in_table()
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2902
    thd				thread handler
2903
    table			table where to search for the field
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2904 2905 2906
    name			name of field
    length			length of name
    allow_rowid			do allow finding of "_rowid" field?
2907 2908
    cached_field_index_ptr	cached position in field list (used to speedup
                                lookup for fields in prepared tables)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2909 2910

  RETURN
2911 2912
    0	field is not found
    #	pointer to field
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2913 2914
*/

2915 2916
Field *
find_field_in_table(THD *thd, TABLE *table, const char *name, uint length,
2917
                    bool allow_rowid, uint *cached_field_index_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2918
{
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2919 2920
  Field **field_ptr, *field;
  uint cached_field_index= *cached_field_index_ptr;
2921 2922
  DBUG_ENTER("find_field_in_table");
  DBUG_PRINT("enter", ("table: '%s', field name: '%s'", table->alias, name));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2923 2924

  /* We assume here that table->field < NO_CACHED_FIELD_INDEX = UINT_MAX */
2925
  if (cached_field_index < table->s->fields &&
2926
      !my_strcasecmp(system_charset_info,
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2927 2928
                     table->field[cached_field_index]->field_name, name))
    field_ptr= table->field + cached_field_index;
2929 2930 2931
  else if (table->s->name_hash.records)
    field_ptr= (Field**) hash_search(&table->s->name_hash, (byte*) name,
                                     length);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2932 2933 2934
  else
  {
    if (!(field_ptr= table->field))
2935
      DBUG_RETURN((Field *)0);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2936 2937 2938 2939 2940 2941
    for (; *field_ptr; ++field_ptr)
      if (!my_strcasecmp(system_charset_info, (*field_ptr)->field_name, name))
        break;
  }

  if (field_ptr && *field_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2942
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2943 2944
    *cached_field_index_ptr= field_ptr - table->field;
    field= *field_ptr;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2945 2946 2947
  }
  else
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2948 2949 2950
    if (!allow_rowid ||
        my_strcasecmp(system_charset_info, name, "_rowid") ||
        !(field=table->rowid_field))
2951
      DBUG_RETURN((Field*) 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2952 2953
  }

2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967
  update_field_dependencies(thd, field, table);

  DBUG_RETURN(field);
}


/*
  Find field in a table reference.

  SYNOPSIS
    find_field_in_table_ref()
    thd			   [in]  thread handler
    table_list		   [in]  table reference to search
    name		   [in]  name of field
2968
    length		   [in]  field length of name
2969 2970
    item_name              [in]  name of item if it will be created (VIEW)
    db_name                [in]  optional database name that qualifies the
2971
    table_name             [in]  optional table name that qualifies the field
2972 2973
    ref		       [in/out] if 'name' is resolved to a view field, ref
                                 is set to point to the found view field
2974
    check_privileges       [in]  check privileges
2975 2976 2977 2978 2979 2980 2981 2982 2983
    allow_rowid		   [in]  do allow finding of "_rowid" field?
    cached_field_index_ptr [in]  cached position in field list (used to
                                 speedup lookup for fields in prepared tables)
    register_tree_change   [in]  TRUE if ref is not stack variable and we
                                 need register changes in item tree
    actual_table           [out] the original table reference where the field
                                 belongs - differs from 'table_list' only for
                                 NATURAL_USING joins.

timour@mysql.com's avatar
timour@mysql.com committed
2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995
  DESCRIPTION
    Find a field in a table reference depending on the type of table
    reference. There are three types of table references with respect
    to the representation of their result columns:
    - an array of Field_translator objects for MERGE views and some
      information_schema tables,
    - an array of Field objects (and possibly a name hash) for stored
      tables,
    - a list of Natural_join_column objects for NATURAL/USING joins.
    This procedure detects the type of the table reference 'table_list'
    and calls the corresponding search routine.

2996 2997 2998 2999 3000 3001 3002 3003
  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,
3004 3005 3006
                        const char *name, uint length,
                        const char *item_name, const char *db_name,
                        const char *table_name, Item **ref,
3007 3008
                        bool check_privileges, bool allow_rowid,
                        uint *cached_field_index_ptr,
3009 3010 3011 3012 3013 3014 3015 3016 3017 3018
                        bool register_tree_change, TABLE_LIST **actual_table)
{
  Field *fld;
  DBUG_ENTER("find_field_in_table_ref");
  DBUG_PRINT("enter",
             ("table: '%s'  field name: '%s'  item name: '%s'  ref 0x%lx",
              table_list->alias, name, item_name, (ulong) ref));

  /*
    Check that the table and database that qualify the current field name
timour@mysql.com's avatar
timour@mysql.com committed
3019 3020
    are the same as the table reference we are going to search for the field.

3021 3022 3023 3024
    Exclude from the test below nested joins because the columns in a
    nested join generally originate from different tables. Nested joins
    also have no table name, except when a nested join is a merge view
    or an information schema table.
timour@mysql.com's avatar
timour@mysql.com committed
3025 3026 3027 3028 3029 3030

    We include explicitly table references with a 'field_translation' table,
    because if there are views over natural joins we don't want to search
    inside the view, but we want to search directly in the view columns
    which are represented as a 'field_translation'.

3031 3032
    TODO: Ensure that table_name, db_name and tables->db always points to
          something !
3033
  */
3034 3035
  if (/* Exclude nested joins. */
      (!table_list->nested_join ||
timour@mysql.com's avatar
timour@mysql.com committed
3036 3037 3038 3039 3040 3041
       /* Include merge views and information schema tables. */
       table_list->field_translation) &&
      /*
        Test if the field qualifiers match the table reference we plan
        to search.
      */
3042 3043
      table_name && table_name[0] &&
      (my_strcasecmp(table_alias_charset, table_list->alias, table_name) ||
3044 3045 3046 3047
       (db_name && db_name[0] && table_list->db && table_list->db[0] &&
        strcmp(db_name, table_list->db))))
    DBUG_RETURN(0);

3048
  *actual_table= NULL;
timour@mysql.com's avatar
timour@mysql.com committed
3049

3050 3051
  if (table_list->field_translation)
  {
timour@mysql.com's avatar
timour@mysql.com committed
3052
    /* 'table_list' is a view or an information schema table. */
3053
    if ((fld= find_field_in_view(thd, table_list, name, length, item_name, ref,
3054
                                 register_tree_change)))
3055 3056
      *actual_table= table_list;
  }
3057
  else if (!table_list->nested_join)
3058
  {
3059 3060
    /* 'table_list' is a stored table. */
    DBUG_ASSERT(table_list->table);
timour@mysql.com's avatar
timour@mysql.com committed
3061
    if ((fld= find_field_in_table(thd, table_list->table, name, length,
3062 3063
                                  allow_rowid,
                                  cached_field_index_ptr)))
timour@mysql.com's avatar
timour@mysql.com committed
3064 3065 3066 3067 3068 3069 3070 3071 3072 3073
      *actual_table= table_list;
  }
  else
  {
    /*
      'table_list' is a NATURAL/USING join, or an operand of such join that
      is a nested join itself.

      If the field name we search for is qualified, then search for the field
      in the table references used by NATURAL/USING the join.
timour@mysql.com's avatar
timour@mysql.com committed
3074
    */
3075 3076 3077 3078 3079 3080
    if (table_name && table_name[0])
    {
      List_iterator<TABLE_LIST> it(table_list->nested_join->join_list);
      TABLE_LIST *table;
      while ((table= it++))
      {
3081 3082
        if ((fld= find_field_in_table_ref(thd, table, name, length, item_name,
                                          db_name, table_name, ref,
3083 3084
                                          check_privileges, allow_rowid,
                                          cached_field_index_ptr,
3085 3086 3087 3088 3089 3090 3091
                                          register_tree_change, actual_table)))
          DBUG_RETURN(fld);
      }
      DBUG_RETURN(0);
    }
    /*
      Non-qualified field, search directly in the result columns of the
timour@mysql.com's avatar
timour@mysql.com committed
3092 3093 3094
      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.
3095 3096
    */
    fld= find_field_in_natural_join(thd, table_list, name, length, ref,
3097
                                    register_tree_change, actual_table);
3098
  }
3099

3100 3101 3102 3103 3104 3105 3106
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  /* Check if there are sufficient access rights to the found field. */
  if (fld && check_privileges &&
      check_column_grant_in_table_ref(thd, *actual_table, name, length))
    fld= WRONG_GRANT;
#endif

3107
  DBUG_RETURN(fld);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3108 3109
}

3110

3111 3112 3113 3114 3115
/*
  Find field in table list.

  SYNOPSIS
    find_field_in_tables()
3116 3117 3118 3119 3120 3121
    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
3122
                          point to the found view field
3123
    report_error	  Degree of error reporting:
3124 3125
                          - IGNORE_ERRORS then do not report any error
                          - IGNORE_EXCEPT_NON_UNIQUE report only non-unique
3126
                            fields, suppress all other errors
3127 3128 3129 3130
                          - REPORT_EXCEPT_NON_UNIQUE report all other errors
                            except when non-unique fields were found
                          - REPORT_ALL_ERRORS
    check_privileges      need to check privileges
3131 3132
    register_tree_change  TRUE if ref is not a stack variable and we
                          to need register changes in item tree
3133 3134

  RETURN VALUES
3135 3136 3137
    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.
3138 3139 3140 3141 3142
    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
3143
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3144 3145

Field *
3146 3147
find_field_in_tables(THD *thd, Item_ident *item,
                     TABLE_LIST *first_table, TABLE_LIST *last_table,
3148
		     Item **ref, find_item_error_report_type report_error,
3149
                     bool check_privileges, bool register_tree_change)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3150 3151
{
  Field *found=0;
3152 3153 3154
  const char *db= item->db_name;
  const char *table_name= item->table_name;
  const char *name= item->field_name;
3155
  uint length=(uint) strlen(name);
3156
  char name_buff[NAME_LEN+1];
3157 3158
  TABLE_LIST *cur_table= first_table;
  TABLE_LIST *actual_table;
3159 3160 3161 3162 3163 3164 3165 3166 3167
  bool allow_rowid;

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

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

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3169 3170 3171
  if (item->cached_table)
  {
    /*
3172 3173
      This shortcut is used by prepared statements. We assume that
      TABLE_LIST *first_table is not changed during query execution (which
3174
      is true for all queries except RENAME but luckily RENAME doesn't
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3175
      use fields...) so we can rely on reusing pointer to its member.
timour@mysql.com's avatar
timour@mysql.com committed
3176
      With this optimization we also miss case when addition of one more
3177
      field makes some prepared query ambiguous and so erroneous, but we
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3178 3179
      accept this trade off.
    */
3180 3181 3182 3183 3184 3185 3186 3187
    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,
3188
                                 TRUE, &(item->cached_field_index));
3189
    else
3190
      found= find_field_in_table_ref(thd, table_ref, name, length, item->name,
3191 3192
                                     NULL, NULL, ref, check_privileges,
                                     TRUE, &(item->cached_field_index),
3193 3194
                                     register_tree_change,
                                     &actual_table);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3195 3196 3197
    if (found)
    {
      if (found == WRONG_GRANT)
3198
	return (Field*) 0;
3199 3200
      {
        SELECT_LEX *current_sel= thd->lex->current_select;
3201
        SELECT_LEX *last_select= table_ref->select_lex;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3202 3203
        /*
          If the field was an outer referencee, mark all selects using this
3204
          sub query as dependent on the outer query
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3205
        */
3206
        if (current_sel != last_select)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3207
          mark_select_range_as_dependent(thd, last_select, current_sel,
3208 3209
                                         found, *ref, item);
      }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3210 3211 3212 3213
      return found;
    }
  }

3214 3215 3216
  if (db && lower_case_table_names)
  {
    /*
timour@mysql.com's avatar
timour@mysql.com committed
3217
      convert database to lower case for comparison.
3218 3219 3220 3221
      We can't do this in Item_field as this would change the
      'name' of the item which may be used in the select list
    */
    strmake(name_buff, db, sizeof(name_buff)-1);
monty@mysql.com's avatar
monty@mysql.com committed
3222
    my_casedn_str(files_charset_info, name_buff);
3223 3224
    db= name_buff;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3225

3226 3227 3228 3229 3230
  if (last_table)
    last_table= last_table->next_name_resolution_table;

  for (; cur_table != last_table ;
       cur_table= cur_table->next_name_resolution_table)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3231
  {
3232 3233
    Field *cur_field= find_field_in_table_ref(thd, cur_table, name, length,
                                              item->name, db, table_name, ref,
3234
                                              check_privileges, allow_rowid,
3235 3236 3237 3238
                                              &(item->cached_field_index),
                                              register_tree_change,
                                              &actual_table);
    if (cur_field)
3239
    {
3240
      if (cur_field == WRONG_GRANT)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3241
	return (Field*) 0;
3242 3243 3244 3245 3246 3247 3248 3249

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

3250 3251 3252 3253 3254
      DBUG_ASSERT(thd->where);
      /*
        If we found a fully qualified field we return it directly as it can't
        have duplicates.
       */
3255
      if (db)
3256 3257
        return cur_field;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3258 3259
      if (found)
      {
3260 3261
        if (report_error == REPORT_ALL_ERRORS ||
            report_error == IGNORE_EXCEPT_NON_UNIQUE)
3262
          my_error(ER_NON_UNIQ_ERROR, MYF(0),
3263
                   table_name ? item->full_name() : name, thd->where);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3264 3265
	return (Field*) 0;
      }
3266
      found= cur_field;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3267 3268
    }
  }
3269

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3270 3271
  if (found)
    return found;
3272 3273 3274 3275 3276 3277 3278 3279

  /*
    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.
  */
3280
  if (table_name && (cur_table == first_table) &&
3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291
      (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);
  }
3292
  else
3293
  {
3294 3295 3296 3297 3298
    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;
3299
  }
3300
  return found;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3301 3302
}

3303 3304 3305

/*
  Find Item in list of items (find_field_in_tables analog)
3306 3307 3308 3309

  TODO
    is it better return only counter?

3310 3311
  SYNOPSIS
    find_item_in_list()
3312 3313 3314
    find			Item to find
    items			List of items
    counter			To return number of found item
3315
    report_error
3316 3317 3318 3319 3320
      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
3321 3322 3323 3324
    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.

3325
  RETURN VALUES
3326 3327 3328 3329 3330
    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
3331
                        found field
3332 3333
*/

3334
/* Special Item pointer to serve as a return value from find_item_in_list(). */
3335
Item **not_found_item= (Item**) 0x1;
3336 3337


bk@work.mysql.com's avatar
bk@work.mysql.com committed
3338
Item **
3339
find_item_in_list(Item *find, List<Item> &items, uint *counter,
3340
                  find_item_error_report_type report_error, bool *unaliased)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3341 3342
{
  List_iterator<Item> li(items);
3343
  Item **found=0, **found_unaliased= 0, *item;
3344
  const char *db_name=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3345 3346
  const char *field_name=0;
  const char *table_name=0;
3347 3348
  bool found_unaliased_non_uniq= 0;
  uint unaliased_counter;
3349

3350 3351
  LINT_INIT(unaliased_counter);                 // Dependent on found_unaliased

3352 3353
  *unaliased= FALSE;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3354 3355 3356 3357
  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;
3358
    db_name=    ((Item_ident*) find)->db_name;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3359 3360
  }

3361
  for (uint i= 0; (item=li++); i++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3362
  {
3363
    if (field_name && item->real_item()->type() == Item::FIELD_ITEM)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3364
    {
3365
      Item_ident *item_field= (Item_ident*) item;
3366

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3367 3368 3369 3370 3371 3372
      /*
	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
      */ 
3373 3374 3375 3376
      if (!item_field->name)
        continue;

      if (table_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3377
      {
3378 3379 3380
        /*
          If table name is specified we should find field 'field_name' in
          table 'table_name'. According to SQL-standard we should ignore
3381 3382 3383 3384 3385
          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.
3386

3387
          We use strcmp for table names and database names as these may be
3388 3389
          case sensitive. In cases where they are not case sensitive, they
          are always in lower case.
3390 3391

	  item_field->field_name and item_field->table_name can be 0x0 if
3392
	  item is not fix_field()'ed yet.
3393
        */
3394 3395
        if (item_field->field_name && item_field->table_name &&
	    !my_strcasecmp(system_charset_info, item_field->field_name,
3396 3397 3398 3399 3400
                           field_name) &&
            !strcmp(item_field->table_name, table_name) &&
            (!db_name || (item_field->db_name &&
                          !strcmp(item_field->db_name, db_name))))
        {
3401
          if (found_unaliased)
3402
          {
3403 3404 3405 3406 3407 3408 3409
            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.
            */
3410
            if (report_error != IGNORE_ERRORS)
3411 3412
              my_error(ER_NON_UNIQ_ERROR, MYF(0),
                       find->full_name(), current_thd->where);
3413 3414
            return (Item**) 0;
          }
3415 3416
          found_unaliased= li.ref();
          unaliased_counter= i;
3417 3418
          if (db_name)
            break;                              // Perfect match
3419 3420 3421
        }
      }
      else if (!my_strcasecmp(system_charset_info, item_field->name,
3422
                              field_name))
3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435
      {
        /*
          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)
3436 3437
            my_error(ER_NON_UNIQ_ERROR, MYF(0),
                     find->full_name(), current_thd->where);
3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462
          return (Item**) 0;
        }
        found= li.ref();
        *counter= i;
      }
      else if (!my_strcasecmp(system_charset_info, item_field->field_name,
                              field_name))
      {
        /*
          We will use un-aliased field or react on such ambiguities only if
          we won't be able to find aliased field.
          Again if we have ambiguity with field outside of select list
          we should prefer fields from select list.
        */
        if (found_unaliased)
        {
          if ((*found_unaliased)->eq(item, 0))
            continue;                           // Same field twice
          found_unaliased_non_uniq= 1;
        }
        else
        {
          found_unaliased= li.ref();
          unaliased_counter= i;
        }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3463 3464
      }
    }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3465
    else if (!table_name && (find->eq(item,0) ||
3466
			     find->name && item->name &&
3467 3468
			     !my_strcasecmp(system_charset_info, 
					    item->name,find->name)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3469
    {
3470 3471
      found= li.ref();
      *counter= i;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3472 3473 3474
      break;
    }
  }
3475 3476 3477 3478 3479
  if (!found)
  {
    if (found_unaliased_non_uniq)
    {
      if (report_error != IGNORE_ERRORS)
3480 3481
        my_error(ER_NON_UNIQ_ERROR, MYF(0),
                 find->full_name(), current_thd->where);
3482 3483 3484 3485 3486 3487
      return (Item **) 0;
    }
    if (found_unaliased)
    {
      found= found_unaliased;
      *counter= unaliased_counter;
3488
      *unaliased= TRUE;
3489 3490
    }
  }
3491 3492
  if (found)
    return found;
3493
  if (report_error != REPORT_EXCEPT_NOT_FOUND)
3494 3495
  {
    if (report_error == REPORT_ALL_ERRORS)
3496 3497
      my_error(ER_BAD_FIELD_ERROR, MYF(0),
               find->full_name(), current_thd->where);
3498 3499 3500 3501
    return (Item **) 0;
  }
  else
    return (Item **) not_found_item;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3502 3503
}

3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531

/*
  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;
3532
    if (!my_strcasecmp(system_charset_info, find, curr_str->ptr()))
3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553
      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
3554 3555
    FALSE  if all OK
    TRUE   otherwise
3556 3557 3558 3559 3560 3561
*/

static bool
set_new_item_local_context(THD *thd, Item_ident *item, TABLE_LIST *table_ref)
{
  Name_resolution_context *context;
3562
  if (!(context= new (thd->mem_root) Name_resolution_context))
3563 3564
    return TRUE;
  context->init();
3565 3566
  context->first_name_resolution_table=
    context->last_name_resolution_table= table_ref;
3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598
  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
3599 3600
    TRUE   error when some common column is non-unique, or out of memory
    FALSE  OK
3601 3602 3603 3604 3605 3606 3607 3608
*/

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;
3609
  const char *field_name_1;
3610
  Query_arena *arena, backup;
3611
  bool add_columns= TRUE;
3612 3613 3614
  bool result= TRUE;

  DBUG_ENTER("mark_common_columns");
3615
  DBUG_PRINT("info", ("operand_1: %s  operand_2: %s",
3616 3617
                      table_ref_1->alias, table_ref_2->alias));

3618
  *found_using_fields= 0;
konstantin@mysql.com's avatar
konstantin@mysql.com committed
3619
  arena= thd->activate_stmt_arena_if_needed(&backup);
3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640

  /*
    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;
3641
    bool found= FALSE;
3642
    if (!(nj_col_1= it_1.get_or_create_column_ref(&is_created_1)))
3643 3644 3645 3646 3647 3648 3649
      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);

3650 3651 3652 3653 3654 3655 3656
    /*
      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.
    */
3657 3658 3659 3660 3661
    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;
3662
      const char *cur_field_name_2;
3663
      if (!(cur_nj_col_2= it_2.get_or_create_column_ref(&is_created_2)))
3664
        goto err;
3665
      cur_field_name_2= cur_nj_col_2->name();
3666 3667 3668 3669 3670

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

timour@mysql.com's avatar
timour@mysql.com committed
3671 3672 3673 3674 3675 3676 3677
      /*
        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).
      */
3678 3679
      if (!my_strcasecmp(system_charset_info, field_name_1, cur_field_name_2))
      {
timour@mysql.com's avatar
timour@mysql.com committed
3680
        if (found || cur_nj_col_2->is_common)
3681 3682 3683 3684 3685 3686 3687 3688
        {
          my_error(ER_NON_UNIQ_ERROR, MYF(0), field_name_1, thd->where);
          goto err;
        }
        nj_col_2= cur_nj_col_2;
        found= TRUE;
      }
    }
3689
    /* Force it_2.set() to use table_ref_2->join_columns. */
3690 3691 3692
    table_ref_2->is_join_columns_complete= TRUE;
    add_columns= FALSE;
    if (!found)
3693
      continue;                                 // No matching field
3694 3695 3696 3697 3698 3699 3700 3701

    /*
      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 ||
3702
          test_if_string_in_list(field_name_1, using_fields)))
3703 3704 3705 3706 3707 3708
    {
      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;
3709 3710 3711 3712 3713
      Item_func_eq *eq_cond;

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

3714
      /*
3715
        The following assert checks that the two created items are of
3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739
        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.
      */
3740 3741
      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))
3742 3743
        goto err;

3744 3745
      if (!(eq_cond= new Item_func_eq(item_ident_1, item_ident_2)))
        goto err;                               /* Out of memory. */
3746 3747 3748 3749 3750 3751

      /*
        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.
       */
3752 3753 3754
      add_join_on((table_ref_1->outer_join & JOIN_TYPE_RIGHT ?
                   table_ref_1 : table_ref_2),
                  eq_cond);
3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787

      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)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
3788
    thd->restore_active_arena(arena, &backup);
3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824
  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
3825 3826
    TRUE    error: Some common column is ambiguous
    FALSE   OK
3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840
*/

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;
3841
  List<Natural_join_column> *non_join_columns;
3842 3843
  DBUG_ENTER("store_natural_using_join_columns");

3844 3845
  DBUG_ASSERT(!natural_using_join->join_columns);

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

3848 3849
  if (!(non_join_columns= new List<Natural_join_column>) ||
      !(natural_using_join->join_columns= new List<Natural_join_column>))
3850 3851 3852 3853 3854
    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())
  {
3855
    nj_col_1= it_1.get_natural_column_ref();
3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876
    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++))
    {
3877
      const char *using_field_name_ptr= using_field_name->c_ptr();
3878 3879 3880
      List_iterator_fast<Natural_join_column>
        it(*(natural_using_join->join_columns));
      Natural_join_column *common_field;
3881 3882

      for (;;)
3883
      {
3884 3885 3886 3887 3888 3889 3890
        /* 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;
        }
3891 3892
        if (!my_strcasecmp(system_charset_info,
                           common_field->name(), using_field_name_ptr))
3893
          break;                                // Found match
3894 3895 3896 3897 3898 3899 3900
      }
    }
  }

  /* 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())
  {
3901
    nj_col_2= it_2.get_natural_column_ref();
3902 3903 3904
    if (!nj_col_2->is_common)
      non_join_columns->push_back(nj_col_2);
    else
3905
    {
3906 3907
      /* Reset the common columns for the next call to mark_common_columns. */
      nj_col_2->is_common= FALSE;
3908
    }
3909 3910 3911 3912 3913 3914 3915 3916 3917 3918
  }

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

  result= FALSE;

err:
  if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
3919
    thd->restore_active_arena(arena, &backup);
3920 3921 3922
  DBUG_RETURN(result);
}

3923

3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949
/*
  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
3950 3951
    TRUE   Error
    FALSE  OK
3952 3953 3954 3955 3956 3957 3958
*/

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

3962
  DBUG_ENTER("store_top_level_join_columns");
3963

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

3966 3967 3968 3969 3970 3971
  /* 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;
3972

3973 3974
    while (cur_left_neighbor)
    {
3975
      TABLE_LIST *cur_table_ref= cur_left_neighbor;
3976
      cur_left_neighbor= nested_it++;
3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997
      /*
        The order of RIGHT JOIN operands is reversed in 'join list' to
        transform it into a LEFT JOIN. However, in this procedure we need
        the join operands in their lexical order, so below we reverse the
        join operands. Notice that this happens only in the first loop, and
        not in the second one, as in the second loop cur_left_neighbor == NULL.
        This is the correct behavior, because the second loop
        sets cur_table_ref reference correctly after the join operands are
        swapped in the first loop.
      */
      if (cur_left_neighbor &&
          cur_table_ref->outer_join & JOIN_TYPE_RIGHT)
      {
        /* This can happen only for JOIN ... ON. */
        DBUG_ASSERT(table_ref->nested_join->join_list.elements == 2);
        swap_variables(TABLE_LIST*, cur_left_neighbor, cur_table_ref);
      }

      if (cur_table_ref->nested_join &&
          store_top_level_join_columns(thd, cur_table_ref,
                                       cur_left_neighbor, cur_right_neighbor))
timour@mysql.com's avatar
timour@mysql.com committed
3998
        goto err;
3999
      cur_right_neighbor= cur_table_ref;
4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029
    }
  }

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

    /*
      The two join operands were interchanged in the parser, change the order
      back for 'mark_common_columns'.
    */
    if (table_ref_2->outer_join & JOIN_TYPE_RIGHT)
      swap_variables(TABLE_LIST*, table_ref_1, table_ref_2);
    if (mark_common_columns(thd, table_ref_1, table_ref_2,
                            using_fields, &found_using_fields))
timour@mysql.com's avatar
timour@mysql.com committed
4030
      goto err;
4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041

    /*
      Swap the join operands back, so that we pick the columns of the second
      one as the coalesced columns. In this way the coalesced columns are the
      same as of an equivalent LEFT JOIN.
    */
    if (table_ref_1->outer_join & JOIN_TYPE_RIGHT)
      swap_variables(TABLE_LIST*, table_ref_1, table_ref_2);
    if (store_natural_using_join_columns(thd, table_ref, table_ref_1,
                                         table_ref_2, using_fields,
                                         found_using_fields))
timour@mysql.com's avatar
timour@mysql.com committed
4042
      goto err;
4043 4044 4045 4046 4047 4048 4049 4050 4051

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

timour@mysql.com's avatar
timour@mysql.com committed
4052 4053 4054 4055 4056
    /* 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. */

4057 4058 4059
    /* Change this table reference to become a leaf for name resolution. */
    if (left_neighbor)
    {
4060
      TABLE_LIST *last_leaf_on_the_left;
4061 4062 4063 4064 4065
      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)
    {
4066
      TABLE_LIST *first_leaf_on_the_right;
4067 4068 4069 4070 4071 4072
      first_leaf_on_the_right= right_neighbor->first_leaf_for_name_resolution();
      table_ref->next_name_resolution_table= first_leaf_on_the_right;
    }
    else
      table_ref->next_name_resolution_table= NULL;
  }
timour@mysql.com's avatar
timour@mysql.com committed
4073 4074 4075 4076
  result= FALSE; /* All is OK. */

err:
  if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
4077
    thd->restore_active_arena(arena, &backup);
timour@mysql.com's avatar
timour@mysql.com committed
4078
  DBUG_RETURN(result);
4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102
}


/*
  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
4103 4104
    TRUE   Error
    FALSE  OK
4105
*/
4106 4107
static bool setup_natural_join_row_types(THD *thd,
                                         List<TABLE_LIST> *from_clause,
4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120
                                         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. */
4121
  TABLE_LIST *left_neighbor;
4122 4123 4124
  /* Table reference to the right of the current. */
  TABLE_LIST *right_neighbor= NULL;

4125 4126
  /* Note that tables in the list are in reversed order */
  for (left_neighbor= table_ref_it++; left_neighbor ; )
4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144
  {
    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
4145
    right_neighbor points to the left-most top-level table reference in the
4146 4147 4148 4149 4150 4151 4152 4153 4154 4155
    FROM clause.
  */
  DBUG_ASSERT(right_neighbor);
  context->first_name_resolution_table=
    right_neighbor->first_leaf_for_name_resolution();

  return FALSE;
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
4156
/****************************************************************************
4157
** Expand all '*' in given fields
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4158 4159
****************************************************************************/

4160 4161 4162
int setup_wild(THD *thd, TABLE_LIST *tables, List<Item> &fields,
	       List<Item> *sum_func_list,
	       uint wild_num)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4163
{
4164
  if (!wild_num)
4165
    return(0);
4166

4167
  Item *item;
4168
  List_iterator<Item> it(fields);
serg@serg.mylan's avatar
serg@serg.mylan committed
4169
  Query_arena *arena, backup;
4170
  DBUG_ENTER("setup_wild");
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4171 4172

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

monty@mysql.com's avatar
monty@mysql.com committed
4178
  while (wild_num && (item= it++))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4179
  {
4180 4181
    if (item->type() == Item::FIELD_ITEM &&
        ((Item_field*) item)->field_name &&
4182 4183
	((Item_field*) item)->field_name[0] == '*' &&
	!((Item_field*) item)->field)
4184
    {
4185
      uint elem= fields.elements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4186
      bool any_privileges= ((Item_field *) item)->any_privileges;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197
      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));
      }
4198 4199
      else if (insert_fields(thd, ((Item_field*) item)->context,
                             ((Item_field*) item)->db_name,
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4200
                             ((Item_field*) item)->table_name, &it,
4201
                             any_privileges))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4202 4203
      {
	if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
4204
	  thd->restore_active_arena(arena, &backup);
4205
	DBUG_RETURN(-1);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4206
      }
4207
      if (sum_func_list)
4208 4209 4210 4211 4212 4213 4214 4215
      {
	/*
	  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;
      }
4216
      wild_num--;
4217 4218
    }
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4219 4220 4221 4222 4223 4224 4225
  if (arena)
  {
    /* make * substituting permanent */
    SELECT_LEX *select_lex= thd->lex->current_select;
    select_lex->with_wild= 0;
    select_lex->item_list= fields;

konstantin@mysql.com's avatar
konstantin@mysql.com committed
4226
    thd->restore_active_arena(arena, &backup);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4227
  }
4228
  DBUG_RETURN(0);
4229 4230
}

4231 4232 4233 4234
/****************************************************************************
** Check that all given fields exists and fill struct with current data
****************************************************************************/

4235
bool setup_fields(THD *thd, Item **ref_pointer_array,
4236 4237
                  List<Item> &fields, bool set_query_id,
                  List<Item> *sum_func_list, bool allow_sum_func)
4238 4239
{
  reg2 Item *item;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4240
  bool save_set_query_id= thd->set_query_id;
4241 4242 4243 4244 4245
  List_iterator<Item> it(fields);
  DBUG_ENTER("setup_fields");

  thd->set_query_id=set_query_id;
  thd->allow_sum_func= allow_sum_func;
4246
  thd->where= THD::DEFAULT_WHERE;
4247

4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261
  /*
    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);

4262 4263
  Item **ref= ref_pointer_array;
  while ((item= it++))
4264
  {
4265
    if (!item->fixed && item->fix_fields(thd, it.ref()) ||
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4266
	(item= *(it.ref()))->check_cols(1))
4267
    {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4268
      thd->set_query_id= save_set_query_id;
4269
      DBUG_RETURN(TRUE); /* purecov: inspected */
4270
    }
4271 4272
    if (ref)
      *(ref++)= item;
4273 4274
    if (item->with_sum_func && item->type() != Item::SUM_FUNC_ITEM &&
	sum_func_list)
4275
      item->split_sum_func(thd, ref_pointer_array, *sum_func_list);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4276
    thd->used_tables|= item->used_tables();
4277
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4278
  thd->set_query_id= save_set_query_id;
4279
  DBUG_RETURN(test(thd->net.report_error));
4280
}
4281

4282

4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297
/*
  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)
  {
4298 4299 4300 4301 4302 4303
    if (table->merge_underlying_list)
    {
      DBUG_ASSERT(table->view &&
                  table->effective_algorithm == VIEW_ALGORITHM_MERGE);
      list= make_leaves_list(list, table->merge_underlying_list);
    }
4304 4305 4306 4307 4308 4309 4310 4311 4312
    else
    {
      *list= table;
      list= &table->next_leaf;
    }
  }
  return list;
}

4313
/*
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4314 4315 4316 4317
  prepare tables

  SYNOPSIS
    setup_tables()
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4318
    thd		  Thread handler
4319
    context       name resolution contest to setup table list there
4320 4321
    from_clause   Top-level list of table references in the FROM clause
    tables	  Table list (select_lex->table_list)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4322
    conds	  Condition of current SELECT (can be changed by VIEW)
4323
    leaves        List of join table leaves list (select_lex->leaf_tables)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4324 4325
    refresh       It is onle refresh for subquery
    select_insert It is SELECT ... INSERT command
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4326

monty@mysql.com's avatar
monty@mysql.com committed
4327 4328
  NOTE
    Check also that the 'used keys' and 'ignored keys' exists and set up the
4329 4330 4331 4332
    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.
4333

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

monty@mysql.com's avatar
monty@mysql.com committed
4337
  RETURN
4338
    FALSE ok;  In this case *map will includes the chosen index
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4339
    TRUE  error
4340 4341
*/

4342
bool setup_tables(THD *thd, Name_resolution_context *context,
4343 4344
                  List<TABLE_LIST> *from_clause, TABLE_LIST *tables,
                  Item **conds, TABLE_LIST **leaves, bool select_insert)
4345
{
monty@mysql.com's avatar
monty@mysql.com committed
4346
  uint tablenr= 0;
4347
  DBUG_ENTER("setup_tables");
4348

4349
  context->table_list= context->first_name_resolution_table= tables;
4350

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4351 4352
  /*
    this is used for INSERT ... SELECT.
4353
    For select we setup tables except first (and its underlying tables)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4354 4355 4356 4357
  */
  TABLE_LIST *first_select_table= (select_insert ?
                                   tables->next_local:
                                   0);
4358 4359 4360
  if (!(*leaves))
    make_leaves_list(leaves, tables);

4361 4362
  TABLE_LIST *table_list;
  for (table_list= *leaves;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4363
       table_list;
4364
       table_list= table_list->next_leaf, tablenr++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4365
  {
4366
    TABLE *table= table_list->table;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4367
    if (first_select_table &&
4368
        table_list->top_table() == first_select_table)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4369 4370 4371 4372 4373
    {
      /* new counting for SELECT of INSERT ... SELECT command */
      first_select_table= 0;
      tablenr= 0;
    }
4374
    setup_table_map(table, table_list, tablenr);
4375
    table->used_keys= table->s->keys_for_keyread;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4376
    if (table_list->use_index)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4377
    {
4378 4379 4380
      key_map map;
      get_key_map_from_key_list(&map, table, table_list->use_index);
      if (map.is_set_all())
4381
	DBUG_RETURN(1);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4382
      table->keys_in_use_for_query=map;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4383
    }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4384
    if (table_list->ignore_index)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4385
    {
4386 4387 4388
      key_map map;
      get_key_map_from_key_list(&map, table, table_list->ignore_index);
      if (map.is_set_all())
4389
	DBUG_RETURN(1);
4390
      table->keys_in_use_for_query.subtract(map);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4391
    }
4392
    table->used_keys.intersect(table->keys_in_use_for_query);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4393 4394 4395 4396
  }
  if (tablenr > MAX_TABLES)
  {
    my_error(ER_TOO_MANY_TABLES,MYF(0),MAX_TABLES);
4397
    DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4398
  }
4399
  for (table_list= tables;
4400 4401
       table_list;
       table_list= table_list->next_local)
4402
  {
4403
    if (table_list->merge_underlying_list)
4404
    {
4405 4406
      DBUG_ASSERT(table_list->view &&
                  table_list->effective_algorithm == VIEW_ALGORITHM_MERGE);
konstantin@mysql.com's avatar
konstantin@mysql.com committed
4407
      Query_arena *arena= thd->stmt_arena, backup;
4408 4409 4410 4411
      bool res;
      if (arena->is_conventional())
        arena= 0;                                   // For easier test
      else
konstantin@mysql.com's avatar
konstantin@mysql.com committed
4412
        thd->set_n_backup_active_arena(arena, &backup);
4413
      res= table_list->setup_underlying(thd);
4414
      if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
4415
        thd->restore_active_arena(arena, &backup);
4416 4417 4418
      if (res)
        DBUG_RETURN(1);
    }
4419
  }
4420 4421 4422 4423 4424

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

4425
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4426
}
4427

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

4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443
/*
   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,
4444
                               List<String> *index_list)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4445
{
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
4446
  List_iterator_fast<String> it(*index_list);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4447 4448
  String *name;
  uint pos;
4449 4450

  map->clear_all();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4451 4452
  while ((name=it++))
  {
4453 4454 4455
    if (table->s->keynames.type_names == 0 ||
        (pos= find_type(&table->s->keynames, name->ptr(),
                        name->length(), 1)) <=
4456
        0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4457
    {
monty@mysql.com's avatar
monty@mysql.com committed
4458
      my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), name->c_ptr(),
serg@serg.mylan's avatar
serg@serg.mylan committed
4459
	       table->s->table_name);
4460
      map->set_all();
4461
      return 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4462
    }
4463
    map->set_bit(pos-1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4464
  }
4465
  return 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4466 4467
}

4468

4469 4470 4471 4472 4473 4474
/*
  Drops in all fields instead of current '*' field

  SYNOPSIS
    insert_fields()
    thd			Thread handler
4475
    context             Context for name resolution
4476 4477 4478 4479 4480 4481 4482
    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
4483
    0	ok     'it' is updated to point at last inserted
monty@mysql.com's avatar
monty@mysql.com committed
4484
    1	error.  Error message is generated but not sent to client
4485
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4486

sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
4487
bool
4488
insert_fields(THD *thd, Name_resolution_context *context, const char *db_name,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4489
	      const char *table_name, List_iterator<Item> *it,
4490
              bool any_privileges)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4491
{
4492 4493
  Field_iterator_table_ref field_iterator;
  bool found;
monty@mysql.com's avatar
monty@mysql.com committed
4494
  char name_buff[NAME_LEN+1];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4495
  DBUG_ENTER("insert_fields");
konstantin@mysql.com's avatar
konstantin@mysql.com committed
4496
  DBUG_PRINT("arena", ("stmt arena: 0x%lx", (ulong)thd->stmt_arena));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4497

4498 4499
  if (db_name && lower_case_table_names)
  {
monty@mysql.com's avatar
monty@mysql.com committed
4500 4501 4502 4503 4504
    /*
      convert database to lower case for comparison
      We can't do this in Item_field as this would change the
      'name' of the item which may be used in the select list
    */
serg@serg.mylan's avatar
serg@serg.mylan committed
4505
    strmake(name_buff, db_name, sizeof(name_buff)-1);
monty@mysql.com's avatar
monty@mysql.com committed
4506
    my_casedn_str(files_charset_info, name_buff);
monty@mysql.com's avatar
monty@mysql.com committed
4507
    db_name= name_buff;
4508 4509
  }

4510
  found= FALSE;
4511 4512 4513 4514 4515 4516 4517 4518

  /*
    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);
4519
       tables;
4520 4521 4522
       tables= (table_name ? tables->next_local :
                tables->next_name_resolution_table)
       )
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4523
  {
4524 4525 4526
    Field *field;
    TABLE *table= tables->table;

4527 4528
    DBUG_ASSERT(tables->is_leaf_for_name_resolution());

4529 4530 4531 4532
    if (table_name && my_strcasecmp(table_alias_charset, table_name,
                                    tables->alias) ||
        (db_name && strcmp(tables->db,db_name)))
      continue;
4533

hf@deer.(none)'s avatar
hf@deer.(none) committed
4534
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4535 4536 4537 4538 4539 4540 4541
    /* 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(),
4542 4543
                                  field_iterator.db_name(),
                                  field_iterator.table_name(),
4544 4545 4546
                                  &field_iterator))
        DBUG_RETURN(TRUE);
    }
hf@deer.(none)'s avatar
hf@deer.(none) committed
4547
#endif
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4548 4549


4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572
    /*
      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)
4573
      {
4574
        found= TRUE;
4575
        it->replace(item); /* Replace '*' with the first found item. */
4576
      }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4577
      else
4578 4579 4580 4581 4582 4583 4584
        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,
4585 4586 4587
        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.
4588 4589
      */
      if (any_privileges)
4590
      {
4591 4592 4593 4594
        DBUG_ASSERT(tables->field_translation == NULL && table ||
                    tables->is_natural_join);
        DBUG_ASSERT(item->type() == Item::FIELD_ITEM);
        Item_field *fld= (Item_field*) item;
4595
        const char *field_table_name= field_iterator.table_name();
4596

4597 4598 4599 4600
        if (!tables->schema_table && 
            !(fld->have_privileges=
              (get_column_grant(thd, field_iterator.grant(),
                                field_iterator.db_name(),
4601
                                field_table_name, fld->field_name) &
4602 4603 4604
               VIEW_ANY_ACL)))
        {
          my_error(ER_COLUMNACCESS_DENIED_ERROR, MYF(0), "ANY",
4605 4606
                   thd->security_ctx->priv_user,
                   thd->security_ctx->host_or_ip,
4607
                   fld->field_name, field_table_name);
4608 4609
          DBUG_RETURN(TRUE);
        }
4610
      }
4611
#endif
4612

4613
      if ((field= field_iterator.field()))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4614
      {
4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626
        /*
          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)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4627
        {
4628 4629 4630
          bool is_created;
          TABLE *field_table;
          /*
4631
            In this case we are sure that the column ref will not be created
4632
            because it was already created and stored with the natural join.
4633
          */
4634
          Natural_join_column *nj_col;
4635
          if (!(nj_col= field_iterator.get_or_create_column_ref(&is_created)))
4636 4637 4638 4639
            DBUG_RETURN(TRUE);
          DBUG_ASSERT(nj_col->table_field && !is_created);
          field_table= nj_col->table_ref->table;
          if (field_table)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4640
          {
4641 4642 4643
            thd->used_tables|= field_table->map;
            field_table->used_keys.intersect(field->part_of_key);
            field_table->used_fields++;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4644
          }
4645
        }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4646
      }
4647 4648 4649 4650 4651 4652
      else
      {
        thd->used_tables|= item->used_tables();
        item->walk(&Item::reset_query_id_processor,
                   (byte *)(&thd->query_id));
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4653
    }
4654 4655 4656 4657 4658 4659 4660 4661
    /*
      In case of stored tables, all fields are considered as used,
      while in the case of views, the fields considered as used are the
      ones marked in setup_tables during fix_fields of view columns.
      For NATURAL joins, used_tables is updated in the IF above.
    */
    if (table)
      table->used_fields= table->s->fields;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4662
  }
4663
  if (found)
4664
    DBUG_RETURN(FALSE);
4665

4666
  /*
4667 4668 4669
    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.
4670
  */
4671
  if (!table_name)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4672
    my_message(ER_NO_TABLES_USED, ER(ER_NO_TABLES_USED), MYF(0));
4673 4674
  else
    my_error(ER_BAD_TABLE_ERROR, MYF(0), table_name);
4675 4676

  DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4677 4678 4679 4680
}


/*
4681
  Fix all conditions and outer join expressions.
4682 4683 4684 4685

  SYNOPSIS
    setup_conds()
    thd     thread handler
4686 4687 4688 4689 4690 4691 4692 4693 4694 4695
    tables  list of tables for name resolving (select_lex->table_list)
    leaves  list of leaves of join table tree (select_lex->leaf_tables)
    conds   WHERE clause

  DESCRIPTION
    TODO

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

4698 4699
int setup_conds(THD *thd, TABLE_LIST *tables, TABLE_LIST *leaves,
                COND **conds)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4700
{
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4701
  SELECT_LEX *select_lex= thd->lex->current_select;
konstantin@mysql.com's avatar
konstantin@mysql.com committed
4702
  Query_arena *arena= thd->stmt_arena, backup;
pem@mysql.comhem.se's avatar
pem@mysql.comhem.se committed
4703
  TABLE_LIST *table= NULL;	// For HP compilers
4704 4705 4706 4707 4708 4709 4710 4711 4712 4713
  /*
    it_is_update set to TRUE when tables of primary SELECT_LEX (SELECT_LEX
    which belong to LEX, i.e. most up SELECT) will be updated by
    INSERT/UPDATE/LOAD
    NOTE: using this condition helps to prevent call of prepare_check_option()
    from subquery of VIEW, because tables of subquery belongs to VIEW
    (see condition before prepare_check_option() call)
  */
  bool it_is_update= (select_lex == &thd->lex->select_lex) &&
    thd->lex->which_check_option_applicable();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4714
  DBUG_ENTER("setup_conds");
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4715

monty@mysql.com's avatar
monty@mysql.com committed
4716
  if (select_lex->conds_processed_with_permanent_arena ||
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4717
      arena->is_conventional())
monty@mysql.com's avatar
monty@mysql.com committed
4718 4719
    arena= 0;                                   // For easier test

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

4723 4724 4725 4726 4727 4728
  for (table= tables; table; table= table->next_local)
  {
    if (table->prepare_where(thd, conds, FALSE))
      goto err_no_arena;
  }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4729 4730 4731
  if (*conds)
  {
    thd->where="where clause";
4732
    if (!(*conds)->fixed && (*conds)->fix_fields(thd, conds) ||
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4733
	(*conds)->check_cols(1))
4734
      goto err_no_arena;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4735 4736
  }

4737 4738 4739 4740
  /*
    Apply fix_fields() to all ON clauses at all levels of nesting,
    including the ones inside view definitions.
  */
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
4741
  for (table= leaves; table; table= table->next_leaf)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4742
  {
4743 4744
    TABLE_LIST *embedded; /* The table at the current level of nesting. */
    TABLE_LIST *embedding= table; /* The parent nested table reference. */
4745
    do
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4746
    {
4747 4748
      embedded= embedding;
      if (embedded->on_expr)
4749
      {
4750 4751
        /* Make a join an a expression */
        thd->where="on clause";
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4752
        if (!embedded->on_expr->fixed &&
4753
            embedded->on_expr->fix_fields(thd, &embedded->on_expr) ||
4754
	    embedded->on_expr->check_cols(1))
4755
	  goto err_no_arena;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4756
        select_lex->cond_count++;
4757
      }
4758
      embedding= embedded->embedding;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4759
    }
4760 4761
    while (embedding &&
           embedding->nested_join->join_list.head() == embedded);
4762 4763 4764 4765

    /* process CHECK OPTION */
    if (it_is_update)
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4766
      TABLE_LIST *view= table->top_table();
4767 4768 4769 4770 4771 4772 4773
      if (view->effective_with_check)
      {
        if (view->prepare_check_option(thd))
          goto err_no_arena;
        thd->change_item_tree(&table->check_option, view->check_option);
      }
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4774
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4775

konstantin@mysql.com's avatar
konstantin@mysql.com committed
4776
  if (!thd->stmt_arena->is_conventional())
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4777 4778 4779 4780 4781 4782 4783 4784 4785 4786
  {
    /*
      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;
  }
4787
  DBUG_RETURN(test(thd->net.report_error));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4788

4789
err_no_arena:
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4790
  DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4791 4792 4793 4794 4795 4796 4797 4798
}


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

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814

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

4815
static bool
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4816 4817
fill_record(THD * thd, List<Item> &fields, List<Item> &values,
            bool ignore_errors)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4818
{
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
4819
  List_iterator_fast<Item> f(fields),v(values);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4820 4821 4822 4823 4824 4825 4826
  Item *value;
  Item_field *field;
  DBUG_ENTER("fill_record");

  while ((field=(Item_field*) f++))
  {
    value=v++;
4827 4828
    Field *rfield= field->field;
    TABLE *table= rfield->table;
4829
    if (rfield == table->next_number_field)
4830
      table->auto_increment_field_not_null= TRUE;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4831
    if ((value->save_in_field(rfield, 0) < 0) && !ignore_errors)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4832 4833 4834 4835
    {
      my_message(ER_UNKNOWN_ERROR, ER(ER_UNKNOWN_ERROR), MYF(0));
      DBUG_RETURN(TRUE);
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4836
  }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4837
  DBUG_RETURN(thd->net.report_error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4838 4839 4840
}


4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875
/*
  Fill fields in list with values from the list of items and invoke
  before triggers.

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

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

  RETURN
    FALSE   OK
    TRUE    error occured
*/

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


bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892
/*
  Fill field buffer with values from Field list

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

  RETURN
    FALSE   OK
    TRUE    error occured
*/

bool
fill_record(THD *thd, Field **ptr, List<Item> &values, bool ignore_errors)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4893
{
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
4894
  List_iterator_fast<Item> v(values);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4895 4896 4897 4898 4899 4900 4901
  Item *value;
  DBUG_ENTER("fill_record");

  Field *field;
  while ((field = *ptr++))
  {
    value=v++;
4902
    TABLE *table= field->table;
4903
    if (field == table->next_number_field)
4904
      table->auto_increment_field_not_null= TRUE;
4905
    if (value->save_in_field(field, 0) == -1)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4906
      DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4907
  }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4908
  DBUG_RETURN(thd->net.report_error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4909 4910 4911
}


4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946
/*
  Fill fields in array with values from the list of items and invoke
  before triggers.

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

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

  RETURN
    FALSE   OK
    TRUE    error occured
*/

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


bk@work.mysql.com's avatar
bk@work.mysql.com committed
4947 4948
static void mysql_rm_tmp_tables(void)
{
4949 4950
  uint i, idx;
  char	filePath[FN_REFLEN], *tmpdir;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4951 4952 4953 4954
  MY_DIR *dirp;
  FILEINFO *file;
  DBUG_ENTER("mysql_rm_tmp_tables");

4955 4956 4957
  for (i=0; i<=mysql_tmpdir_list.max; i++)
  {
    tmpdir=mysql_tmpdir_list.list[i];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4958
  /* See if the directory exists */
4959 4960
    if (!(dirp = my_dir(tmpdir,MYF(MY_WME | MY_DONT_SORT))))
      continue;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4961

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

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4964
  for (idx=0 ; idx < (uint) dirp->number_off_files ; idx++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4965 4966
  {
    file=dirp->dir_entry+idx;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4967 4968 4969 4970 4971 4972

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4973 4974
    if (!bcmp(file->name,tmp_file_prefix,tmp_file_prefix_length))
    {
4975 4976
        sprintf(filePath,"%s%s",tmpdir,file->name);
        VOID(my_delete(filePath,MYF(MY_WME)));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4977 4978 4979
    }
  }
  my_dirend(dirp);
4980
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4981 4982 4983 4984 4985 4986 4987 4988 4989 4990
  DBUG_VOID_RETURN;
}



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

/*
4991 4992 4993 4994 4995 4996 4997 4998 4999 5000
  Invalidate any cache entries that are for some DB

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

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

5003
void remove_db_from_cache(const char *db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5004 5005 5006 5007
{
  for (uint idx=0 ; idx < open_cache.records ; idx++)
  {
    TABLE *table=(TABLE*) hash_element(&open_cache,idx);
5008
    if (!strcmp(table->s->db, db))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5009
    {
5010
      table->s->version= 0L;			/* Free when thread is ready */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5011 5012 5013 5014
      if (!table->in_use)
	relink_unused(table);
    }
  }
5015
  while (unused_tables && !unused_tables->s->version)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031 5032 5033
    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);
}


/*
5034 5035 5036 5037 5038
  Mark all entries with the table as deleted to force an reopen of the table

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

monty@mysql.com's avatar
monty@mysql.com committed
5039 5040 5041
  PREREQUISITES
    Lock on LOCK_open()

5042 5043 5044 5045
  RETURN
    0  This thread now have exclusive access to this table and no other thread
       can access the table until close_thread_tables() is called.
    1  Table is in use by another thread
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5046 5047
*/

5048
bool remove_table_from_cache(THD *thd, const char *db, const char *table_name,
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5049
                             uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5050 5051 5052 5053
{
  char key[MAX_DBKEY_LENGTH];
  uint key_length;
  TABLE *table;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5054
  bool result=0, signalled= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5055 5056
  DBUG_ENTER("remove_table_from_cache");

monty@mysql.com's avatar
monty@mysql.com committed
5057

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5058
  key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
5059
  for (;;)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5060
  {
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5061 5062 5063 5064 5065
    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))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5066
    {
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5067
      THD *in_use;
5068
      table->s->version=0L;		/* Free when thread is ready */
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5069
      if (!(in_use=table->in_use))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5070
      {
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5071 5072
        DBUG_PRINT("info",("Table was not in use"));
        relink_unused(table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5073
      }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5074
      else if (in_use != thd)
5075
      {
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5076 5077 5078 5079 5080 5081 5082
        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)
        {
5083
	  in_use->killed= THD::KILL_CONNECTION;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102
	  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
5103
	    signalled|= mysql_lock_abort_for_thread(thd, thd_table);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5104
        }
5105
      }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5106
      else
5107
        result= result || (flags & RTFC_OWNED_BY_THD_FLAG);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5108
    }
5109
    while (unused_tables && !unused_tables->s->version)
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5110
      VOID(hash_delete(&open_cache,(byte*) unused_tables));
5111
    if (result && (flags & RTFC_WAIT_OTHER_THREAD_FLAG))
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5112
    {
5113
      if (!(flags & RTFC_CHECK_KILLED_FLAG) || !thd->killed)
5114
      {
monty@mysql.com's avatar
monty@mysql.com committed
5115
        dropping_tables++;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5116 5117 5118 5119
        if (likely(signalled))
          (void) pthread_cond_wait(&COND_refresh, &LOCK_open);
        else
        {
monty@mysql.com's avatar
monty@mysql.com committed
5120
          struct timespec abstime;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5121 5122 5123 5124 5125 5126 5127 5128 5129 5130
          /*
            It can happen that another thread has opened the
            table but has not yet locked any table at all. Since
            it can be locked waiting for a table that our thread
            has done LOCK TABLE x WRITE on previously, we need to
            ensure that the thread actually hears our signal
            before we go to sleep. Thus we wait for a short time
            and then we retry another loop in the
            remove_table_from_cache routine.
          */
monty@mysql.com's avatar
monty@mysql.com committed
5131 5132
          set_timespec(abstime, 10);
          pthread_cond_timedwait(&COND_refresh, &LOCK_open, &abstime);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5133
        }
monty@mysql.com's avatar
monty@mysql.com committed
5134 5135
        dropping_tables--;
        continue;
5136
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5137
    }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
5138
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5139 5140 5141 5142
  }
  DBUG_RETURN(result);
}

5143
int setup_ftfuncs(SELECT_LEX *select_lex)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5144
{
5145 5146
  List_iterator<Item_func_match> li(*(select_lex->ftfunc_list)),
                                 lj(*(select_lex->ftfunc_list));
5147
  Item_func_match *ftf, *ftf2;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5148 5149

  while ((ftf=li++))
5150
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5151 5152
    if (ftf->fix_index())
      return 1;
5153 5154
    lj.rewind();
    while ((ftf2=lj++) != ftf)
5155
    {
5156
      if (ftf->eq(ftf2,1) && !ftf2->master)
5157 5158 5159
        ftf2->master=ftf;
    }
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5160 5161 5162

  return 0;
}
5163

5164

5165
int init_ftfuncs(THD *thd, SELECT_LEX *select_lex, bool no_order)
5166
{
5167
  if (select_lex->ftfunc_list->elements)
5168
  {
5169
    List_iterator<Item_func_match> li(*(select_lex->ftfunc_list));
5170 5171 5172
    Item_func_match *ifm;
    DBUG_PRINT("info",("Performing FULLTEXT search"));
    thd->proc_info="FULLTEXT initialization";
5173

5174 5175 5176
    while ((ifm=li++))
      ifm->init_search(no_order);
  }
5177 5178
  return 0;
}
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5179 5180 5181 5182 5183 5184 5185


/*
  open new .frm format table

  SYNOPSIS
    open_new_frm()
5186
    THD		  thread handler
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5187 5188
    path	  path to .frm
    alias	  alias for table
5189 5190
    db            database
    table_name    name of table
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5191 5192 5193 5194 5195 5196 5197 5198
    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
*/
5199

5200 5201
static bool
open_new_frm(THD *thd, const char *path, const char *alias,
5202 5203
             const char *db, const char *table_name,
             uint db_stat, uint prgflag,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5204 5205 5206 5207
	     uint ha_open_flags, TABLE *outparam, TABLE_LIST *table_desc,
	     MEM_ROOT *mem_root)
{
  LEX_STRING pathstr;
5208 5209 5210 5211
  File_parser *parser;
  DBUG_ENTER("open_new_frm");

  pathstr.str=    (char*) path;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5212
  pathstr.length= strlen(path);
5213

5214
  if ((parser= sql_parse_prepare(&pathstr, mem_root, 1)))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5215
  {
5216
    if (is_equal(&view_type, parser->type()))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5217
    {
5218
      if (table_desc == 0 || table_desc->required_type == FRMTYPE_TABLE)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5219
      {
5220
        my_error(ER_WRONG_OBJECT, MYF(0), db, table_name, "BASE TABLE");
5221
        goto err;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5222
      }
5223
      if (mysql_make_view(thd, parser, table_desc))
5224
        goto err;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5225 5226 5227 5228 5229
    }
    else
    {
      /* only VIEWs are supported now */
      my_error(ER_FRM_UNKNOWN_TYPE, MYF(0), path,  parser->type()->str);
5230
      goto err;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5231
    }
5232
    DBUG_RETURN(0);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5233
  }
monty@mysql.com's avatar
monty@mysql.com committed
5234
 
5235 5236 5237
err:
  bzero(outparam, sizeof(TABLE));	// do not run repair
  DBUG_RETURN(1);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5238
}
5239 5240 5241 5242 5243 5244


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