1
1
/* Copyright (C) 2000-2006 MySQL AB
3
This program is free software; you can redistribute it and/or modify
4
it under the terms of the GNU General Public License as published by
5
the Free Software Foundation; version 2 of the License.
7
This program is distributed in the hope that it will be useful,
8
but WITHOUT ANY WARRANTY; without even the implied warranty of
9
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10
GNU General Public License for more details.
12
You should have received a copy of the GNU General Public License
13
along with this program; if not, write to the Free Software
14
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
3
This program is free software; you can redistribute it and/or modify
4
it under the terms of the GNU General Public License as published by
5
the Free Software Foundation; version 2 of the License.
7
This program is distributed in the hope that it will be useful,
8
but WITHOUT ANY WARRANTY; without even the implied warranty of
9
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10
GNU General Public License for more details.
12
You should have received a copy of the GNU General Public License
13
along with this program; if not, write to the Free Software
14
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
17
17
/* Basic functions needed by many modules */
23
#if TIME_WITH_SYS_TIME
24
# include <sys/time.h>
28
# include <sys/time.h>
33
#include "drizzled/internal/my_pthread.h"
34
#include "drizzled/internal/thread_var.h"
36
#include <drizzled/sql_select.h>
37
#include <drizzled/error.h>
38
#include <drizzled/gettext.h>
39
#include <drizzled/nested_join.h>
40
#include <drizzled/sql_base.h>
41
#include <drizzled/show.h>
42
#include <drizzled/item/cmpfunc.h>
43
#include <drizzled/replication_services.h>
44
#include <drizzled/check_stack_overrun.h>
45
#include <drizzled/lock.h>
46
#include <drizzled/plugin/listen.h>
47
#include "drizzled/cached_directory.h"
48
#include <drizzled/field/timestamp.h>
49
#include <drizzled/field/null.h>
50
#include "drizzled/sql_table.h"
51
#include "drizzled/global_charset_info.h"
52
#include "drizzled/pthread_globals.h"
53
#include "drizzled/internal/iocache.h"
54
#include "drizzled/drizzled.h"
55
#include "drizzled/plugin/authorization.h"
56
#include "drizzled/table_placeholder.h"
63
extern bool volatile shutdown_in_progress;
65
TableOpenCache &get_open_cache()
67
static TableOpenCache open_cache; /* Used by mysql_test */
72
static void free_cache_entry(Table *entry);
74
void remove_table(Table *arg)
76
TableOpenCacheRange ppp;
77
ppp= get_open_cache().equal_range(arg->getShare()->getCacheKey());
79
for (TableOpenCache::const_iterator iter= ppp.first;
80
iter != ppp.second; ++iter)
82
Table *found_table= (*iter).second;
84
if (found_table == arg)
86
free_cache_entry(arg);
87
get_open_cache().erase(iter);
93
static bool add_table(Table *arg)
95
TableOpenCache &open_cache(get_open_cache());
97
TableOpenCache::iterator returnable= open_cache.insert(make_pair(arg->getShare()->getCacheKey(), arg));
99
return not (returnable == open_cache.end());
103
Table *tables; /* Used by mysql_test */
105
Table *getTable() const
110
Table *setTable(Table *arg)
119
/* Free cache if too big */
120
while (cached_open_tables() > table_cache_size && getTable())
121
remove_table(getTable());
126
while (getTable() && not getTable()->getShare()->getVersion())
127
remove_table(getTable());
130
void link(Table *table)
134
table->setNext(getTable()); /* Link in last */
135
table->setPrev(getTable()->getPrev());
136
getTable()->setPrev(table);
137
table->getPrev()->setNext(table);
141
table->setPrev(setTable(table));
142
table->setNext(table->getPrev());
143
assert(table->getNext() == table && table->getPrev() == table);
148
void unlink(Table *table)
152
/* Unlink the table from "unused_tables" list. */
153
if (table == getTable())
155
setTable(getTable()->getNext()); // Remove from link
156
if (table == getTable())
161
/* move table first in unused links */
163
void relink(Table *table)
165
if (table != getTable())
169
table->setNext(getTable()); /* Link in unused tables */
170
table->setPrev(getTable()->getPrev());
171
getTable()->getPrev()->setNext(table);
172
getTable()->setPrev(table);
181
remove_table(getTable());
193
static UnusedTables unused_tables;
194
static int open_unireg_entry(Session *session,
197
TableIdentifier &identifier);
199
unsigned char *table_cache_key(const unsigned char *record,
204
static bool reopen_table(Table *table);
207
unsigned char *table_cache_key(const unsigned char *record,
211
Table *entry=(Table*) record;
212
*length= entry->getShare()->getCacheKey().size();
213
return (unsigned char*) &entry->getShare()->getCacheKey()[0];
19
#include "mysql_priv.h"
20
#include "sql_select.h"
25
#define FLAGSTR(S,F) ((S) & (F) ? #F " " : "")
28
@defgroup Data_Dictionary Data Dictionary
31
TABLE *unused_tables; /* Used by mysql_test */
32
HASH open_cache; /* Used by mysql_test */
33
static HASH table_def_cache;
34
static TABLE_SHARE *oldest_unused_share, end_of_unused_share;
35
static pthread_mutex_t LOCK_table_share;
36
static bool table_def_inited= 0;
38
static int open_unireg_entry(THD *thd, TABLE *entry, TABLE_LIST *table_list,
40
char *cache_key, uint cache_key_length,
41
MEM_ROOT *mem_root, uint flags);
42
static void free_cache_entry(TABLE *entry);
43
static void close_old_data_files(THD *thd, TABLE *table, bool morph_locks,
47
extern "C" uchar *table_cache_key(const uchar *record, size_t *length,
48
my_bool not_used __attribute__((unused)))
50
TABLE *entry=(TABLE*) record;
51
*length= entry->s->table_cache_key.length;
52
return (uchar*) entry->s->table_cache_key.str;
216
56
bool table_cache_init(void)
221
uint32_t cached_open_tables(void)
223
return get_open_cache().size();
58
return hash_init(&open_cache, &my_charset_bin, table_cache_size+16,
59
0, 0, table_cache_key,
60
(hash_free_key) free_cache_entry, 0) != 0;
226
63
void table_cache_free(void)
228
refresh_version++; // Force close of open tables
230
unused_tables.clear();
231
get_open_cache().clear();
235
Close cursor handle, but leave the table in the table cache
238
close_handle_and_leave_table_as_lock()
242
By leaving the table in the table cache, it disallows any other thread
245
session->killed will be set if we run out of memory
247
If closing a MERGE child, the calling function has to take care for
248
closing the parent too, if necessary.
252
void close_handle_and_leave_table_as_lock(Table *table)
254
TableShare *share, *old_share= table->getMutableShare();
255
assert(table->db_stat);
256
assert(table->getShare()->getType() == message::Table::STANDARD);
65
DBUG_ENTER("table_cache_free");
68
close_cached_tables(NULL, NULL, false, false, false);
69
if (!open_cache.records) // Safety first
70
hash_free(&open_cache);
75
uint cached_open_tables(void)
77
return open_cache.records;
82
static void check_unused(void)
84
uint count= 0, open_files= 0, idx= 0;
85
TABLE *cur_link,*start_link;
87
if ((start_link=cur_link=unused_tables))
91
if (cur_link != cur_link->next->prev || cur_link != cur_link->prev->next)
93
DBUG_PRINT("error",("Unused_links aren't linked properly")); /* purecov: inspected */
94
return; /* purecov: inspected */
96
} while (count++ < open_cache.records &&
97
(cur_link=cur_link->next) != start_link);
98
if (cur_link != start_link)
100
DBUG_PRINT("error",("Unused_links aren't connected")); /* purecov: inspected */
103
for (idx=0 ; idx < open_cache.records ; idx++)
105
TABLE *entry=(TABLE*) hash_element(&open_cache,idx);
113
DBUG_PRINT("error",("Unused_links doesn't match open_cache: diff: %d", /* purecov: inspected */
114
count)); /* purecov: inspected */
117
#ifdef NOT_SAFE_FOR_REPAIR
119
check that open cache and table definition cache has same number of
123
for (idx=0 ; idx < table_def_cache.records ; idx++)
125
TABLE_SHARE *entry= (TABLE_SHARE*) hash_element(&table_def_cache,idx);
126
count+= entry->ref_count;
128
if (count != open_files)
130
DBUG_PRINT("error", ("table_def ref_count: %u open_cache: %u",
132
DBUG_ASSERT(count == open_files);
137
#define check_unused()
142
Create a table cache key
145
create_table_def_key()
147
key Create key here (must be of size MAX_DBKEY_LENGTH)
148
table_list Table definition
149
tmp_table Set if table is a tmp table
152
The table cache_key is created from:
156
if the table is a tmp table, we add the following to make each tmp table
159
4 bytes for master thread id
160
4 bytes pseudo thread id
166
uint create_table_def_key(THD *thd, char *key, TABLE_LIST *table_list,
169
uint key_length= (uint) (strmov(strmov(key, table_list->db)+1,
170
table_list->table_name)-key)+1;
173
int4store(key + key_length, thd->server_id);
174
int4store(key + key_length + 4, thd->variables.pseudo_thread_id);
175
key_length+= TMP_TABLE_KEY_EXTRA;
182
/*****************************************************************************
183
Functions to handle table definition cach (TABLE_SHARE)
184
*****************************************************************************/
186
extern "C" uchar *table_def_key(const uchar *record, size_t *length,
187
my_bool not_used __attribute__((unused)))
189
TABLE_SHARE *entry=(TABLE_SHARE*) record;
190
*length= entry->table_cache_key.length;
191
return (uchar*) entry->table_cache_key.str;
195
static void table_def_free_entry(TABLE_SHARE *share)
197
DBUG_ENTER("table_def_free_entry");
200
/* remove from old_unused_share list */
201
pthread_mutex_lock(&LOCK_table_share);
202
*share->prev= share->next;
203
share->next->prev= share->prev;
204
pthread_mutex_unlock(&LOCK_table_share);
206
free_table_share(share);
211
bool table_def_init(void)
214
pthread_mutex_init(&LOCK_table_share, MY_MUTEX_INIT_FAST);
215
oldest_unused_share= &end_of_unused_share;
216
end_of_unused_share.prev= &oldest_unused_share;
218
return hash_init(&table_def_cache, &my_charset_bin, table_def_size,
220
(hash_free_key) table_def_free_entry, 0) != 0;
224
void table_def_free(void)
226
DBUG_ENTER("table_def_free");
227
if (table_def_inited)
230
pthread_mutex_destroy(&LOCK_table_share);
231
hash_free(&table_def_cache);
237
uint cached_table_definitions(void)
239
return table_def_cache.records;
244
Get TABLE_SHARE for a table.
248
table_list Table that should be opened
250
key_length Length of key
251
db_flags Flags to open_table_def():
253
error out: Error code from open_table_def()
256
Get a table definition from the table definition cache.
257
If it doesn't exist, create a new from the table definition file.
260
We must have wrlock on LOCK_open when we come here
261
(To be changed later)
268
TABLE_SHARE *get_table_share(THD *thd, TABLE_LIST *table_list, char *key,
269
uint key_length, uint db_flags, int *error)
272
DBUG_ENTER("get_table_share");
276
/* Read table definition from cache */
277
if ((share= (TABLE_SHARE*) hash_search(&table_def_cache,(uchar*) key,
281
if (!(share= alloc_table_share(table_list, key, key_length)))
287
Lock mutex to be able to read table definition from file without
290
(void) pthread_mutex_lock(&share->mutex);
293
We assign a new table id under the protection of the LOCK_open and
294
the share's own mutex. We do this insted of creating a new mutex
295
and using it for the sole purpose of serializing accesses to a
296
static variable, we assign the table id here. We assign it to the
297
share before inserting it into the table_def_cache to be really
298
sure that it cannot be read from the cache without having a table
301
CAVEAT. This means that the table cannot be used for
302
binlogging/replication purposes, unless get_table_share() has been
303
called directly or indirectly.
305
assign_new_table_id(share);
307
if (my_hash_insert(&table_def_cache, (uchar*) share))
309
free_table_share(share);
310
DBUG_RETURN(0); // return error
312
if (open_table_def(thd, share, db_flags))
314
*error= share->error;
315
(void) hash_delete(&table_def_cache, (uchar*) share);
318
share->ref_count++; // Mark in use
319
DBUG_PRINT("exit", ("share: 0x%lx ref_count: %u",
320
(ulong) share, share->ref_count));
321
(void) pthread_mutex_unlock(&share->mutex);
326
We found an existing table definition. Return it if we didn't get
327
an error when reading the table definition from file.
330
/* We must do a lock to ensure that the structure is initialized */
331
(void) pthread_mutex_lock(&share->mutex);
334
/* Table definition contained an error */
335
open_table_error(share, share->error, share->open_errno, share->errarg);
336
(void) pthread_mutex_unlock(&share->mutex);
340
if (!share->ref_count++ && share->prev)
343
Share was not used before and it was in the old_unused_share list
344
Unlink share from this list
346
DBUG_PRINT("info", ("Unlinking from not used list"));
347
pthread_mutex_lock(&LOCK_table_share);
348
*share->prev= share->next;
349
share->next->prev= share->prev;
352
pthread_mutex_unlock(&LOCK_table_share);
354
(void) pthread_mutex_unlock(&share->mutex);
356
/* Free cache if too big */
357
while (table_def_cache.records > table_def_size &&
358
oldest_unused_share->next)
360
pthread_mutex_lock(&oldest_unused_share->mutex);
361
VOID(hash_delete(&table_def_cache, (uchar*) oldest_unused_share));
364
DBUG_PRINT("exit", ("share: 0x%lx ref_count: %u",
365
(ulong) share, share->ref_count));
371
Get a table share. If it didn't exist, try creating it from engine
373
For arguments and return values, see get_table_from_share()
377
*get_table_share_with_create(THD *thd, TABLE_LIST *table_list,
378
char *key, uint key_length,
379
uint db_flags, int *error)
383
DBUG_ENTER("get_table_share_with_create");
385
share= get_table_share(thd, table_list, key, key_length, db_flags, error);
387
If share is not NULL, we found an existing share.
389
If share is NULL, and there is no error, we're inside
390
pre-locking, which silences 'ER_NO_SUCH_TABLE' errors
391
with the intention to silently drop non-existing tables
392
from the pre-locking list. In this case we still need to try
393
auto-discover before returning a NULL share.
395
If share is NULL and the error is ER_NO_SUCH_TABLE, this is
396
the same as above, only that the error was not silenced by
397
pre-locking. Once again, we need to try to auto-discover
400
Finally, if share is still NULL, it's a real error and we need
403
@todo Rework alternative ways to deal with ER_NO_SUCH TABLE.
405
if (share || (thd->is_error() && (thd->main_da.sql_errno() != ER_NO_SUCH_TABLE)))
409
/* Table didn't exist. Check if some engine can provide it */
410
if ((tmp= ha_create_table_from_engine(thd, table_list->db,
411
table_list->table_name)) < 0)
414
No such table in any engine.
415
Hide "Table doesn't exist" errors if the table belongs to a view.
416
The check for thd->is_error() is necessary to not push an
417
unwanted error in case of pre-locking, which silences
418
"no such table" errors.
419
@todo Rework the alternative ways to deal with ER_NO_SUCH TABLE.
421
if (thd->is_error() && table_list->belong_to_view)
424
my_error(ER_VIEW_INVALID, MYF(0), "", "");
430
/* Give right error message */
432
DBUG_PRINT("error", ("Discovery of %s/%s failed", table_list->db,
433
table_list->table_name));
434
my_printf_error(ER_UNKNOWN_ERROR,
435
"Failed to open '%-.64s', error while "
436
"unpacking from engine",
437
MYF(0), table_list->table_name);
440
/* Table existed in engine. Let's open it */
441
mysql_reset_errors(thd, 1); // Clear warnings
442
thd->clear_error(); // Clear error message
443
DBUG_RETURN(get_table_share(thd, table_list, key, key_length,
449
Mark that we are not using table share anymore.
452
release_table_share()
454
release_type How the release should be done:
456
- Release without checking
457
RELEASE_WAIT_FOR_DROP
458
- Don't return until we get a signal that the
459
table is deleted or the thread is killed.
462
If ref_count goes to zero and (we have done a refresh or if we have
463
already too many open table shares) then delete the definition.
465
If type == RELEASE_WAIT_FOR_DROP then don't return until we get a signal
466
that the table is deleted or the thread is killed.
469
void release_table_share(TABLE_SHARE *share, enum release_type type)
471
bool to_be_deleted= 0;
472
DBUG_ENTER("release_table_share");
474
("share: 0x%lx table: %s.%s ref_count: %u version: %lu",
475
(ulong) share, share->db.str, share->table_name.str,
476
share->ref_count, share->version));
478
safe_mutex_assert_owner(&LOCK_open);
480
pthread_mutex_lock(&share->mutex);
481
if (!--share->ref_count)
483
if (share->version != refresh_version)
487
/* Link share last in used_table_share list */
488
DBUG_PRINT("info",("moving share to unused list"));
490
DBUG_ASSERT(share->next == 0);
491
pthread_mutex_lock(&LOCK_table_share);
492
share->prev= end_of_unused_share.prev;
493
*end_of_unused_share.prev= share;
494
end_of_unused_share.prev= &share->next;
495
share->next= &end_of_unused_share;
496
pthread_mutex_unlock(&LOCK_table_share);
498
to_be_deleted= (table_def_cache.records > table_def_size);
504
DBUG_PRINT("info", ("Deleting share"));
505
hash_delete(&table_def_cache, (uchar*) share);
508
pthread_mutex_unlock(&share->mutex);
514
Check if table definition exits in cache
517
get_cached_table_share()
519
table_name Table name
523
# TABLE_SHARE for table
526
TABLE_SHARE *get_cached_table_share(const char *db, const char *table_name)
528
char key[NAME_LEN*2+2];
529
TABLE_LIST table_list;
531
safe_mutex_assert_owner(&LOCK_open);
533
table_list.db= (char*) db;
534
table_list.table_name= (char*) table_name;
535
key_length= create_table_def_key((THD*) 0, key, &table_list, 0);
536
return (TABLE_SHARE*) hash_search(&table_def_cache,(uchar*) key, key_length);
541
Close file handle, but leave the table in the table cache
544
close_handle_and_leave_table_as_lock()
548
By leaving the table in the table cache, it disallows any other thread
551
thd->killed will be set if we run out of memory
553
If closing a MERGE child, the calling function has to take care for
554
closing the parent too, if necessary.
558
void close_handle_and_leave_table_as_lock(TABLE *table)
560
TABLE_SHARE *share, *old_share= table->s;
562
MEM_ROOT *mem_root= &table->mem_root;
563
DBUG_ENTER("close_handle_and_leave_table_as_lock");
565
DBUG_ASSERT(table->db_stat);
259
568
Make a local copy of the table share and free the current one.
260
569
This has to be done to ensure that the table share is removed from
261
570
the table defintion cache as soon as the last instance is removed
263
TableIdentifier identifier(table->getShare()->getSchemaName(), table->getShare()->getTableName(), message::Table::INTERNAL);
264
const TableIdentifier::Key &key(identifier.getKey());
265
share= new TableShare(identifier.getType(),
267
const_cast<char *>(&key[0]), static_cast<uint32_t>(old_share->getCacheKeySize()));
269
table->cursor->close();
270
table->db_stat= 0; // Mark cursor closed
271
TableShare::release(table->getMutableShare());
272
table->setShare(share);
273
table->cursor->change_table_ptr(table, table->getMutableShare());
572
if (multi_alloc_root(mem_root,
573
&share, sizeof(*share),
574
&key_buff, old_share->table_cache_key.length,
577
bzero((char*) share, sizeof(*share));
578
share->set_table_cache_key(key_buff, old_share->table_cache_key.str,
579
old_share->table_cache_key.length);
580
share->tmp_table= INTERNAL_TMP_TABLE; // for intern_close_table()
583
table->file->close();
584
table->db_stat= 0; // Mark file closed
585
release_table_share(table->s, RELEASE_NORMAL);
587
table->file->change_table_ptr(table, table->s);
595
Create a list for all open tables matching SQL expression
600
wild SQL like expression
603
One gets only a list of tables for which one has any kind of privilege.
604
db and table names are allocated in result struct, so one doesn't need
605
a lock on LOCK_open when traversing the return list.
608
NULL Error (Probably OOM)
609
# Pointer to list of names of open tables.
612
OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *db, const char *wild)
615
OPEN_TABLE_LIST **start_list, *open_list;
616
TABLE_LIST table_list;
617
DBUG_ENTER("list_open_tables");
619
VOID(pthread_mutex_lock(&LOCK_open));
620
bzero((char*) &table_list,sizeof(table_list));
621
start_list= &open_list;
624
for (uint idx=0 ; result == 0 && idx < open_cache.records; idx++)
626
OPEN_TABLE_LIST *table;
627
TABLE *entry=(TABLE*) hash_element(&open_cache,idx);
628
TABLE_SHARE *share= entry->s;
630
if (db && my_strcasecmp(system_charset_info, db, share->db.str))
632
if (wild && wild_compare(share->table_name.str, wild, 0))
635
/* Check if user has SELECT privilege for any column in the table */
636
table_list.db= share->db.str;
637
table_list.table_name= share->table_name.str;
639
/* need to check if we haven't already listed it */
640
for (table= open_list ; table ; table=table->next)
642
if (!strcmp(table->table, share->table_name.str) &&
643
!strcmp(table->db, share->db.str))
647
if (entry->locked_by_name)
654
if (!(*start_list = (OPEN_TABLE_LIST *)
655
sql_alloc(sizeof(**start_list)+share->table_cache_key.length)))
657
open_list=0; // Out of memory
660
strmov((*start_list)->table=
661
strmov(((*start_list)->db= (char*) ((*start_list)+1)),
663
share->table_name.str);
664
(*start_list)->in_use= entry->in_use ? 1 : 0;
665
(*start_list)->locked= entry->locked_by_name ? 1 : 0;
666
start_list= &(*start_list)->next;
669
VOID(pthread_mutex_unlock(&LOCK_open));
670
DBUG_RETURN(open_list);
277
673
/*****************************************************************************
278
674
* Functions to free open table cache
279
675
****************************************************************************/
282
void Table::intern_close_table()
678
void intern_close_table(TABLE *table)
283
679
{ // Free all structures
285
if (cursor) // Not true if name lock
287
delete_table(true); // close cursor
680
DBUG_ENTER("intern_close_table");
681
DBUG_PRINT("tcache", ("table: '%s'.'%s' 0x%lx",
682
table->s ? table->s->db.str : "?",
683
table->s ? table->s->table_name.str : "?",
686
free_io_cache(table);
687
if (table->file) // Not true if name lock
688
VOID(closefrm(table, 1)); // close file
292
693
Remove table from the open table cache
296
entry Table to remove
697
table Table to remove
299
We need to have a lock on LOCK_open when calling this
700
We need to have a lock on LOCK_open when calling this
302
void free_cache_entry(Table *table)
703
static void free_cache_entry(TABLE *table)
304
table->intern_close_table();
305
if (not table->in_use)
705
DBUG_ENTER("free_cache_entry");
707
intern_close_table(table);
307
unused_tables.unlink(table);
710
table->next->prev=table->prev; /* remove from used chain */
711
table->prev->next=table->next;
712
if (table == unused_tables)
714
unused_tables=unused_tables->next;
715
if (table == unused_tables)
718
check_unused(); // consisty check
720
my_free((uchar*) table,MYF(0));
313
724
/* Free resources allocated by filesort() and read_record() */
315
void Table::free_io_cache()
726
void free_io_cache(TABLE *table)
728
DBUG_ENTER("free_io_cache");
729
if (table->sort.io_cache)
319
close_cached_file(sort.io_cache);
320
delete sort.io_cache;
731
close_cached_file(table->sort.io_cache);
732
my_free((uchar*) table->sort.io_cache,MYF(0));
733
table->sort.io_cache=0;
327
740
Close all tables which aren't in use by any thread
329
@param session Thread context (may be NULL)
742
@param thd Thread context
330
743
@param tables List of tables to remove from the cache
331
744
@param have_lock If LOCK_open is locked
332
745
@param wait_for_refresh Wait for a impending flush
333
746
@param wait_for_placeholders Wait for tables being reopened so that the GRL
334
won't proceed while write-locked tables are being reopened by other
747
won't proceed while write-locked tables are being reopened by other
337
@remark Session can be NULL, but then wait_for_refresh must be false
338
and tables must be NULL.
750
@remark THD can be NULL, but then wait_for_refresh must be false
751
and tables must be NULL.
341
bool Session::close_cached_tables(TableList *tables, bool wait_for_refresh, bool wait_for_placeholders)
754
bool close_cached_tables(THD *thd, TABLE_LIST *tables, bool have_lock,
755
bool wait_for_refresh, bool wait_for_placeholders)
344
Session *session= this;
346
LOCK_open.lock(); /* Optionally lock for remove tables from open_cahe if not in use */
758
DBUG_ENTER("close_cached_tables");
759
DBUG_ASSERT(thd || (!wait_for_refresh && !tables));
762
VOID(pthread_mutex_lock(&LOCK_open));
350
765
refresh_version++; // Force close of open tables
352
unused_tables.clear();
766
while (unused_tables)
769
if (hash_delete(&open_cache,(uchar*) unused_tables))
770
printf("Warning: Couldn't delete open table from hash\n");
772
VOID(hash_delete(&open_cache,(uchar*) unused_tables));
775
/* Free table shares */
776
while (oldest_unused_share->next)
778
pthread_mutex_lock(&oldest_unused_share->mutex);
779
VOID(hash_delete(&table_def_cache, (uchar*) oldest_unused_share));
781
DBUG_PRINT("tcache", ("incremented global refresh_version to: %lu",
354
783
if (wait_for_refresh)
469
895
old locks. This should always succeed (unless some external process
470
896
has removed the tables)
472
result= session->reopen_tables(true, true);
898
thd->in_lock_tables=1;
899
result=reopen_tables(thd,1,1);
900
thd->in_lock_tables=0;
474
901
/* Set version for table */
475
for (Table *table= session->open_tables; table ; table= table->getNext())
902
for (TABLE *table=thd->open_tables; table ; table= table->next)
478
905
Preserve the version (0) of write locked tables so that a impending
479
906
global read lock won't sneak in.
481
908
if (table->reginfo.lock_type < TL_WRITE_ALLOW_WRITE)
482
table->getMutableShare()->refreshVersion();
909
table->s->version= refresh_version;
913
VOID(pthread_mutex_unlock(&LOCK_open));
488
914
if (wait_for_refresh)
490
boost::mutex::scoped_lock scopedLock(session->mysys_var->mutex);
491
session->mysys_var->current_mutex= 0;
492
session->mysys_var->current_cond= 0;
493
session->set_proc_info(0);
916
pthread_mutex_lock(&thd->mysys_var->mutex);
917
thd->mysys_var->current_mutex= 0;
918
thd->mysys_var->current_cond= 0;
919
thd_proc_info(thd, 0);
920
pthread_mutex_unlock(&thd->mysys_var->mutex);
927
Close all tables which match specified connection string or
928
if specified string is NULL, then any table with a connection string.
931
bool close_cached_connection_tables(THD *thd, bool if_wait_for_refresh,
932
LEX_STRING *connection, bool have_lock)
935
TABLE_LIST tmp, *tables= NULL;
937
DBUG_ENTER("close_cached_connections");
940
bzero(&tmp, sizeof(TABLE_LIST));
943
VOID(pthread_mutex_lock(&LOCK_open));
945
for (idx= 0; idx < table_def_cache.records; idx++)
947
TABLE_SHARE *share= (TABLE_SHARE *) hash_element(&table_def_cache, idx);
949
/* Ignore if table is not open or does not have a connect_string */
950
if (!share->connect_string.length || !share->ref_count)
953
/* Compare the connection string */
955
(connection->length > share->connect_string.length ||
956
(connection->length < share->connect_string.length &&
957
(share->connect_string.str[connection->length] != '/' &&
958
share->connect_string.str[connection->length] != '\\')) ||
959
strncasecmp(connection->str, share->connect_string.str,
960
connection->length)))
963
/* close_cached_tables() only uses these elements */
964
tmp.db= share->db.str;
965
tmp.table_name= share->table_name.str;
966
tmp.next_local= tables;
968
tables= (TABLE_LIST *) memdup_root(thd->mem_root, (char*)&tmp,
973
result= close_cached_tables(thd, tables, true, false, false);
976
VOID(pthread_mutex_unlock(&LOCK_open));
978
if (if_wait_for_refresh)
980
pthread_mutex_lock(&thd->mysys_var->mutex);
981
thd->mysys_var->current_mutex= 0;
982
thd->mysys_var->current_cond= 0;
984
pthread_mutex_unlock(&thd->mysys_var->mutex);
501
move one table to free list
504
bool Session::free_cached_table()
506
bool found_old_table= false;
507
Table *table= open_tables;
509
safe_mutex_assert_owner(LOCK_open.native_handle());
510
assert(table->key_read == 0);
511
assert(!table->cursor || table->cursor->inited == Cursor::NONE);
513
open_tables= table->getNext();
515
if (table->needs_reopen_or_name_lock() ||
516
version != refresh_version || !table->db_stat)
519
found_old_table= true;
524
Open placeholders have Table::db_stat set to 0, so they should be
525
handled by the first alternative.
527
assert(not table->open_placeholder);
529
/* Free memory and reset for next loop */
530
table->cursor->ha_reset();
531
table->in_use= false;
533
unused_tables.link(table);
536
return found_old_table;
992
Mark all temporary tables which were used by the current statement or
993
substatement as free for reuse, but only if the query_id can be cleared.
995
@param thd thread context
997
@remark For temp tables associated with a open SQL HANDLER the query_id
998
is not reset until the HANDLER is closed.
1001
static void mark_temp_tables_as_free_for_reuse(THD *thd)
1003
for (TABLE *table= thd->temporary_tables ; table ; table= table->next)
1005
if ((table->query_id == thd->query_id) && ! table->open_by_handler)
1008
table->file->ha_reset();
1015
Mark all tables in the list which were used by current substatement
1019
mark_used_tables_as_free_for_reuse()
1020
thd - thread context
1021
table - head of the list of tables
1024
Marks all tables in the list which were used by current substatement
1025
(they are marked by its query_id) as free for reuse.
1028
The reason we reset query_id is that it's not enough to just test
1029
if table->query_id != thd->query_id to know if a table is in use.
1032
SELECT f1_that_uses_t1() FROM t1;
1033
In f1_that_uses_t1() we will see one instance of t1 where query_id is
1034
set to query_id of original query.
1037
static void mark_used_tables_as_free_for_reuse(THD *thd, TABLE *table)
1039
for (; table ; table= table->next)
1041
if (table->query_id == thd->query_id)
1044
table->file->ha_reset();
541
1051
Auxiliary function to close all tables in the open_tables list.
543
@param session Thread context.
1053
@param thd Thread context.
545
1055
@remark It should not ordinarily be called directly.
548
void Session::close_open_tables()
1058
static void close_open_tables(THD *thd)
550
bool found_old_table= false;
552
safe_mutex_assert_not_owner(LOCK_open.native_handle());
554
boost::mutex::scoped_lock scoped_lock(LOCK_open); /* Close all open tables on Session */
558
found_old_table|= free_cached_table();
560
some_tables_deleted= false;
1060
bool found_old_table= 0;
1062
safe_mutex_assert_not_owner(&LOCK_open);
1064
VOID(pthread_mutex_lock(&LOCK_open));
1066
DBUG_PRINT("info", ("thd->open_tables: 0x%lx", (long) thd->open_tables));
1068
while (thd->open_tables)
1069
found_old_table|= close_thread_table(thd, &thd->open_tables);
1070
thd->some_tables_deleted= 0;
1072
/* Free tables to hold down open files */
1073
while (open_cache.records > table_cache_size && unused_tables)
1074
VOID(hash_delete(&open_cache,(uchar*) unused_tables)); /* purecov: tested */
562
1076
if (found_old_table)
564
1078
/* Tell threads waiting for refresh that something has happened */
565
1079
broadcast_refresh();
1082
VOID(pthread_mutex_unlock(&LOCK_open));
1087
Close all tables used by the current substatement, or all tables
1088
used by this thread if we are on the upper level.
1091
close_thread_tables()
1095
Unlocks tables and frees derived tables.
1096
Put all normal tables used by thread in free list.
1098
It will only close/mark as free for reuse tables opened by this
1099
substatement, it will also check if we are closing tables after
1100
execution of complete query (i.e. we are on upper level) and will
1101
leave prelocked mode if needed.
1104
void close_thread_tables(THD *thd)
1107
DBUG_ENTER("close_thread_tables");
1110
We are assuming here that thd->derived_tables contains ONLY derived
1111
tables for this substatement. i.e. instead of approach which uses
1112
query_id matching for determining which of the derived tables belong
1113
to this substatement we rely on the ability of substatements to
1114
save/restore thd->derived_tables during their execution.
1116
TODO: Probably even better approach is to simply associate list of
1117
derived tables with (sub-)statement instead of thread and destroy
1118
them at the end of its execution.
1120
if (thd->derived_tables)
1124
Close all derived tables generated in queries like
1125
SELECT * FROM (SELECT * FROM t1)
1127
for (table= thd->derived_tables ; table ; table= next)
1130
free_tmp_table(thd, table);
1132
thd->derived_tables= 0;
1136
Mark all temporary tables used by this statement as free for reuse.
1138
mark_temp_tables_as_free_for_reuse(thd);
1140
Let us commit transaction for statement. Since in 5.0 we only have
1141
one statement transaction and don't allow several nested statement
1142
transactions this call will do nothing if we are inside of stored
1143
function or trigger (i.e. statement transaction is already active and
1144
does not belong to statement for which we do close_thread_tables()).
1145
TODO: This should be fixed in later releases.
1147
if (!(thd->state_flags & Open_tables_state::BACKUPS_AVAIL))
1149
thd->main_da.can_overwrite_status= true;
1150
ha_autocommit_or_rollback(thd, thd->is_error());
1151
thd->main_da.can_overwrite_status= false;
1152
thd->transaction.stmt.reset();
1155
if (thd->locked_tables)
1158
/* Ensure we are calling ha_reset() for all used tables */
1159
mark_used_tables_as_free_for_reuse(thd, thd->open_tables);
1162
We are under simple LOCK TABLES so should not do anything else.
1170
For RBR we flush the pending event just before we unlock all the
1171
tables. This means that we are at the end of a topmost
1172
statement, so we ensure that the STMT_END_F flag is set on the
1173
pending event. For statements that are *inside* stored
1174
functions, the pending event will not be flushed: that will be
1175
handled either before writing a query log event (inside
1176
binlog_query()) or when preparing a pending event.
1178
thd->binlog_flush_pending_rows_event(true);
1179
mysql_unlock_tables(thd, thd->lock);
1183
Note that we need to hold LOCK_open while changing the
1184
open_tables list. Another thread may work on it.
1185
(See: remove_table_from_cache(), mysql_wait_completed_table())
1186
Closing a MERGE child before the parent would be fatal if the
1187
other thread tries to abort the MERGE lock in between.
1189
if (thd->open_tables)
1190
close_open_tables(thd);
1196
/* move one table to free list */
1198
bool close_thread_table(THD *thd, TABLE **table_ptr)
1200
bool found_old_table= 0;
1201
TABLE *table= *table_ptr;
1202
DBUG_ENTER("close_thread_table");
1203
DBUG_ASSERT(table->key_read == 0);
1204
DBUG_ASSERT(!table->file || table->file->inited == handler::NONE);
1205
DBUG_PRINT("tcache", ("table: '%s'.'%s' 0x%lx", table->s->db.str,
1206
table->s->table_name.str, (long) table));
1208
*table_ptr=table->next;
1210
if (table->needs_reopen_or_name_lock() ||
1211
thd->version != refresh_version || !table->db_stat)
1213
VOID(hash_delete(&open_cache,(uchar*) table));
1219
Open placeholders have TABLE::db_stat set to 0, so they should be
1220
handled by the first alternative.
1222
DBUG_ASSERT(!table->open_placeholder);
1224
/* Free memory and reset for next loop */
1225
table->file->ha_reset();
1229
table->next=unused_tables; /* Link in last */
1230
table->prev=unused_tables->prev;
1231
unused_tables->prev=table;
1232
table->prev->next=table;
1235
unused_tables=table->next=table->prev=table;
1237
DBUG_RETURN(found_old_table);
1241
/* close_temporary_tables' internal, 4 is due to uint4korr definition */
1242
static inline uint tmpkeyval(THD *thd, TABLE *table)
1244
return uint4korr(table->s->table_cache_key.str + table->s->table_cache_key.length - 4);
1249
Close all temporary tables created by 'CREATE TEMPORARY TABLE' for thread
1250
creates one DROP TEMPORARY TABLE binlog event for each pseudo-thread
1253
void close_temporary_tables(THD *thd)
1258
/* Assume thd->options has OPTION_QUOTE_SHOW_CREATE */
1259
bool was_quote_show= true;
1261
if (!thd->temporary_tables)
1264
if (!mysql_bin_log.is_open() || thd->current_stmt_binlog_row_based)
1267
for (table= thd->temporary_tables; table; table= tmp_next)
1269
tmp_next= table->next;
1270
close_temporary(table, 1, 1);
1272
thd->temporary_tables= 0;
1276
/* Better add "if exists", in case a RESET MASTER has been done */
1277
const char stub[]= "DROP /*!40005 TEMPORARY */ TABLE IF EXISTS ";
1278
uint stub_len= sizeof(stub) - 1;
1280
String s_query= String(buf, sizeof(buf), system_charset_info);
1281
bool found_user_tables= false;
1283
memcpy(buf, stub, stub_len);
1286
Insertion sort of temp tables by pseudo_thread_id to build ordered list
1287
of sublists of equal pseudo_thread_id
1290
for (prev_table= thd->temporary_tables, table= prev_table->next;
1292
prev_table= table, table= table->next)
1294
TABLE *prev_sorted /* same as for prev_table */, *sorted;
1295
if (is_user_table(table))
1297
if (!found_user_tables)
1298
found_user_tables= true;
1299
for (prev_sorted= NULL, sorted= thd->temporary_tables; sorted != table;
1300
prev_sorted= sorted, sorted= sorted->next)
1302
if (!is_user_table(sorted) ||
1303
tmpkeyval(thd, sorted) > tmpkeyval(thd, table))
1305
/* move into the sorted part of the list from the unsorted */
1306
prev_table->next= table->next;
1307
table->next= sorted;
1310
prev_sorted->next= table;
1314
thd->temporary_tables= table;
1323
/* We always quote db,table names though it is slight overkill */
1324
if (found_user_tables &&
1325
!(was_quote_show= test(thd->options & OPTION_QUOTE_SHOW_CREATE)))
1327
thd->options |= OPTION_QUOTE_SHOW_CREATE;
1330
/* scan sorted tmps to generate sequence of DROP */
1331
for (table= thd->temporary_tables; table; table= next)
1333
if (is_user_table(table))
1335
my_thread_id save_pseudo_thread_id= thd->variables.pseudo_thread_id;
1336
/* Set pseudo_thread_id to be that of the processed table */
1337
thd->variables.pseudo_thread_id= tmpkeyval(thd, table);
1339
Loop forward through all tables within the sublist of
1340
common pseudo_thread_id to create single DROP query.
1342
for (s_query.length(stub_len);
1343
table && is_user_table(table) &&
1344
tmpkeyval(thd, table) == thd->variables.pseudo_thread_id;
1348
We are going to add 4 ` around the db/table names and possible more
1349
due to special characters in the names
1351
append_identifier(thd, &s_query, table->s->db.str, strlen(table->s->db.str));
1352
s_query.append('.');
1353
append_identifier(thd, &s_query, table->s->table_name.str,
1354
strlen(table->s->table_name.str));
1355
s_query.append(',');
1357
close_temporary(table, 1, 1);
1360
CHARSET_INFO *cs_save= thd->variables.character_set_client;
1361
thd->variables.character_set_client= system_charset_info;
1362
Query_log_event qinfo(thd, s_query.ptr(),
1363
s_query.length() - 1 /* to remove trailing ',' */,
1365
thd->variables.character_set_client= cs_save;
1367
Imagine the thread had created a temp table, then was doing a
1368
SELECT, and the SELECT was killed. Then it's not clever to
1369
mark the statement above as "killed", because it's not really
1370
a statement updating data, and there are 99.99% chances it
1371
will succeed on slave. If a real update (one updating a
1372
persistent table) was killed on the master, then this real
1373
update will be logged with error_code=killed, rightfully
1374
causing the slave to stop.
1376
qinfo.error_code= 0;
1377
mysql_bin_log.write(&qinfo);
1378
thd->variables.pseudo_thread_id= save_pseudo_thread_id;
1383
close_temporary(table, 1, 1);
1386
if (!was_quote_show)
1387
thd->options&= ~OPTION_QUOTE_SHOW_CREATE; /* restore option */
1388
thd->temporary_tables=0;
570
1392
Find table in list.
574
table Pointer to table list
575
offset Offset to which list in table structure to use
576
db_name Data base name
577
table_name Table name
580
This is called by find_table_in_global_list().
584
# Pointer to found table.
1395
find_table_in_list()
1396
table Pointer to table list
1397
offset Offset to which list in table structure to use
1398
db_name Data base name
1399
table_name Table name
1402
This is called by find_table_in_local_list() and
1403
find_table_in_global_list().
1406
NULL Table not found
1407
# Pointer to found table.
587
TableList *find_table_in_list(TableList *table,
588
TableList *TableList::*link,
590
const char *table_name)
1410
TABLE_LIST *find_table_in_list(TABLE_LIST *table,
1411
TABLE_LIST *TABLE_LIST::*link,
1412
const char *db_name,
1413
const char *table_name)
592
1415
for (; table; table= table->*link )
594
if ((table->table == 0 || table->table->getShare()->getType() == message::Table::STANDARD) &&
595
strcasecmp(table->db, db_name) == 0 &&
596
strcasecmp(table->table_name, table_name) == 0)
1417
if ((table->table == 0 || table->table->s->tmp_table == NO_TMP_TABLE) &&
1418
strcmp(table->db, db_name) == 0 &&
1419
strcmp(table->table_name, table_name) == 0)
681
1510
(exclude_from_table_unique_test) or prelocking placeholder.
683
1512
table_list= res->next_global;
689
void Session::doGetTableNames(const SchemaIdentifier &schema_identifier,
690
std::set<std::string>& set_of_names)
692
for (Table *table= temporary_tables ; table ; table= table->getNext())
694
if (schema_identifier.compare(table->getShare()->getSchemaName()))
696
set_of_names.insert(table->getShare()->getTableName());
701
void Session::doGetTableNames(CachedDirectory &,
702
const SchemaIdentifier &schema_identifier,
703
std::set<std::string> &set_of_names)
705
doGetTableNames(schema_identifier, set_of_names);
708
void Session::doGetTableIdentifiers(const SchemaIdentifier &schema_identifier,
709
TableIdentifiers &set_of_identifiers)
711
for (Table *table= temporary_tables ; table ; table= table->getNext())
713
if (schema_identifier.compare(table->getShare()->getSchemaName()))
715
set_of_identifiers.push_back(TableIdentifier(table->getShare()->getSchemaName(),
716
table->getShare()->getTableName(),
717
table->getShare()->getPath()));
722
void Session::doGetTableIdentifiers(CachedDirectory &,
723
const SchemaIdentifier &schema_identifier,
724
TableIdentifiers &set_of_identifiers)
726
doGetTableIdentifiers(schema_identifier, set_of_identifiers);
729
bool Session::doDoesTableExist(const TableIdentifier &identifier)
731
for (Table *table= temporary_tables ; table ; table= table->getNext())
733
if (table->getShare()->getType() == message::Table::TEMPORARY)
735
if (identifier.getKey() == table->getShare()->getCacheKey())
745
int Session::doGetTableDefinition(const TableIdentifier &identifier,
746
message::Table &table_proto)
748
for (Table *table= temporary_tables ; table ; table= table->getNext())
750
if (table->getShare()->getType() == message::Table::TEMPORARY)
752
if (identifier.getKey() == table->getShare()->getCacheKey())
754
table_proto.CopyFrom(*(table->getShare()->getTableProto()));
764
Table *Session::find_temporary_table(const char *new_db, const char *table_name)
1514
("found same copy of table or table which we should skip"));
1521
Issue correct error message in case we found 2 duplicate tables which
1522
prevent some update operation
1525
update_non_unique_table_error()
1526
update table which we try to update
1527
operation name of update operation
1528
duplicate duplicate table which we found
1531
here we hide view underlying tables if we have them
1534
void update_non_unique_table_error(TABLE_LIST *update,
1535
const char *operation,
1536
TABLE_LIST *duplicate)
1538
my_error(ER_UPDATE_TABLE_USED, MYF(0), update->alias);
1542
TABLE *find_temporary_table(THD *thd, const char *db, const char *table_name)
1544
TABLE_LIST table_list;
1546
table_list.db= (char*) db;
1547
table_list.table_name= (char*) table_name;
1548
return find_temporary_table(thd, &table_list);
1552
TABLE *find_temporary_table(THD *thd, TABLE_LIST *table_list)
766
1554
char key[MAX_DBKEY_LENGTH];
767
1555
uint key_length;
769
key_length= TableIdentifier::createKey(key, new_db, table_name);
771
for (Table *table= temporary_tables ; table ; table= table->getNext())
1557
DBUG_ENTER("find_temporary_table");
1558
DBUG_PRINT("enter", ("table: '%s'.'%s'",
1559
table_list->db, table_list->table_name));
1561
key_length= create_table_def_key(thd, key, table_list, 1);
1562
for (table=thd->temporary_tables ; table ; table= table->next)
773
const TableIdentifier::Key &share_key(table->getShare()->getCacheKey());
774
if (share_key.size() == key_length &&
775
not memcmp(&share_key[0], key, key_length))
1564
if (table->s->table_cache_key.length == key_length &&
1565
!memcmp(table->s->table_cache_key.str, key, key_length))
1568
("Found table. server_id: %u pseudo_thread_id: %lu",
1569
(uint) thd->server_id,
1570
(ulong) thd->variables.pseudo_thread_id));
780
return NULL; // Not a temporary table
783
Table *Session::find_temporary_table(TableList *table_list)
785
return find_temporary_table(table_list->db, table_list->table_name);
788
Table *Session::find_temporary_table(TableIdentifier &identifier)
790
for (Table *table= temporary_tables ; table ; table= table->getNext())
792
if (identifier.getKey() == table->getShare()->getCacheKey())
796
return NULL; // Not a temporary table
1574
DBUG_RETURN(0); // Not a temporary table
801
1579
Drop a temporary table.
803
Try to locate the table in the list of session->temporary_tables.
1581
Try to locate the table in the list of thd->temporary_tables.
804
1582
If the table is found:
805
- if the table is being used by some outer statement, fail.
806
- if the table is in session->locked_tables, unlock it and
807
remove it from the list of locked tables. Currently only transactional
808
temporary tables are present in the locked_tables list.
809
- Close the temporary table, remove its .FRM
810
- remove the table from the list of temporary tables
1583
- if the table is being used by some outer statement, fail.
1584
- if the table is in thd->locked_tables, unlock it and
1585
remove it from the list of locked tables. Currently only transactional
1586
temporary tables are present in the locked_tables list.
1587
- Close the temporary table, remove its .FRM
1588
- remove the table from the list of temporary tables
812
1590
This function is used to drop user temporary tables, as well as
813
1591
internal tables created in CREATE TEMPORARY TABLE ... SELECT
814
or ALTER Table. Even though part of the work done by this function
1592
or ALTER TABLE. Even though part of the work done by this function
815
1593
is redundant when the table is internal, as long as we
816
1594
link both internal and user temporary tables into the same
817
session->temporary_tables list, it's impossible to tell here whether
1595
thd->temporary_tables list, it's impossible to tell here whether
818
1596
we're dealing with an internal or a user temporary table.
820
1598
@retval 0 the table was found and dropped successfully.
821
1599
@retval 1 the table was not found in the list of temporary tables
823
1601
@retval -1 the table is in use by a outer query
826
int Session::drop_temporary_table(TableList *table_list)
1604
int drop_temporary_table(THD *thd, TABLE_LIST *table_list)
1607
DBUG_ENTER("drop_temporary_table");
1608
DBUG_PRINT("tmptable", ("closing table: '%s'.'%s'",
1609
table_list->db, table_list->table_name));
830
if (not (table= find_temporary_table(table_list)))
1611
if (!(table= find_temporary_table(thd, table_list)))
833
1614
/* Table might be in use by some outer statement. */
834
if (table->query_id && table->query_id != query_id)
836
my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->getAlias());
840
close_temporary_table(table);
1615
if (table->query_id && table->query_id != thd->query_id)
1617
my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
1622
If LOCK TABLES list is not empty and contains this table,
1623
unlock the table and remove the table from this list.
1625
mysql_lock_remove(thd, thd->locked_tables, table, false);
1626
close_temporary_table(thd, table, 1, 1);
1631
unlink from thd->temporary tables and close temporary table
1634
void close_temporary_table(THD *thd, TABLE *table,
1635
bool free_share, bool delete_table)
1637
DBUG_ENTER("close_temporary_table");
1638
DBUG_PRINT("tmptable", ("closing table: '%s'.'%s' 0x%lx alias: '%s'",
1639
table->s->db.str, table->s->table_name.str,
1640
(long) table, table->alias));
1644
table->prev->next= table->next;
1645
if (table->prev->next)
1646
table->next->prev= table->prev;
1650
/* removing the item from the list */
1651
DBUG_ASSERT(table == thd->temporary_tables);
1653
slave must reset its temporary list pointer to zero to exclude
1654
passing non-zero value to end_slave via rli->save_temporary_tables
1655
when no temp tables opened, see an invariant below.
1657
thd->temporary_tables= table->next;
1658
if (thd->temporary_tables)
1659
table->next->prev= 0;
1661
if (thd->slave_thread)
1663
/* natural invariant of temporary_tables */
1664
DBUG_ASSERT(slave_open_temp_tables || !thd->temporary_tables);
1665
slave_open_temp_tables--;
1667
close_temporary(table, free_share, delete_table);
1673
Close and delete a temporary table
1676
This dosn't unlink table from thd->temporary
1677
If this is needed, use close_temporary_table()
1680
void close_temporary(TABLE *table, bool free_share, bool delete_table)
1682
handlerton *table_type= table->s->db_type();
1683
DBUG_ENTER("close_temporary");
1684
DBUG_PRINT("tmptable", ("closing table: '%s'.'%s'",
1685
table->s->db.str, table->s->table_name.str));
1687
free_io_cache(table);
1690
Check that temporary table has not been created with
1691
frm_only because it has then not been created in any storage engine
1694
rm_temporary_table(table_type, table->s->path.str,
1695
table->s->tmp_table == TMP_TABLE_FRM_FILE_ONLY);
1698
free_table_share(table->s);
1699
my_free((char*) table,MYF(0));
1706
Used by ALTER TABLE when the table is a temporary one. It changes something
1707
only if the ALTER contained a RENAME clause (otherwise, table_name is the old
1709
Prepares a table cache key, which is the concatenation of db, table_name and
1710
thd->slave_proxy_id, separated by '\0'.
1713
bool rename_temporary_table(THD* thd, TABLE *table, const char *db,
1714
const char *table_name)
1718
TABLE_SHARE *share= table->s;
1719
TABLE_LIST table_list;
1720
DBUG_ENTER("rename_temporary_table");
1722
if (!(key=(char*) alloc_root(&share->mem_root, MAX_DBKEY_LENGTH)))
1723
DBUG_RETURN(1); /* purecov: inspected */
1725
table_list.db= (char*) db;
1726
table_list.table_name= (char*) table_name;
1727
key_length= create_table_def_key(thd, key, &table_list, 1);
1728
share->set_table_cache_key(key, key_length);
1733
/* move table first in unused links */
1735
static void relink_unused(TABLE *table)
1737
if (table != unused_tables)
1739
table->prev->next=table->next; /* Remove from unused list */
1740
table->next->prev=table->prev;
1741
table->next=unused_tables; /* Link in unused tables */
1742
table->prev=unused_tables->prev;
1743
unused_tables->prev->next=table;
1744
unused_tables->prev=table;
1745
unused_tables=table;
847
Remove all instances of table from thread's open list and
850
@param session Thread context
851
@param find Table to remove
1752
Remove all instances of table from thread's open list and
1755
@param thd Thread context
1756
@param find Table to remove
1757
@param unlock true - free all locks on tables removed that are
1758
done with LOCK TABLES
1761
@note When unlock parameter is false or current thread doesn't have
1762
any tables locked with LOCK TABLES, tables are assumed to be
1763
not locked (for example already unlocked).
854
void Session::unlink_open_table(Table *find)
1766
void unlink_open_table(THD *thd, TABLE *find, bool unlock)
856
1768
char key[MAX_DBKEY_LENGTH];
857
uint32_t key_length= find->getShare()->getCacheKeySize();
859
safe_mutex_assert_owner(LOCK_open.native_handle());
861
memcpy(key, &find->getMutableShare()->getCacheKey()[0], key_length);
1769
uint key_length= find->s->table_cache_key.length;
1770
TABLE *list, **prev;
1771
DBUG_ENTER("unlink_open_table");
1773
safe_mutex_assert_owner(&LOCK_open);
1775
memcpy(key, find->s->table_cache_key.str, key_length);
863
1777
Note that we need to hold LOCK_open while changing the
864
1778
open_tables list. Another thread may work on it.
1018
1976
object to its original state.
1020
1978
*table= orig_table;
1024
share= table->getMutableShare();
1026
1984
We want to prevent other connections from opening this table until end
1027
1985
of statement as it is likely that modifications of table's metadata are
1028
not yet finished (for example CREATE TRIGGER have to change .TRG cursor,
1986
not yet finished (for example CREATE TRIGGER have to change .TRG file,
1029
1987
or we might want to drop table if CREATE TABLE ... SELECT fails).
1030
1988
This also allows us to assume that no other connection will sneak in
1031
1989
before we will get table-level lock on this table.
1033
share->resetVersion();
1034
table->in_use = this;
1992
table->in_use = thd;
1038
table->setNext(open_tables);
1997
table->next= thd->open_tables;
1998
thd->open_tables= table;
1044
Table object should be already in Session::open_tables list so we just
1045
need to set Table::next correctly.
2003
TABLE object should be already in THD::open_tables list so we just
2004
need to set TABLE::next correctly.
1047
table->setNext(orig_table.getNext());
2006
table->next= orig_table.next;
1050
table->tablenr= current_tablenr++;
1051
table->used_fields= 0;
1052
table->const_table= 0;
1053
table->null_row= false;
1054
table->maybe_null= false;
1055
table->force_index= false;
1056
table->status= STATUS_NO_RECORD;
2009
table->tablenr=thd->current_tablenr++;
2010
table->used_fields=0;
2011
table->const_table=0;
2012
table->null_row= table->maybe_null= table->force_index= 0;
2013
table->status=STATUS_NO_RECORD;
1063
Create and insert into table cache placeholder for table
1064
which will prevent its opening (or creation) (a.k.a lock
1067
@param session Thread context
1068
@param key Table cache key for name to be locked
1069
@param key_length Table cache key length
1071
@return Pointer to Table object used for name locking or 0 in
2019
Create and insert into table cache placeholder for table
2020
which will prevent its opening (or creation) (a.k.a lock
2023
@param thd Thread context
2024
@param key Table cache key for name to be locked
2025
@param key_length Table cache key length
2027
@return Pointer to TABLE object used for name locking or 0 in
1075
Table *Session::table_cache_insert_placeholder(const char *db_name, const char *table_name)
2031
TABLE *table_cache_insert_placeholder(THD *thd, const char *key,
1077
safe_mutex_assert_owner(LOCK_open.native_handle());
2037
DBUG_ENTER("table_cache_insert_placeholder");
2039
safe_mutex_assert_owner(&LOCK_open);
1080
2042
Create a table entry with the right key and with an old refresh version
2043
Note that we must use my_multi_malloc() here as this is freed by the
1082
TableIdentifier identifier(db_name, table_name, message::Table::INTERNAL);
1083
TablePlaceholder *table= new TablePlaceholder(this, identifier);
1085
if (not add_table(table))
2046
if (!my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),
2047
&table, sizeof(*table),
2048
&share, sizeof(*share),
2049
&key_buff, key_length,
2054
share->set_table_cache_key(key_buff, key, key_length);
2055
share->tmp_table= INTERNAL_TMP_TABLE; // for intern_close_table
2057
table->locked_by_name=1;
2059
if (my_hash_insert(&open_cache, (uchar*)table))
2061
my_free((uchar*) table, MYF(0));
1097
Obtain an exclusive name lock on the table if it is not cached
1100
@param session Thread context
1101
@param db Name of database
1102
@param table_name Name of table
1103
@param[out] table Out parameter which is either:
1104
- set to NULL if table cache contains record for
1106
- set to point to the Table instance used for
1109
@note This function takes into account all records for table in table
1110
cache, even placeholders used for name-locking. This means that
1111
'table' parameter can be set to NULL for some situations when
1112
table does not really exist.
1114
@retval true Error occured (OOM)
1115
@retval false Success. 'table' parameter set according to above rules.
2070
Obtain an exclusive name lock on the table if it is not cached
2073
@param thd Thread context
2074
@param db Name of database
2075
@param table_name Name of table
2076
@param[out] table Out parameter which is either:
2077
- set to NULL if table cache contains record for
2079
- set to point to the TABLE instance used for
2082
@note This function takes into account all records for table in table
2083
cache, even placeholders used for name-locking. This means that
2084
'table' parameter can be set to NULL for some situations when
2085
table does not really exist.
2087
@retval true Error occured (OOM)
2088
@retval false Success. 'table' parameter set according to above rules.
1117
bool Session::lock_table_name_if_not_cached(TableIdentifier &identifier, Table **table)
2091
bool lock_table_name_if_not_cached(THD *thd, const char *db,
2092
const char *table_name, TABLE **table)
1119
const TableIdentifier::Key &key(identifier.getKey());
1121
boost::mutex::scoped_lock scope_lock(LOCK_open); /* Obtain a name lock even though table is not in cache (like for create table) */
1123
TableOpenCache::iterator iter;
1125
iter= get_open_cache().find(key);
1127
if (iter != get_open_cache().end())
2094
char key[MAX_DBKEY_LENGTH];
2096
DBUG_ENTER("lock_table_name_if_not_cached");
2098
key_length= (uint)(strmov(strmov(key, db) + 1, table_name) - key) + 1;
2099
VOID(pthread_mutex_lock(&LOCK_open));
2101
if (hash_search(&open_cache, (uchar *)key, key_length))
2103
VOID(pthread_mutex_unlock(&LOCK_open));
2104
DBUG_PRINT("info", ("Table is cached, name-lock is not obtained"));
1133
if (not (*table= table_cache_insert_placeholder(identifier.getSchemaName().c_str(), identifier.getTableName().c_str())))
1137
(*table)->open_placeholder= true;
1138
(*table)->setNext(open_tables);
1139
open_tables= *table;
2108
if (!(*table= table_cache_insert_placeholder(thd, key, key_length)))
2110
VOID(pthread_mutex_unlock(&LOCK_open));
2113
(*table)->open_placeholder= 1;
2114
(*table)->next= thd->open_tables;
2115
thd->open_tables= *table;
2116
VOID(pthread_mutex_unlock(&LOCK_open));
2122
Check that table exists in table definition cache, on disk
2123
or in some storage engine.
2125
@param thd Thread context
2126
@param table Table list element
2127
@param[out] exists Out parameter which is set to true if table
2128
exists and to false otherwise.
2130
@note This function assumes that caller owns LOCK_open mutex.
2131
It also assumes that the fact that there are no name-locks
2132
on the table was checked beforehand.
2134
@note If there is no .FRM file for the table but it exists in one
2135
of engines (e.g. it was created on another node of NDB cluster)
2136
this function will fetch and create proper .FRM file for it.
2138
@retval true Some error occured
2139
@retval false No error. 'exists' out parameter set accordingly.
2142
bool check_if_table_exists(THD *thd, TABLE_LIST *table, bool *exists)
2144
char path[FN_REFLEN];
2146
DBUG_ENTER("check_if_table_exists");
2148
safe_mutex_assert_owner(&LOCK_open);
2152
if (get_cached_table_share(table->db, table->table_name))
2155
build_table_filename(path, sizeof(path) - 1, table->db, table->table_name,
2158
if (!access(path, F_OK))
2161
/* .FRM file doesn't exist. Check if some engine can provide it. */
2163
rc= ha_create_table_from_engine(thd, table->db, table->table_name);
2167
/* Table does not exists in engines as well. */
2173
/* Table exists in some engine and .FRM for it was created. */
2178
my_printf_error(ER_UNKNOWN_ERROR, "Failed to open '%-.64s', error while "
2179
"unpacking from engine", MYF(0), table->table_name);
1149
session Thread context.
1150
table_list Open first table in list.
1151
refresh INOUT Pointer to memory that will be set to 1 if
1152
we need to close all tables and reopen them.
1153
If this is a NULL pointer, then the table is not
1154
put in the thread-open-list.
1155
flags Bitmap of flags to modify how open works:
1156
DRIZZLE_LOCK_IGNORE_FLUSH - Open table even if
1157
someone has done a flush or namelock on it.
1158
No version number checking is done.
1159
DRIZZLE_OPEN_TEMPORARY_ONLY - Open only temporary
1160
table not the base table or view.
2191
table_list Open first table in list.
2192
refresh INOUT Pointer to memory that will be set to 1 if
2193
we need to close all tables and reopen them.
2194
If this is a NULL pointer, then the table is not
2195
put in the thread-open-list.
2196
flags Bitmap of flags to modify how open works:
2197
MYSQL_LOCK_IGNORE_FLUSH - Open table even if
2198
someone has done a flush or namelock on it.
2199
No version number checking is done.
2200
MYSQL_OPEN_TEMPORARY_ONLY - Open only temporary
2201
table not the base table or view.
1163
Uses a cache of open tables to find a table not in use.
2204
Uses a cache of open tables to find a table not in use.
1165
If table list element for the table to be opened has "create" flag
1166
set and table does not exist, this function will automatically insert
1167
a placeholder for exclusive name lock into the open tables cache and
1168
will return the Table instance that corresponds to this placeholder.
2206
If table list element for the table to be opened has "create" flag
2207
set and table does not exist, this function will automatically insert
2208
a placeholder for exclusive name lock into the open tables cache and
2209
will return the TABLE instance that corresponds to this placeholder.
1171
NULL Open failed. If refresh is set then one should close
1172
all other tables and retry the open.
1173
# Success. Pointer to Table object for open table.
2212
NULL Open failed. If refresh is set then one should close
2213
all other tables and retry the open.
2214
# Success. Pointer to TABLE object for open table.
1177
Table *Session::openTable(TableList *table_list, bool *refresh, uint32_t flags)
2218
TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
2219
bool *refresh, uint flags)
1180
const char *alias= table_list->alias;
2221
register TABLE *table;
2222
char key[MAX_DBKEY_LENGTH];
2223
unsigned int key_length;
2224
char *alias= table_list->alias;
2225
HASH_SEARCH_STATE state;
2226
DBUG_ENTER("open_table");
1182
/* Parsing of partitioning information from .frm needs session->lex set up. */
1183
assert(lex->is_lex_started);
2228
/* Parsing of partitioning information from .frm needs thd->lex set up. */
2229
DBUG_ASSERT(thd->lex->is_lex_started);
1185
2231
/* find a unused table in the open table cache */
1189
2235
/* an open table operation needs a lot of the stack space */
1190
if (check_stack_overrun(this, STACK_MIN_SIZE_FOR_OPEN, (unsigned char *)&alias))
1196
TableIdentifier identifier(table_list->db, table_list->table_name);
1197
const TableIdentifier::Key &key(identifier.getKey());
1198
TableOpenCacheRange ppp;
2236
if (check_stack_overrun(thd, STACK_MIN_SIZE_FOR_OPEN, (uchar *)&alias))
2242
key_length= (create_table_def_key(thd, key, table_list, 1) -
2243
TMP_TABLE_KEY_EXTRA);
1201
2246
Unless requested otherwise, try to resolve this table in the list
1202
2247
of temporary tables of this thread. In MySQL temporary tables
1203
2248
are always thread-local and "shadow" possible base tables with the
1204
2249
same name. This block implements the behaviour.
1205
TODO -> move this block into a separate function.
1207
for (table= temporary_tables; table ; table=table->getNext())
1209
if (table->getShare()->getCacheKey() == key)
1212
We're trying to use the same temporary table twice in a query.
1213
Right now we don't support this because a temporary table
1214
is always represented by only one Table object in Session, and
1215
it can not be cloned. Emit an error for an unsupported behaviour.
1217
if (table->query_id)
1219
my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->getAlias());
1222
table->query_id= getQueryId();
2250
TODO: move this block into a separate function.
2253
for (table= thd->temporary_tables; table ; table=table->next)
2255
if (table->s->table_cache_key.length == key_length +
2256
TMP_TABLE_KEY_EXTRA &&
2257
!memcmp(table->s->table_cache_key.str, key,
2258
key_length + TMP_TABLE_KEY_EXTRA))
2261
We're trying to use the same temporary table twice in a query.
2262
Right now we don't support this because a temporary table
2263
is always represented by only one TABLE object in THD, and
2264
it can not be cloned. Emit an error for an unsupported behaviour.
2266
if (table->query_id)
2269
("query_id: %lu server_id: %u pseudo_thread_id: %lu",
2270
(ulong) table->query_id, (uint) thd->server_id,
2271
(ulong) thd->variables.pseudo_thread_id));
2272
my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
2275
table->query_id= thd->query_id;
2276
thd->thread_specific_used= true;
2277
DBUG_PRINT("info",("Using temporary table"));
2283
if (flags & MYSQL_OPEN_TEMPORARY_ONLY)
2285
my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->db, table_list->table_name);
2290
The table is not temporary - if we're in pre-locked or LOCK TABLES
2291
mode, let's try to find the requested table in the list of pre-opened
2292
and locked tables. If the table is not there, return an error - we can't
2293
open not pre-opened tables in pre-locked/LOCK TABLES mode.
2294
TODO: move this block into a separate function.
2296
if (thd->locked_tables)
2297
{ // Using table locks
2298
TABLE *best_table= 0;
2299
int best_distance= INT_MIN;
2300
bool check_if_used= false;
2301
for (table=thd->open_tables; table ; table=table->next)
2303
if (table->s->table_cache_key.length == key_length &&
2304
!memcmp(table->s->table_cache_key.str, key, key_length))
2306
if (check_if_used && table->query_id &&
2307
table->query_id != thd->query_id)
2310
If we are in stored function or trigger we should ensure that
2311
we won't change table that is already used by calling statement.
2312
So if we are opening table for writing, we should check that it
2313
is not already open by some calling stamement.
2315
my_error(ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG, MYF(0),
2316
table->s->table_name.str);
2320
When looking for a usable TABLE, ignore MERGE children, as they
2321
belong to their parent and cannot be used explicitly.
2323
if (!my_strcasecmp(system_charset_info, table->alias, alias) &&
2324
table->query_id != thd->query_id) /* skip tables already used */
2326
int distance= ((int) table->reginfo.lock_type -
2327
(int) table_list->lock_type);
2329
Find a table that either has the exact lock type requested,
2330
or has the best suitable lock. In case there is no locked
2331
table that has an equal or higher lock than requested,
2332
we us the closest matching lock to be able to produce an error
2333
message about wrong lock mode on the table. The best_table
2334
is changed if bd < 0 <= d or bd < d < 0 or 0 <= d < bd.
2336
distance < 0 - No suitable lock found
2337
distance > 0 - we have lock mode higher then we require
2338
distance == 0 - we have lock mode exactly which we need
2340
if ((best_distance < 0 && distance > best_distance) || (distance >= 0 && distance < best_distance))
2342
best_distance= distance;
2344
if (best_distance == 0 && !check_if_used)
2347
If we have found perfect match and we don't need to check that
2348
table is not used by one of calling statements (assuming that
2349
we are inside of function or trigger) we can finish iterating
2350
through open tables list.
2361
table->query_id= thd->query_id;
2362
DBUG_PRINT("info",("Using locked table"));
1227
if (flags & DRIZZLE_OPEN_TEMPORARY_ONLY)
1229
my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->db, table_list->table_name);
1234
If it's the first table from a list of tables used in a query,
1235
remember refresh_version (the version of open_cache state).
1236
If the version changes while we're opening the remaining tables,
1237
we will have to back off, close all the tables opened-so-far,
1238
and try to reopen them.
1240
Note-> refresh_version is currently changed only during FLUSH TABLES.
1244
version= refresh_version;
1246
else if ((version != refresh_version) &&
1247
! (flags & DRIZZLE_LOCK_IGNORE_FLUSH))
1249
/* Someone did a refresh while thread was opening tables */
1257
Before we test the global cache, we test our local session cache.
1261
assert(false); /* Not implemented yet */
2366
No table in the locked tables list. In case of explicit LOCK TABLES
2367
this can happen if a user did not include the able into the list.
2368
In case of pre-locked mode locked tables list is generated automatically,
2369
so we may only end up here if the table did not exist when
2370
locked tables list was created.
2372
my_error(ER_TABLE_NOT_LOCKED, MYF(0), alias);
1288
2431
an implicit "pending locks queue" - see
1289
2432
wait_for_locked_table_names for details.
1291
ppp= get_open_cache().equal_range(key);
1294
for (TableOpenCache::const_iterator iter= ppp.first;
1295
iter != ppp.second; ++iter, table= NULL)
2434
for (table= (TABLE*) hash_first(&open_cache, (uchar*) key, key_length,
2436
table && table->in_use ;
2437
table= (TABLE*) hash_next(&open_cache, (uchar*) key, key_length,
1297
table= (*iter).second;
1299
if (not table->in_use)
2440
DBUG_PRINT("tcache", ("in_use table: '%s'.'%s' 0x%lx", table->s->db.str,
2441
table->s->table_name.str, (long) table));
1302
2443
Here we flush tables marked for flush.
1303
Normally, table->getShare()->version contains the value of
2444
Normally, table->s->version contains the value of
1304
2445
refresh_version from the moment when this table was
1305
2446
(re-)opened and added to the cache.
1306
2447
If since then we did (or just started) FLUSH TABLES
1307
2448
statement, refresh_version has been increased.
1308
For "name-locked" Table instances, table->getShare()->version is set
2449
For "name-locked" TABLE instances, table->s->version is set
1309
2450
to 0 (see lock_table_name for details).
1310
2451
In case there is a pending FLUSH TABLES or a name lock, we
1311
2452
need to back off and re-start opening tables.
1312
2453
If we do not back off now, we may dead lock in case of lock
1313
2454
order mismatch with some other thread:
1314
c1-> name lock t1; -- sort of exclusive lock
1315
c2-> open t2; -- sort of shared lock
1316
c1-> name lock t2; -- blocks
1317
c2-> open t1; -- blocks
2455
c1: name lock t1; -- sort of exclusive lock
2456
c2: open t2; -- sort of shared lock
2457
c1: name lock t2; -- blocks
2458
c2: open t1; -- blocks
1319
2460
if (table->needs_reopen_or_name_lock())
1321
if (flags & DRIZZLE_LOCK_IGNORE_FLUSH)
2463
("Found table '%s.%s' with different refresh version",
2464
table_list->db, table_list->table_name));
2466
if (flags & MYSQL_LOCK_IGNORE_FLUSH)
1323
2468
/* Force close at once after usage */
1324
version= table->getShare()->getVersion();
2469
thd->version= table->s->version;
1328
2473
/* Avoid self-deadlocks by detecting self-dependencies. */
1329
if (table->open_placeholder && table->in_use == this)
2474
if (table->open_placeholder && table->in_use == thd)
1332
my_error(ER_UPDATE_TABLE_USED, MYF(0), table->getMutableShare()->getTableName());
2476
VOID(pthread_mutex_unlock(&LOCK_open));
2477
my_error(ER_UPDATE_TABLE_USED, MYF(0), table->s->table_name.str);
1337
2482
Back off, part 1: mark the table as "unused" for the
1338
2483
purpose of name-locking by setting table->db_stat to 0. Do
1339
2484
that only for the tables in this thread that have an old
1340
table->getShare()->version (this is an optimization (?)).
2485
table->s->version (this is an optimization (?)).
1341
2486
table->db_stat == 0 signals wait_for_locked_table_names
1342
2487
that the tables in question are not used any more. See
1343
2488
table_is_used call for details.
2490
Notice that HANDLER tables were already taken care of by
2491
the earlier call to mysql_ha_flush() in this same critical
1345
close_old_data_files(false, false);
2494
close_old_data_files(thd,thd->open_tables,0,0);
1348
2496
Back-off part 2: try to avoid "busy waiting" on the table:
1349
2497
if the table is in use by some other thread, we suspend
1350
2498
and wait till the operation is complete: when any
1351
operation that juggles with table->getShare()->version completes,
2499
operation that juggles with table->s->version completes,
1352
2500
it broadcasts COND_refresh condition variable.
1353
2501
If 'old' table we met is in use by current thread we return
1354
2502
without waiting since in this situation it's this thread
1355
2503
which is responsible for broadcasting on COND_refresh
1356
(and this was done already in Session::close_old_data_files()).
2504
(and this was done already in close_old_data_files()).
1357
2505
Good example of such situation is when we have statement
1358
2506
that needs two instances of table and FLUSH TABLES comes
1359
2507
after we open first instance but before we open second
1362
if (table->in_use != this)
2510
if (table->in_use != thd)
1364
2512
/* wait_for_conditionwill unlock LOCK_open for us */
1365
wait_for_condition(LOCK_open, COND_refresh);
2513
wait_for_condition(thd, &LOCK_open, &COND_refresh);
2517
VOID(pthread_mutex_unlock(&LOCK_open));
1372
2520
There is a refresh in progress for this table.
1373
2521
Signal the caller that it has to try again.
1382
unused_tables.unlink(table);
1383
table->in_use= this;
2530
DBUG_PRINT("tcache", ("unused table: '%s'.'%s' 0x%lx", table->s->db.str,
2531
table->s->table_name.str, (long) table));
2532
/* Unlink the table from "unused_tables" list. */
2533
if (table == unused_tables)
2535
unused_tables=unused_tables->next; // Remove from link
2536
if (table == unused_tables)
2539
table->prev->next=table->next; /* Remove from unused list */
2540
table->next->prev=table->prev;
1387
/* Insert a new Table instance into the open cache */
2545
/* Insert a new TABLE instance into the open cache */
2547
DBUG_PRINT("tcache", ("opening new table"));
1389
2548
/* Free cache if too big */
1390
unused_tables.cull();
2549
while (open_cache.records > table_cache_size && unused_tables)
2550
VOID(hash_delete(&open_cache,(uchar*) unused_tables)); /* purecov: tested */
1392
if (table_list->isCreate())
2552
if (table_list->create)
1394
TableIdentifier lock_table_identifier(table_list->db, table_list->table_name, message::Table::STANDARD);
1396
if (not plugin::StorageEngine::doesTableExist(*this, lock_table_identifier))
2556
if (check_if_table_exists(thd, table_list, &exists))
2558
VOID(pthread_mutex_unlock(&LOCK_open));
1399
2565
Table to be created, so we need to create placeholder in table-cache.
1401
if (!(table= table_cache_insert_placeholder(table_list->db, table_list->table_name)))
2567
if (!(table= table_cache_insert_placeholder(thd, key, key_length)))
2569
VOID(pthread_mutex_unlock(&LOCK_open));
1407
2573
Link placeholder to the open tables list so it will be automatically
1408
2574
removed once tables are closed. Also mark it so it won't be ignored
1409
2575
by other trying to take name-lock.
1411
table->open_placeholder= true;
1412
table->setNext(open_tables);
2577
table->open_placeholder= 1;
2578
table->next= thd->open_tables;
2579
thd->open_tables= table;
2580
VOID(pthread_mutex_unlock(&LOCK_open));
1418
2583
/* Table exists. Let us try to open it. */
1421
2586
/* make a new table */
2587
if (!(table=(TABLE*) my_malloc(sizeof(*table),MYF(MY_WME))))
2589
VOID(pthread_mutex_unlock(&LOCK_open));
1429
error= open_unireg_entry(this, table, alias, identifier);
1436
(void)add_table(table);
2593
error= open_unireg_entry(thd, table, table_list, alias, key, key_length,
2594
mem_root, (flags & OPEN_VIEW_NO_PARSE));
2595
/* Combine the follow two */
2598
my_free((uchar*)table, MYF(0));
2599
VOID(pthread_mutex_unlock(&LOCK_open));
2604
my_free((uchar*)table, MYF(0));
2605
VOID(pthread_mutex_unlock(&LOCK_open));
2606
DBUG_RETURN(0); // VIEW
2608
DBUG_PRINT("info", ("inserting table '%s'.'%s' 0x%lx into the cache",
2609
table->s->db.str, table->s->table_name.str,
2611
VOID(my_hash_insert(&open_cache,(uchar*) table));
2614
check_unused(); // Debugging call
2616
VOID(pthread_mutex_unlock(&LOCK_open));
1442
table->setNext(open_tables); /* Link into simple list */
2619
table->next=thd->open_tables; /* Link into simple list */
2620
thd->open_tables=table;
1445
table->reginfo.lock_type= TL_READ; /* Assume read */
1448
assert(table->getShare()->getTableCount() > 0 || table->getShare()->getType() != message::Table::STANDARD);
1450
if (lex->need_correct_ident())
2622
table->reginfo.lock_type=TL_READ; /* Assume read */
2625
DBUG_ASSERT(table->s->ref_count > 0 || table->s->tmp_table != NO_TMP_TABLE);
2627
if (thd->lex->need_correct_ident())
1451
2628
table->alias_name_used= my_strcasecmp(table_alias_charset,
1452
table->getMutableShare()->getTableName(), alias);
2629
table->s->table_name.str, alias);
1453
2630
/* Fix alias if table name changes */
1454
if (strcmp(table->getAlias(), alias))
2631
if (strcmp(table->alias, alias))
1456
uint32_t length=(uint32_t) strlen(alias)+1;
1457
table->alias= (char*) realloc((char*) table->alias, length);
1458
memcpy((void*) table->alias, alias, length);
2633
uint length=(uint) strlen(alias)+1;
2634
table->alias= (char*) my_realloc((char*) table->alias, length,
2636
memcpy((char*) table->alias, alias, length);
1461
2638
/* These variables are also set in reopen_table() */
1462
table->tablenr= current_tablenr++;
1463
table->used_fields= 0;
1464
table->const_table= 0;
1465
table->null_row= false;
1466
table->maybe_null= false;
1467
table->force_index= false;
2639
table->tablenr=thd->current_tablenr++;
2640
table->used_fields=0;
2641
table->const_table=0;
2642
table->null_row= table->maybe_null= table->force_index= 0;
1468
2643
table->status=STATUS_NO_RECORD;
1469
table->insert_values.clear();
2644
table->insert_values= 0;
2645
table->fulltext_searched= 0;
2646
table->file->ft_handler= 0;
1470
2647
/* Catch wrong handling of the auto_increment_field_not_null. */
1471
assert(!table->auto_increment_field_not_null);
2648
DBUG_ASSERT(!table->auto_increment_field_not_null);
1472
2649
table->auto_increment_field_not_null= false;
1473
2650
if (table->timestamp_field)
1475
2651
table->timestamp_field_type= table->timestamp_field->get_auto_set_type();
1477
2652
table->pos_in_table_list= table_list;
1478
2653
table->clear_column_bitmaps();
1479
assert(table->key_read == 0);
2654
DBUG_ASSERT(table->key_read == 0);
2659
TABLE *find_locked_table(THD *thd, const char *db,const char *table_name)
2661
char key[MAX_DBKEY_LENGTH];
2662
uint key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
2664
for (TABLE *table=thd->open_tables; table ; table=table->next)
2666
if (table->s->table_cache_key.length == key_length &&
2667
!memcmp(table->s->table_cache_key.str, key, key_length))
1487
2675
Reopen an table because the definition has changed.
1494
The data cursor for the table is already closed and the share is released
1495
The table has a 'dummy' share that mainly contains database and table name.
2682
The data file for the table is already closed and the share is released
2683
The table has a 'dummy' share that mainly contains database and table name.
1499
1 error. The old table object is not changed.
2687
1 error. The old table object is not changed.
1502
bool reopen_table(Table *table)
2690
bool reopen_table(TABLE *table)
1508
TableList table_list;
1509
Session *session= table->in_use;
2696
TABLE_LIST table_list;
2697
THD *thd= table->in_use;
2698
DBUG_ENTER("reopen_table");
2699
DBUG_PRINT("tcache", ("table: '%s'.'%s' 0x%lx", table->s->db.str,
2700
table->s->table_name.str, (long) table));
1511
assert(table->getShare()->ref_count == 0);
1512
assert(!table->sort.io_cache);
2702
DBUG_ASSERT(table->s->ref_count == 0);
2703
DBUG_ASSERT(!table->sort.io_cache);
1514
2705
#ifdef EXTRA_DEBUG
1515
2706
if (table->db_stat)
1516
errmsg_printf(ERRMSG_LVL_ERROR, _("Table %s had a open data Cursor in reopen_table"),
2707
sql_print_error("Table %s had a open data handler in reopen_table",
1519
table_list.db= const_cast<char *>(table->getShare()->getSchemaName());
1520
table_list.table_name= table->getShare()->getTableName();
2710
bzero((char*) &table_list, sizeof(TABLE_LIST));
2711
table_list.db= table->s->db.str;
2712
table_list.table_name= table->s->table_name.str;
1521
2713
table_list.table= table;
1523
if (wait_for_locked_table_names(session, &table_list))
1524
return true; // Thread was killed
2715
if (wait_for_locked_table_names(thd, &table_list))
2716
DBUG_RETURN(1); // Thread was killed
1526
if (open_unireg_entry(session, &tmp, &table_list,
1528
table->getShare()->getCacheKey(),
1529
table->getShare()->getCacheKeySize()))
2718
if (open_unireg_entry(thd, &tmp, &table_list,
2720
table->s->table_cache_key.str,
2721
table->s->table_cache_key.length,
1532
2725
/* This list copies variables set by open_table */
1537
2730
tmp.maybe_null= table->maybe_null;
1538
2731
tmp.status= table->status;
2733
tmp.s->table_map_id= table->s->table_map_id;
1540
2735
/* Get state */
1541
tmp.in_use= session;
1542
2737
tmp.reginfo.lock_type=table->reginfo.lock_type;
1544
2739
/* Replace table in open list */
1545
2740
tmp.next= table->next;
1546
2741
tmp.prev= table->prev;
1549
table->delete_table(true); // close cursor, free everything
2744
VOID(closefrm(table, 1)); // close file, free everything
1552
2747
table->default_column_bitmaps();
1553
table->cursor->change_table_ptr(table, table->s);
2748
table->file->change_table_ptr(table, table->s);
1555
assert(table->alias != 0);
2750
DBUG_ASSERT(table->alias != 0);
1556
2751
for (field=table->field ; *field ; field++)
1558
2753
(*field)->table= (*field)->orig_table= table;
1559
2754
(*field)->table_name= &table->alias;
1561
for (key=0 ; key < table->getShare()->keys ; key++)
2756
for (key=0 ; key < table->s->keys ; key++)
1563
2758
for (part=0 ; part < table->key_info[key].usable_key_parts ; part++)
1564
2759
table->key_info[key].key_part[part].field->table= table;
2762
Do not attach MERGE children here. The children might be reopened
2763
after the parent. Attach children after reopening all tables that
2764
require reopen. See for example reopen_tables().
1567
2767
broadcast_refresh();
1577
Close all instances of a table open by this thread and replace
1578
them with exclusive name-locks.
1580
@param session Thread context
1581
@param db Database name for the table to be closed
1582
@param table_name Name of the table to be closed
1584
@note This function assumes that if we are not under LOCK TABLES,
1585
then there is only one table open and locked. This means that
1586
the function probably has to be adjusted before it can be used
1587
anywhere outside ALTER Table.
1589
@note Must not use TableShare::table_name/db of the table being closed,
1590
the strings are used in a loop even after the share may be freed.
2776
Close all instances of a table open by this thread and replace
2777
them with exclusive name-locks.
2779
@param thd Thread context
2780
@param db Database name for the table to be closed
2781
@param table_name Name of the table to be closed
2783
@note This function assumes that if we are not under LOCK TABLES,
2784
then there is only one table open and locked. This means that
2785
the function probably has to be adjusted before it can be used
2786
anywhere outside ALTER TABLE.
2788
@note Must not use TABLE_SHARE::table_name/db of the table being closed,
2789
the strings are used in a loop even after the share may be freed.
1593
void Session::close_data_files_and_morph_locks(TableIdentifier &identifier)
2792
void close_data_files_and_morph_locks(THD *thd, const char *db,
2793
const char *table_name)
1595
safe_mutex_assert_owner(LOCK_open.native_handle()); /* Adjust locks at the end of ALTER TABLEL */
2796
DBUG_ENTER("close_data_files_and_morph_locks");
2798
safe_mutex_assert_owner(&LOCK_open);
1600
2803
If we are not under LOCK TABLES we should have only one table
1601
2804
open and locked so it makes sense to remove the lock at once.
1603
mysql_unlock_tables(this, lock);
2806
mysql_unlock_tables(thd, thd->lock);
1608
2811
Note that open table list may contain a name-lock placeholder
1609
for target table name if we process ALTER Table ... RENAME.
2812
for target table name if we process ALTER TABLE ... RENAME.
1610
2813
So loop below makes sense even if we are not under LOCK TABLES.
1612
for (Table *table= open_tables; table ; table=table->getNext())
2815
for (table=thd->open_tables; table ; table=table->next)
1614
if (table->getShare()->getCacheKey() == identifier.getKey())
2817
if (!strcmp(table->s->table_name.str, table_name) &&
2818
!strcmp(table->s->db.str, db))
1616
table->open_placeholder= true;
2820
if (thd->locked_tables)
2822
mysql_lock_remove(thd, thd->locked_tables, table, true);
2824
table->open_placeholder= 1;
1617
2825
close_handle_and_leave_table_as_lock(table);
1624
Reopen all tables with closed data files.
1626
@param session Thread context
1627
@param get_locks Should we get locks after reopening tables ?
1628
@param mark_share_as_old Mark share as old to protect from a impending
1631
@note Since this function can't properly handle prelocking and
1632
create placeholders it should be used in very special
1633
situations like FLUSH TABLES or ALTER Table. In general
1634
case one should just repeat open_tables()/lock_tables()
1635
combination when one needs tables to be reopened (for
1636
example see openTablesLock()).
1638
@note One should have lock on LOCK_open when calling this.
1640
@return false in case of success, true - otherwise.
2833
Reopen all tables with closed data files.
2835
@param thd Thread context
2836
@param get_locks Should we get locks after reopening tables ?
2837
@param mark_share_as_old Mark share as old to protect from a impending
2840
@note Since this function can't properly handle prelocking and
2841
create placeholders it should be used in very special
2842
situations like FLUSH TABLES or ALTER TABLE. In general
2843
case one should just repeat open_tables()/lock_tables()
2844
combination when one needs tables to be reopened (for
2845
example see open_and_lock_tables()).
2847
@note One should have lock on LOCK_open when calling this.
2849
@return false in case of success, true - otherwise.
1643
bool Session::reopen_tables(bool get_locks, bool)
2852
bool reopen_tables(THD *thd, bool get_locks, bool mark_share_as_old)
1645
Table *table,*next,**prev;
1646
Table **tables,**tables_ptr; // For locks
2854
TABLE *table,*next,**prev;
2855
TABLE **tables,**tables_ptr; // For locks
1647
2856
bool error=0, not_used;
1648
const uint32_t flags= DRIZZLE_LOCK_NOTIFY_IF_NEED_REOPEN |
1649
DRIZZLE_LOCK_IGNORE_GLOBAL_READ_LOCK |
1650
DRIZZLE_LOCK_IGNORE_FLUSH;
1652
if (open_tables == NULL)
1655
safe_mutex_assert_owner(LOCK_open.native_handle());
2857
const uint flags= MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN |
2858
MYSQL_LOCK_IGNORE_GLOBAL_READ_LOCK |
2859
MYSQL_LOCK_IGNORE_FLUSH;
2861
DBUG_ENTER("reopen_tables");
2863
if (!thd->open_tables)
2866
safe_mutex_assert_owner(&LOCK_open);
1659
2870
The ptr is checked later
1660
2871
Do not handle locks of MERGE children.
1664
for (table= open_tables; table ; table=table->getNext())
2874
for (table= thd->open_tables; table ; table=table->next)
1668
tables= new Table *[opens];
2876
DBUG_PRINT("tcache", ("open tables to lock: %u", opens));
2877
tables= (TABLE**) my_alloca(sizeof(TABLE*)*opens);
1672
tables= &open_tables;
2880
tables= &thd->open_tables;
1674
2881
tables_ptr =tables;
1677
for (table= open_tables; table ; table=next)
2883
prev= &thd->open_tables;
2884
for (table=thd->open_tables; table ; table=next)
1679
next= table->getNext();
1681
my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->getAlias());
1682
remove_table(table);
2886
uint db_stat=table->db_stat;
2888
if (!tables || (!db_stat && reopen_table(table)))
2890
my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
2891
VOID(hash_delete(&open_cache,(uchar*) table));
2898
/* Do not handle locks of MERGE children. */
2899
if (get_locks && !db_stat)
2900
*tables_ptr++= table; // need new lock on this
2901
if (mark_share_as_old)
2903
table->s->version=0;
2904
table->open_placeholder= 0;
2909
DBUG_PRINT("tcache", ("open tables to lock: %u",
2910
(uint) (tables_ptr - tables)));
1686
2911
if (tables != tables_ptr) // Should we get back old locks
1688
DrizzleLock *local_lock;
1690
2915
We should always get these locks. Anyway, we must not go into
1691
2916
wait_for_tables() as it tries to acquire LOCK_open, which is
1692
2917
already locked.
1694
some_tables_deleted= false;
1696
if ((local_lock= mysql_lock_tables(this, tables, (uint32_t) (tables_ptr - tables),
2919
thd->some_tables_deleted=0;
2920
if ((lock= mysql_lock_tables(thd, tables, (uint) (tables_ptr - tables),
1697
2921
flags, ¬_used)))
2923
thd->locked_tables=mysql_lock_merge(thd->locked_tables,lock);
1925
3166
if (table->db_stat)
1927
3168
table->db_stat= 0;
1928
table->cursor->close();
3169
table->file->close();
1933
3174
/* We already have a name lock, remove copy */
1934
remove_table(table);
3175
VOID(hash_delete(&open_cache,(uchar*) table));
1940
prev= table->getNextPtr();
1945
3186
broadcast_refresh();
3187
if (thd->locked_tables && thd->locked_tables->table_count == 0)
3189
my_free((uchar*) thd->locked_tables,MYF(0));
3190
thd->locked_tables=0;
1952
If we have the table open, which only happens when a LOCK Table has been
3197
If we have the table open, which only happens when a LOCK TABLE has been
1953
3198
done on the table, change the lock type to a lock that will abort all
1954
3199
other threads trying to get the lock.
1957
void abort_locked_tables(Session *session, const drizzled::TableIdentifier &identifier)
3202
void abort_locked_tables(THD *thd,const char *db, const char *table_name)
1960
for (table= session->open_tables; table ; table= table->getNext())
3205
for (table= thd->open_tables; table ; table= table->next)
1962
if (table->getShare()->getCacheKey() == identifier.getKey())
3207
if (!strcmp(table->s->table_name.str, table_name) &&
3208
!strcmp(table->s->db.str, db))
1964
3210
/* If MERGE child, forward lock handling to parent. */
1965
mysql_lock_abort(session, table);
3211
mysql_lock_abort(thd, table, true);
1972
Load a table definition from cursor and open unireg table
3219
Function to assign a new table map id to a table share.
3223
share - Pointer to table share structure
3227
We are intentionally not checking that share->mutex is locked
3228
since this function should only be called when opening a table
3229
share and before it is entered into the table_def_cache (meaning
3230
that it cannot be fetched by another thread, even accidentally).
3235
The LOCK_open mutex is locked
3239
share->table_map_id is given a value that with a high certainty is
3240
not used by any other table (the only case where a table id can be
3241
reused is on wrap-around, which means more than 4 billion table
3242
share opens have been executed while one table was open all the
3245
share->table_map_id is not ~0UL.
3247
void assign_new_table_id(TABLE_SHARE *share)
3249
static ulong last_table_id= ~0UL;
3251
DBUG_ENTER("assign_new_table_id");
3254
DBUG_ASSERT(share != NULL);
3255
safe_mutex_assert_owner(&LOCK_open);
3257
ulong tid= ++last_table_id; /* get next id */
3259
There is one reserved number that cannot be used. Remember to
3260
change this when 6-byte global table id's are introduced.
3262
if (unlikely(tid == ~0UL))
3263
tid= ++last_table_id;
3264
share->table_map_id= tid;
3265
DBUG_PRINT("info", ("table_id=%lu", tid));
3267
/* Post conditions */
3268
DBUG_ASSERT(share->table_map_id != ~0UL);
3274
Load a table definition from file and open unireg table
1976
session Thread handle
1977
entry Store open table definition here
1978
table_list TableList with db, table_name
1980
cache_key Key for share_cache
1981
cache_key_length length of cache_key
3279
entry Store open table definition here
3280
table_list TABLE_LIST with db, table_name & belong_to_view
3282
cache_key Key for share_cache
3283
cache_key_length length of cache_key
3284
mem_root temporary mem_root for parsing
3285
flags the OPEN_VIEW_NO_PARSE flag to be passed to
3286
openfrm()/open_new_frm()
1984
Extra argument for open is taken from session->open_options
1985
One must have a lock on LOCK_open when calling this function
3289
Extra argument for open is taken from thd->open_options
3290
One must have a lock on LOCK_open when calling this function
1992
static int open_unireg_entry(Session *session,
3297
static int open_unireg_entry(THD *thd, TABLE *entry, TABLE_LIST *table_list,
1994
3298
const char *alias,
1995
TableIdentifier &identifier)
3299
char *cache_key, uint cache_key_length,
3300
MEM_ROOT *mem_root, uint flags)
1999
uint32_t discover_retry_count= 0;
3304
uint discover_retry_count= 0;
3305
DBUG_ENTER("open_unireg_entry");
2001
safe_mutex_assert_owner(LOCK_open.native_handle());
3307
safe_mutex_assert_owner(&LOCK_open);
2003
if (not (share= TableShare::getShareCreate(session,
3309
if (!(share= get_table_share_with_create(thd, table_list, cache_key,
3312
table_list->i_s_requested_object,
2008
while ((error= share->open_table_from_share(session,
2011
(uint32_t) (HA_OPEN_KEYFILE |
2015
session->open_options, *entry)))
3316
while ((error= open_table_from_share(thd, share, alias,
3317
(uint) (HA_OPEN_KEYFILE |
3321
(READ_KEYINFO | COMPUTE_TYPES |
3323
thd->open_options, entry, OTM_OPEN)))
2017
3325
if (error == 7) // Table def changed
2019
share->resetVersion(); // Mark share as old
3327
share->version= 0; // Mark share as old
2020
3328
if (discover_retry_count++) // Retry once
2025
3333
Here we should wait until all threads has released the table.
2026
3334
For now we do one retry. This may cause a deadlock if there
2027
3335
is other threads waiting for other tables used by this thread.
2029
3337
Proper fix would be to if the second retry failed:
2030
3338
- Mark that table def changed
2031
3339
- Return from open table
2239
3743
table_list->lock_type= lock_type;
2240
3744
table_list->table= table;
2242
assert(lock == 0); // You must lock everything at once
2243
if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)
2244
if (! (lock= mysql_lock_tables(this, &table_list->table, 1, 0, &refresh)))
3745
if (thd->locked_tables)
3747
if (check_lock_and_start_stmt(thd, table, lock_type))
3752
DBUG_ASSERT(thd->lock == 0); // You must lock everything at once
3753
if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)
3754
if (! (thd->lock= mysql_lock_tables(thd, &table_list->table, 1,
3755
lock_flags, &refresh)))
3760
thd_proc_info(thd, 0);
3766
Open all tables in list, locks them and optionally process derived tables.
3769
open_and_lock_tables_derived()
3770
thd - thread handler
3771
tables - list of tables for open&locking
3772
derived - if to handle derived tables
3779
The lock will automaticaly be freed by close_thread_tables()
3782
There are two convenience functions:
3783
- simple_open_n_lock_tables(thd, tables) without derived handling
3784
- open_and_lock_tables(thd, tables) with derived handling
3785
Both inline functions call open_and_lock_tables_derived() with
3786
the third argument set appropriately.
3789
int open_and_lock_tables_derived(THD *thd, TABLE_LIST *tables, bool derived)
3793
DBUG_ENTER("open_and_lock_tables_derived");
3794
DBUG_PRINT("enter", ("derived handling: %d", derived));
3798
if (open_tables(thd, &tables, &counter, 0))
3801
DBUG_EXECUTE_IF("sleep_open_and_lock_after_open", {
3802
const char *old_proc_info= thd->proc_info;
3803
thd->proc_info= "DBUG sleep";
3805
thd->proc_info= old_proc_info;});
3807
if (!lock_tables(thd, tables, counter, &need_reopen))
3811
close_tables_for_reopen(thd, &tables);
3814
(mysql_handle_derived(thd->lex, &mysql_derived_prepare) ||
3815
(thd->fill_derived_tables() &&
3816
mysql_handle_derived(thd->lex, &mysql_derived_filling))))
3817
DBUG_RETURN(true); /* purecov: inspected */
3823
Open all tables in list and process derived tables
3826
open_normal_and_derived_tables
3827
thd - thread handler
3828
tables - list of tables for open
3829
flags - bitmap of flags to modify how the tables will be open:
3830
MYSQL_LOCK_IGNORE_FLUSH - open table even if someone has
3831
done a flush or namelock on it.
3838
This is to be used on prepare stage when you don't read any
3839
data from the tables.
3842
bool open_normal_and_derived_tables(THD *thd, TABLE_LIST *tables, uint flags)
3845
DBUG_ENTER("open_normal_and_derived_tables");
3846
DBUG_ASSERT(!thd->fill_derived_tables());
3847
if (open_tables(thd, &tables, &counter, flags) ||
3848
mysql_handle_derived(thd->lex, &mysql_derived_prepare))
3849
DBUG_RETURN(true); /* purecov: inspected */
3855
Decide on logging format to use for the statement.
3857
Compute the capabilities vector for the involved storage engines
3858
and mask out the flags for the binary log. Right now, the binlog
3859
flags only include the capabilities of the storage engines, so this
3862
We now have three alternatives that prevent the statement from
3865
1. If there are no capabilities left (all flags are clear) it is
3866
not possible to log the statement at all, so we roll back the
3867
statement and report an error.
3869
2. Statement mode is set, but the capabilities indicate that
3870
statement format is not possible.
3872
3. Row mode is set, but the capabilities indicate that row
3873
format is not possible.
3875
4. Statement is unsafe, but the capabilities indicate that row
3876
format is not possible.
3878
If we are in MIXED mode, we then decide what logging format to use:
3880
1. If the statement is unsafe, row-based logging is used.
3882
2. If statement-based logging is not possible, row-based logging is
3885
3. Otherwise, statement-based logging is used.
3887
@param thd Client thread
3888
@param tables Tables involved in the query
3891
int decide_logging_format(THD *thd, TABLE_LIST *tables)
3893
if (mysql_bin_log.is_open() && (thd->options & OPTION_BIN_LOG))
3895
handler::Table_flags flags_some_set= handler::Table_flags();
3896
handler::Table_flags flags_all_set= ~handler::Table_flags();
3897
my_bool multi_engine= false;
3898
void* prev_ht= NULL;
3899
for (TABLE_LIST *table= tables; table; table= table->next_global)
3901
if (!table->placeholder() && table->lock_type >= TL_WRITE_ALLOW_WRITE)
3903
ulonglong const flags= table->table->file->ha_table_flags();
3904
DBUG_PRINT("info", ("table: %s; ha_table_flags: %s%s",
3906
FLAGSTR(flags, HA_BINLOG_STMT_CAPABLE),
3907
FLAGSTR(flags, HA_BINLOG_ROW_CAPABLE)));
3908
if (prev_ht && prev_ht != table->table->file->ht)
3910
prev_ht= table->table->file->ht;
3911
flags_all_set &= flags;
3912
flags_some_set |= flags;
3916
DBUG_PRINT("info", ("flags_all_set: %s%s",
3917
FLAGSTR(flags_all_set, HA_BINLOG_STMT_CAPABLE),
3918
FLAGSTR(flags_all_set, HA_BINLOG_ROW_CAPABLE)));
3919
DBUG_PRINT("info", ("flags_some_set: %s%s",
3920
FLAGSTR(flags_some_set, HA_BINLOG_STMT_CAPABLE),
3921
FLAGSTR(flags_some_set, HA_BINLOG_ROW_CAPABLE)));
3922
DBUG_PRINT("info", ("thd->variables.binlog_format: %ld",
3923
thd->variables.binlog_format));
3924
DBUG_PRINT("info", ("multi_engine: %s",
3925
multi_engine ? "true" : "false"));
3928
if (flags_all_set == 0)
3930
my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
3931
"Statement cannot be logged to the binary log in"
3932
" row-based nor statement-based format");
3934
else if (thd->variables.binlog_format == BINLOG_FORMAT_STMT &&
3935
(flags_all_set & HA_BINLOG_STMT_CAPABLE) == 0)
3937
my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
3938
"Statement-based format required for this statement,"
3939
" but not allowed by this combination of engines");
3941
else if ((thd->variables.binlog_format == BINLOG_FORMAT_ROW ||
3942
thd->lex->is_stmt_unsafe()) &&
3943
(flags_all_set & HA_BINLOG_ROW_CAPABLE) == 0)
3945
my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
3946
"Row-based format required for this statement,"
3947
" but not allowed by this combination of engines");
3951
If more than one engine is involved in the statement and at
3952
least one is doing it's own logging (is *self-logging*), the
3953
statement cannot be logged atomically, so we generate an error
3954
rather than allowing the binlog to become corrupt.
3957
(flags_some_set & HA_HAS_OWN_BINLOGGING))
3959
error= ER_BINLOG_LOGGING_IMPOSSIBLE;
3960
my_error(error, MYF(0),
3961
"Statement cannot be written atomically since more"
3962
" than one engine involved and at least one engine"
3963
" is self-logging");
3966
DBUG_PRINT("info", ("error: %d", error));
3972
We switch to row-based format if we are in mixed mode and one of
3973
the following are true:
3975
1. If the statement is unsafe
3976
2. If statement format cannot be used
3978
Observe that point to cannot be decided before the tables
3979
involved in a statement has been checked, i.e., we cannot put
3980
this code in reset_current_stmt_binlog_row_based(), it has to be
3983
if (thd->lex->is_stmt_unsafe() ||
3984
(flags_all_set & HA_BINLOG_STMT_CAPABLE) == 0)
3986
thd->set_current_stmt_binlog_row_based_if_mixed();
2254
3994
Lock all tables in list
2258
session Thread Cursor
2259
tables Tables to lock
2260
count Number of opened tables
2261
need_reopen Out parameter which if true indicates that some
2262
tables were dropped or altered during this call
2263
and therefore invoker should reopen tables and
2264
try to lock them once again (in this case
2265
lock_tables() will also return error).
3999
tables Tables to lock
4000
count Number of opened tables
4001
need_reopen Out parameter which if true indicates that some
4002
tables were dropped or altered during this call
4003
and therefore invoker should reopen tables and
4004
try to lock them once again (in this case
4005
lock_tables() will also return error).
2268
You can't call lock_tables twice, as this would break the dead-lock-free
2269
handling thr_lock gives us. You most always get all needed locks at
4008
You can't call lock_tables twice, as this would break the dead-lock-free
4009
handling thr_lock gives us. You most always get all needed locks at
2272
If query for which we are calling this function marked as requring
2273
prelocking, this function will do implicit LOCK TABLES and change
2274
session::prelocked_mode accordingly.
4012
If query for which we are calling this function marked as requring
4013
prelocking, this function will do implicit LOCK TABLES and change
4014
thd::prelocked_mode accordingly.
2281
int Session::lock_tables(TableList *tables, uint32_t count, bool *need_reopen)
4021
int lock_tables(THD *thd, TABLE_LIST *tables, uint count, bool *need_reopen)
2284
Session *session= this;
4025
DBUG_ENTER("lock_tables");
2287
4027
We can't meet statement requiring prelocking if we already
2288
4028
in prelocked mode.
2290
4030
*need_reopen= false;
2295
assert(session->lock == 0); // You must lock everything at once
2296
Table **start,**ptr;
2297
uint32_t lock_flag= DRIZZLE_LOCK_NOTIFY_IF_NEED_REOPEN;
2299
if (!(ptr=start=(Table**) session->alloc(sizeof(Table*)*count)))
2301
for (table= tables; table; table= table->next_global)
2303
if (!table->placeholder())
2304
*(ptr++)= table->table;
2307
if (!(session->lock= mysql_lock_tables(session, start, (uint32_t) (ptr - start),
2308
lock_flag, need_reopen)))
4033
DBUG_RETURN(decide_logging_format(thd, tables));
4035
if (!thd->locked_tables)
4037
DBUG_ASSERT(thd->lock == 0); // You must lock everything at once
4038
TABLE **start,**ptr;
4039
uint lock_flag= MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN;
4041
if (!(ptr=start=(TABLE**) thd->alloc(sizeof(TABLE*)*count)))
4043
for (table= tables; table; table= table->next_global)
4045
if (!table->placeholder())
4046
*(ptr++)= table->table;
4049
if (!(thd->lock= mysql_lock_tables(thd, start, (uint) (ptr - start),
4050
lock_flag, need_reopen)))
4057
TABLE_LIST *first_not_own= thd->lex->first_not_own_table();
4059
When open_and_lock_tables() is called for a single table out of
4060
a table list, the 'next_global' chain is temporarily broken. We
4061
may not find 'first_not_own' before the end of the "list".
4062
Look for example at those places where open_n_lock_single_table()
4063
is called. That function implements the temporary breaking of
4064
a table list for opening a single table.
4067
table && table != first_not_own;
4068
table= table->next_global)
4070
if (!table->placeholder() &&
4071
check_lock_and_start_stmt(thd, table->table, table->lock_type))
4078
DBUG_RETURN(decide_logging_format(thd, tables));
4083
Prepare statement for reopening of tables and recalculation of set of
4087
close_tables_for_reopen()
4088
thd in Thread context
4089
tables in/out List of tables which we were trying to open and lock
4093
void close_tables_for_reopen(THD *thd, TABLE_LIST **tables)
4096
If table list consists only from tables from prelocking set, table list
4097
for new attempt should be empty, so we have to update list's root pointer.
4099
if (thd->lex->first_not_own_table() == *tables)
4101
thd->lex->chop_off_not_own_tables();
4102
for (TABLE_LIST *tmp= *tables; tmp; tmp= tmp->next_global)
4104
close_thread_tables(thd);
2318
4109
Open a single table without table caching and don't set it in open_list
2321
open_temporary_table()
2322
session Thread object
2323
path Path (without .frm)
2325
table_name Table name
2326
link_in_list 1 if table should be linked into session->temporary_tables
2329
Used by alter_table to open a temporary table and when creating
2330
a temporary table with CREATE TEMPORARY ...
4112
open_temporary_table()
4114
path Path (without .frm)
4116
table_name Table name
4117
link_in_list 1 if table should be linked into thd->temporary_tables
4120
Used by alter_table to open a temporary table and when creating
4121
a temporary table with CREATE TEMPORARY ...
2337
Table *Session::open_temporary_table(TableIdentifier &identifier,
4128
TABLE *open_temporary_table(THD *thd, const char *path, const char *db,
4129
const char *table_name, bool link_in_list,
4130
open_table_mode open_mode)
2342
assert(identifier.isTmp());
2343
share= new TableShare(identifier.getType(),
2345
const_cast<char *>(identifier.getPath().c_str()), static_cast<uint32_t>(identifier.getPath().length()));
2348
Table *new_tmp_table= new Table;
2349
if (not new_tmp_table)
2353
First open the share, and then open the table from the share we just opened.
2355
if (share->open_table_def(*this, identifier) ||
2356
share->open_table_from_share(this, identifier, identifier.getTableName().c_str(),
2357
(uint32_t) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
4134
char cache_key[MAX_DBKEY_LENGTH], *saved_cache_key, *tmp_path;
4136
TABLE_LIST table_list;
4137
DBUG_ENTER("open_temporary_table");
4139
("table: '%s'.'%s' path: '%s' server_id: %u "
4140
"pseudo_thread_id: %lu",
4141
db, table_name, path,
4142
(uint) thd->server_id, (ulong) thd->variables.pseudo_thread_id));
4144
table_list.db= (char*) db;
4145
table_list.table_name= (char*) table_name;
4146
/* Create the cache_key for temporary tables */
4147
key_length= create_table_def_key(thd, cache_key, &table_list, 1);
4149
if (!(tmp_table= (TABLE*) my_malloc(sizeof(*tmp_table) + sizeof(*share) +
4150
strlen(path)+1 + key_length,
4152
DBUG_RETURN(0); /* purecov: inspected */
4154
share= (TABLE_SHARE*) (tmp_table+1);
4155
tmp_path= (char*) (share+1);
4156
saved_cache_key= strmov(tmp_path, path)+1;
4157
memcpy(saved_cache_key, cache_key, key_length);
4159
init_tmp_table_share(thd, share, saved_cache_key, key_length,
4160
strend(saved_cache_key)+1, tmp_path);
4162
if (open_table_def(thd, share, 0) ||
4163
open_table_from_share(thd, share, table_name,
4164
(open_mode == OTM_ALTER) ? 0 :
4165
(uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
4167
(open_mode == OTM_ALTER) ?
4168
(READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD |
4170
: (READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD),
2359
4171
ha_open_options,
4172
tmp_table, open_mode))
2362
4174
/* No need to lock share->mutex as this is not needed for tmp tables */
2364
delete new_tmp_table;
2369
new_tmp_table->reginfo.lock_type= TL_WRITE; // Simulate locked
4175
free_table_share(share);
4176
my_free((char*) tmp_table,MYF(0));
4180
tmp_table->reginfo.lock_type= TL_WRITE; // Simulate locked
4181
if (open_mode == OTM_ALTER)
4184
Temporary table has been created with frm_only
4185
and has not been created in any storage engine
4187
share->tmp_table= TMP_TABLE_FRM_FILE_ONLY;
4190
share->tmp_table= (tmp_table->file->has_transactions() ?
4191
TRANSACTIONAL_TMP_TABLE : NON_TRANSACTIONAL_TMP_TABLE);
2371
4193
if (link_in_list)
2373
4195
/* growing temp list at the head */
2374
new_tmp_table->setNext(this->temporary_tables);
2375
if (new_tmp_table->getNext())
2377
new_tmp_table->getNext()->setPrev(new_tmp_table);
2379
this->temporary_tables= new_tmp_table;
2380
this->temporary_tables->setPrev(0);
2382
new_tmp_table->pos_in_table_list= 0;
2384
return new_tmp_table;
4196
tmp_table->next= thd->temporary_tables;
4197
if (tmp_table->next)
4198
tmp_table->next->prev= tmp_table;
4199
thd->temporary_tables= tmp_table;
4200
thd->temporary_tables->prev= 0;
4201
if (thd->slave_thread)
4202
slave_open_temp_tables++;
4204
tmp_table->pos_in_table_list= 0;
4205
DBUG_PRINT("tmptable", ("opened table: '%s'.'%s' 0x%lx", tmp_table->s->db.str,
4206
tmp_table->s->table_name.str, (long) tmp_table));
4207
DBUG_RETURN(tmp_table);
4211
bool rm_temporary_table(handlerton *base, char *path, bool frm_only)
4216
DBUG_ENTER("rm_temporary_table");
4218
strmov(ext= strend(path), reg_ext);
4219
if (my_delete(path,MYF(0)))
4220
error=1; /* purecov: inspected */
4221
*ext= 0; // remove extension
4222
file= get_new_handler((TABLE_SHARE*) 0, current_thd->mem_root, base);
4223
if (!frm_only && file && file->ha_delete_table(path))
4226
sql_print_warning("Could not remove temporary table: '%s', error: %d",
2388
4234
/*****************************************************************************
2389
* The following find_field_in_XXX procedures implement the core of the
2390
* name resolution functionality. The entry point to resolve a column name in a
2391
* list of tables is 'find_field_in_tables'. It calls 'find_field_in_table_ref'
2392
* for each table reference. In turn, depending on the type of table reference,
2393
* 'find_field_in_table_ref' calls one of the 'find_field_in_XXX' procedures
2394
* below specific for the type of table reference.
2395
******************************************************************************/
4235
* The following find_field_in_XXX procedures implement the core of the
4236
* name resolution functionality. The entry point to resolve a column name in a
4237
* list of tables is 'find_field_in_tables'. It calls 'find_field_in_table_ref'
4238
* for each table reference. In turn, depending on the type of table reference,
4239
* 'find_field_in_table_ref' calls one of the 'find_field_in_XXX' procedures
4240
* below specific for the type of table reference.
4241
******************************************************************************/
2397
4243
/* Special Field pointers as return values of find_field_in_XXX functions. */
2398
4244
Field *not_found_field= (Field*) 0x1;
2399
Field *view_ref_found= (Field*) 0x2;
2401
static void update_field_dependencies(Session *session, Field *field, Table *table)
4245
Field *view_ref_found= (Field*) 0x2;
4247
#define WRONG_GRANT (Field*) -1
4249
static void update_field_dependencies(THD *thd, Field *field, TABLE *table)
2403
if (session->mark_used_columns != MARK_COLUMNS_NONE)
4251
DBUG_ENTER("update_field_dependencies");
4252
if (thd->mark_used_columns != MARK_COLUMNS_NONE)
2405
MyBitmap *current_bitmap, *other_bitmap;
4254
MY_BITMAP *current_bitmap, *other_bitmap;
2408
4257
We always want to register the used keys, as the column bitmap may have
2409
4258
been set for all fields (for example for view).
2412
table->covering_keys&= field->part_of_key;
2413
table->merge_keys|= field->part_of_key;
2415
if (session->mark_used_columns == MARK_COLUMNS_READ)
4261
table->covering_keys.intersect(field->part_of_key);
4262
table->merge_keys.merge(field->part_of_key);
4264
if (thd->mark_used_columns == MARK_COLUMNS_READ)
2417
4266
current_bitmap= table->read_set;
2418
4267
other_bitmap= table->write_set;
added
removed
sql/sql_base.cc
