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();
67
close_cached_tables(NULL, NULL, false, false, false);
68
if (!open_cache.records) // Safety first
69
hash_free(&open_cache);
74
uint cached_open_tables(void)
76
return open_cache.records;
80
Create a table cache key
83
create_table_def_key()
85
key Create key here (must be of size MAX_DBKEY_LENGTH)
86
table_list Table definition
87
tmp_table Set if table is a tmp table
90
The table cache_key is created from:
94
if the table is a tmp table, we add the following to make each tmp table
97
4 bytes for master thread id
98
4 bytes pseudo thread id
104
uint create_table_def_key(THD *thd, char *key, TABLE_LIST *table_list,
107
uint key_length= (uint) (strmov(strmov(key, table_list->db)+1,
108
table_list->table_name)-key)+1;
111
int4store(key + key_length, thd->server_id);
112
int4store(key + key_length + 4, thd->variables.pseudo_thread_id);
113
key_length+= TMP_TABLE_KEY_EXTRA;
120
/*****************************************************************************
121
Functions to handle table definition cach (TABLE_SHARE)
122
*****************************************************************************/
124
extern "C" uchar *table_def_key(const uchar *record, size_t *length,
125
my_bool not_used __attribute__((unused)))
127
TABLE_SHARE *entry=(TABLE_SHARE*) record;
128
*length= entry->table_cache_key.length;
129
return (uchar*) entry->table_cache_key.str;
133
static void table_def_free_entry(TABLE_SHARE *share)
137
/* remove from old_unused_share list */
138
pthread_mutex_lock(&LOCK_table_share);
139
*share->prev= share->next;
140
share->next->prev= share->prev;
141
pthread_mutex_unlock(&LOCK_table_share);
143
free_table_share(share);
148
bool table_def_init(void)
151
pthread_mutex_init(&LOCK_table_share, MY_MUTEX_INIT_FAST);
152
oldest_unused_share= &end_of_unused_share;
153
end_of_unused_share.prev= &oldest_unused_share;
155
return hash_init(&table_def_cache, &my_charset_bin, table_def_size,
157
(hash_free_key) table_def_free_entry, 0) != 0;
161
void table_def_free(void)
163
if (table_def_inited)
166
pthread_mutex_destroy(&LOCK_table_share);
167
hash_free(&table_def_cache);
173
uint cached_table_definitions(void)
175
return table_def_cache.records;
180
Get TABLE_SHARE for a table.
184
table_list Table that should be opened
186
key_length Length of key
187
db_flags Flags to open_table_def():
189
error out: Error code from open_table_def()
192
Get a table definition from the table definition cache.
193
If it doesn't exist, create a new from the table definition file.
196
We must have wrlock on LOCK_open when we come here
197
(To be changed later)
204
TABLE_SHARE *get_table_share(THD *thd, TABLE_LIST *table_list, char *key,
205
uint key_length, uint db_flags, int *error)
211
/* Read table definition from cache */
212
if ((share= (TABLE_SHARE*) hash_search(&table_def_cache,(uchar*) key,
216
if (!(share= alloc_table_share(table_list, key, key_length)))
222
Lock mutex to be able to read table definition from file without
225
(void) pthread_mutex_lock(&share->mutex);
228
We assign a new table id under the protection of the LOCK_open and
229
the share's own mutex. We do this insted of creating a new mutex
230
and using it for the sole purpose of serializing accesses to a
231
static variable, we assign the table id here. We assign it to the
232
share before inserting it into the table_def_cache to be really
233
sure that it cannot be read from the cache without having a table
236
CAVEAT. This means that the table cannot be used for
237
binlogging/replication purposes, unless get_table_share() has been
238
called directly or indirectly.
240
assign_new_table_id(share);
242
if (my_hash_insert(&table_def_cache, (uchar*) share))
244
free_table_share(share);
245
return(0); // return error
247
if (open_table_def(thd, share, db_flags))
249
*error= share->error;
250
(void) hash_delete(&table_def_cache, (uchar*) share);
253
share->ref_count++; // Mark in use
254
(void) pthread_mutex_unlock(&share->mutex);
259
We found an existing table definition. Return it if we didn't get
260
an error when reading the table definition from file.
263
/* We must do a lock to ensure that the structure is initialized */
264
(void) pthread_mutex_lock(&share->mutex);
267
/* Table definition contained an error */
268
open_table_error(share, share->error, share->open_errno, share->errarg);
269
(void) pthread_mutex_unlock(&share->mutex);
273
if (!share->ref_count++ && share->prev)
276
Share was not used before and it was in the old_unused_share list
277
Unlink share from this list
279
pthread_mutex_lock(&LOCK_table_share);
280
*share->prev= share->next;
281
share->next->prev= share->prev;
284
pthread_mutex_unlock(&LOCK_table_share);
286
(void) pthread_mutex_unlock(&share->mutex);
288
/* Free cache if too big */
289
while (table_def_cache.records > table_def_size &&
290
oldest_unused_share->next)
292
pthread_mutex_lock(&oldest_unused_share->mutex);
293
VOID(hash_delete(&table_def_cache, (uchar*) oldest_unused_share));
301
Get a table share. If it didn't exist, try creating it from engine
303
For arguments and return values, see get_table_from_share()
307
*get_table_share_with_create(THD *thd, TABLE_LIST *table_list,
308
char *key, uint key_length,
309
uint db_flags, int *error)
314
share= get_table_share(thd, table_list, key, key_length, db_flags, error);
316
If share is not NULL, we found an existing share.
318
If share is NULL, and there is no error, we're inside
319
pre-locking, which silences 'ER_NO_SUCH_TABLE' errors
320
with the intention to silently drop non-existing tables
321
from the pre-locking list. In this case we still need to try
322
auto-discover before returning a NULL share.
324
If share is NULL and the error is ER_NO_SUCH_TABLE, this is
325
the same as above, only that the error was not silenced by
326
pre-locking. Once again, we need to try to auto-discover
329
Finally, if share is still NULL, it's a real error and we need
332
@todo Rework alternative ways to deal with ER_NO_SUCH TABLE.
334
if (share || (thd->is_error() && (thd->main_da.sql_errno() != ER_NO_SUCH_TABLE)))
338
/* Table didn't exist. Check if some engine can provide it */
339
if ((tmp= ha_create_table_from_engine(thd, table_list->db,
340
table_list->table_name)) < 0)
343
No such table in any engine.
344
Hide "Table doesn't exist" errors if the table belongs to a view.
345
The check for thd->is_error() is necessary to not push an
346
unwanted error in case of pre-locking, which silences
347
"no such table" errors.
348
@todo Rework the alternative ways to deal with ER_NO_SUCH TABLE.
350
if (thd->is_error() && table_list->belong_to_view)
353
my_error(ER_VIEW_INVALID, MYF(0), "", "");
359
/* Give right error message */
361
my_printf_error(ER_UNKNOWN_ERROR,
362
"Failed to open '%-.64s', error while "
363
"unpacking from engine",
364
MYF(0), table_list->table_name);
367
/* Table existed in engine. Let's open it */
368
mysql_reset_errors(thd, 1); // Clear warnings
369
thd->clear_error(); // Clear error message
370
return(get_table_share(thd, table_list, key, key_length,
376
Mark that we are not using table share anymore.
379
release_table_share()
381
release_type How the release should be done:
383
- Release without checking
384
RELEASE_WAIT_FOR_DROP
385
- Don't return until we get a signal that the
386
table is deleted or the thread is killed.
389
If ref_count goes to zero and (we have done a refresh or if we have
390
already too many open table shares) then delete the definition.
392
If type == RELEASE_WAIT_FOR_DROP then don't return until we get a signal
393
that the table is deleted or the thread is killed.
396
void release_table_share(TABLE_SHARE *share,
397
enum release_type type __attribute__((__unused__)))
399
bool to_be_deleted= 0;
401
safe_mutex_assert_owner(&LOCK_open);
403
pthread_mutex_lock(&share->mutex);
404
if (!--share->ref_count)
406
if (share->version != refresh_version)
410
/* Link share last in used_table_share list */
411
assert(share->next == 0);
412
pthread_mutex_lock(&LOCK_table_share);
413
share->prev= end_of_unused_share.prev;
414
*end_of_unused_share.prev= share;
415
end_of_unused_share.prev= &share->next;
416
share->next= &end_of_unused_share;
417
pthread_mutex_unlock(&LOCK_table_share);
419
to_be_deleted= (table_def_cache.records > table_def_size);
425
hash_delete(&table_def_cache, (uchar*) share);
428
pthread_mutex_unlock(&share->mutex);
434
Check if table definition exits in cache
437
get_cached_table_share()
439
table_name Table name
443
# TABLE_SHARE for table
446
TABLE_SHARE *get_cached_table_share(const char *db, const char *table_name)
448
char key[NAME_LEN*2+2];
449
TABLE_LIST table_list;
451
safe_mutex_assert_owner(&LOCK_open);
453
table_list.db= (char*) db;
454
table_list.table_name= (char*) table_name;
455
key_length= create_table_def_key((THD*) 0, key, &table_list, 0);
456
return (TABLE_SHARE*) hash_search(&table_def_cache,(uchar*) key, key_length);
461
Close file handle, but leave the table in the table cache
464
close_handle_and_leave_table_as_lock()
468
By leaving the table in the table cache, it disallows any other thread
471
thd->killed will be set if we run out of memory
473
If closing a MERGE child, the calling function has to take care for
474
closing the parent too, if necessary.
478
void close_handle_and_leave_table_as_lock(TABLE *table)
480
TABLE_SHARE *share, *old_share= table->s;
482
MEM_ROOT *mem_root= &table->mem_root;
255
484
assert(table->db_stat);
256
assert(table->getShare()->getType() == message::Table::STANDARD);
259
487
Make a local copy of the table share and free the current one.
260
488
This has to be done to ensure that the table share is removed from
261
489
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());
491
if (multi_alloc_root(mem_root,
492
&share, sizeof(*share),
493
&key_buff, old_share->table_cache_key.length,
496
bzero((char*) share, sizeof(*share));
497
share->set_table_cache_key(key_buff, old_share->table_cache_key.str,
498
old_share->table_cache_key.length);
499
share->tmp_table= INTERNAL_TMP_TABLE; // for intern_close_table()
502
table->file->close();
503
table->db_stat= 0; // Mark file closed
504
release_table_share(table->s, RELEASE_NORMAL);
506
table->file->change_table_ptr(table, table->s);
514
Create a list for all open tables matching SQL expression
519
wild SQL like expression
522
One gets only a list of tables for which one has any kind of privilege.
523
db and table names are allocated in result struct, so one doesn't need
524
a lock on LOCK_open when traversing the return list.
527
NULL Error (Probably OOM)
528
# Pointer to list of names of open tables.
531
OPEN_TABLE_LIST *list_open_tables(THD *thd __attribute__((__unused__)),
532
const char *db, const char *wild)
535
OPEN_TABLE_LIST **start_list, *open_list;
536
TABLE_LIST table_list;
538
VOID(pthread_mutex_lock(&LOCK_open));
539
bzero((char*) &table_list,sizeof(table_list));
540
start_list= &open_list;
543
for (uint idx=0 ; result == 0 && idx < open_cache.records; idx++)
545
OPEN_TABLE_LIST *table;
546
TABLE *entry=(TABLE*) hash_element(&open_cache,idx);
547
TABLE_SHARE *share= entry->s;
549
if (db && my_strcasecmp(system_charset_info, db, share->db.str))
551
if (wild && wild_compare(share->table_name.str, wild, 0))
554
/* Check if user has SELECT privilege for any column in the table */
555
table_list.db= share->db.str;
556
table_list.table_name= share->table_name.str;
558
/* need to check if we haven't already listed it */
559
for (table= open_list ; table ; table=table->next)
561
if (!strcmp(table->table, share->table_name.str) &&
562
!strcmp(table->db, share->db.str))
566
if (entry->locked_by_name)
573
if (!(*start_list = (OPEN_TABLE_LIST *)
574
sql_alloc(sizeof(**start_list)+share->table_cache_key.length)))
576
open_list=0; // Out of memory
579
strmov((*start_list)->table=
580
strmov(((*start_list)->db= (char*) ((*start_list)+1)),
582
share->table_name.str);
583
(*start_list)->in_use= entry->in_use ? 1 : 0;
584
(*start_list)->locked= entry->locked_by_name ? 1 : 0;
585
start_list= &(*start_list)->next;
588
VOID(pthread_mutex_unlock(&LOCK_open));
277
592
/*****************************************************************************
278
593
* Functions to free open table cache
279
594
****************************************************************************/
282
void Table::intern_close_table()
597
void intern_close_table(TABLE *table)
283
598
{ // Free all structures
285
if (cursor) // Not true if name lock
287
delete_table(true); // close cursor
599
free_io_cache(table);
600
if (table->file) // Not true if name lock
601
VOID(closefrm(table, 1)); // close file
292
606
Remove table from the open table cache
296
entry Table to remove
610
table Table to remove
299
We need to have a lock on LOCK_open when calling this
613
We need to have a lock on LOCK_open when calling this
302
void free_cache_entry(Table *table)
616
static void free_cache_entry(TABLE *table)
304
table->intern_close_table();
305
if (not table->in_use)
618
intern_close_table(table);
307
unused_tables.unlink(table);
621
table->next->prev=table->prev; /* remove from used chain */
622
table->prev->next=table->next;
623
if (table == unused_tables)
625
unused_tables=unused_tables->next;
626
if (table == unused_tables)
630
my_free((uchar*) table,MYF(0));
313
634
/* Free resources allocated by filesort() and read_record() */
315
void Table::free_io_cache()
636
void free_io_cache(TABLE *table)
638
if (table->sort.io_cache)
319
close_cached_file(sort.io_cache);
320
delete sort.io_cache;
640
close_cached_file(table->sort.io_cache);
641
my_free((uchar*) table->sort.io_cache,MYF(0));
642
table->sort.io_cache=0;
327
649
Close all tables which aren't in use by any thread
329
@param session Thread context (may be NULL)
651
@param thd Thread context
330
652
@param tables List of tables to remove from the cache
331
653
@param have_lock If LOCK_open is locked
332
654
@param wait_for_refresh Wait for a impending flush
333
655
@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
656
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.
659
@remark THD can be NULL, but then wait_for_refresh must be false
660
and tables must be NULL.
341
bool Session::close_cached_tables(TableList *tables, bool wait_for_refresh, bool wait_for_placeholders)
663
bool close_cached_tables(THD *thd, TABLE_LIST *tables, bool have_lock,
664
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 */
667
assert(thd || (!wait_for_refresh && !tables));
670
VOID(pthread_mutex_lock(&LOCK_open));
350
673
refresh_version++; // Force close of open tables
352
unused_tables.clear();
674
while (unused_tables)
677
if (hash_delete(&open_cache,(uchar*) unused_tables))
678
printf("Warning: Couldn't delete open table from hash\n");
680
VOID(hash_delete(&open_cache,(uchar*) unused_tables));
683
/* Free table shares */
684
while (oldest_unused_share->next)
686
pthread_mutex_lock(&oldest_unused_share->mutex);
687
VOID(hash_delete(&table_def_cache, (uchar*) oldest_unused_share));
354
689
if (wait_for_refresh)
469
798
old locks. This should always succeed (unless some external process
470
799
has removed the tables)
472
result= session->reopen_tables(true, true);
801
thd->in_lock_tables=1;
802
result=reopen_tables(thd,1,1);
803
thd->in_lock_tables=0;
474
804
/* Set version for table */
475
for (Table *table= session->open_tables; table ; table= table->getNext())
805
for (TABLE *table=thd->open_tables; table ; table= table->next)
478
808
Preserve the version (0) of write locked tables so that a impending
479
809
global read lock won't sneak in.
481
811
if (table->reginfo.lock_type < TL_WRITE_ALLOW_WRITE)
482
table->getMutableShare()->refreshVersion();
812
table->s->version= refresh_version;
816
VOID(pthread_mutex_unlock(&LOCK_open));
488
817
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);
819
pthread_mutex_lock(&thd->mysys_var->mutex);
820
thd->mysys_var->current_mutex= 0;
821
thd->mysys_var->current_cond= 0;
822
thd_proc_info(thd, 0);
823
pthread_mutex_unlock(&thd->mysys_var->mutex);
830
Close all tables which match specified connection string or
831
if specified string is NULL, then any table with a connection string.
834
bool close_cached_connection_tables(THD *thd, bool if_wait_for_refresh,
835
LEX_STRING *connection, bool have_lock)
838
TABLE_LIST tmp, *tables= NULL;
842
bzero(&tmp, sizeof(TABLE_LIST));
845
VOID(pthread_mutex_lock(&LOCK_open));
847
for (idx= 0; idx < table_def_cache.records; idx++)
849
TABLE_SHARE *share= (TABLE_SHARE *) hash_element(&table_def_cache, idx);
851
/* Ignore if table is not open or does not have a connect_string */
852
if (!share->connect_string.length || !share->ref_count)
855
/* Compare the connection string */
857
(connection->length > share->connect_string.length ||
858
(connection->length < share->connect_string.length &&
859
(share->connect_string.str[connection->length] != '/' &&
860
share->connect_string.str[connection->length] != '\\')) ||
861
strncasecmp(connection->str, share->connect_string.str,
862
connection->length)))
865
/* close_cached_tables() only uses these elements */
866
tmp.db= share->db.str;
867
tmp.table_name= share->table_name.str;
868
tmp.next_local= tables;
870
tables= (TABLE_LIST *) memdup_root(thd->mem_root, (char*)&tmp,
875
result= close_cached_tables(thd, tables, true, false, false);
878
VOID(pthread_mutex_unlock(&LOCK_open));
880
if (if_wait_for_refresh)
882
pthread_mutex_lock(&thd->mysys_var->mutex);
883
thd->mysys_var->current_mutex= 0;
884
thd->mysys_var->current_cond= 0;
886
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;
894
Mark all temporary tables which were used by the current statement or
895
substatement as free for reuse, but only if the query_id can be cleared.
897
@param thd thread context
899
@remark For temp tables associated with a open SQL HANDLER the query_id
900
is not reset until the HANDLER is closed.
903
static void mark_temp_tables_as_free_for_reuse(THD *thd)
905
for (TABLE *table= thd->temporary_tables ; table ; table= table->next)
907
if ((table->query_id == thd->query_id) && ! table->open_by_handler)
910
table->file->ha_reset();
917
Mark all tables in the list which were used by current substatement
921
mark_used_tables_as_free_for_reuse()
923
table - head of the list of tables
926
Marks all tables in the list which were used by current substatement
927
(they are marked by its query_id) as free for reuse.
930
The reason we reset query_id is that it's not enough to just test
931
if table->query_id != thd->query_id to know if a table is in use.
934
SELECT f1_that_uses_t1() FROM t1;
935
In f1_that_uses_t1() we will see one instance of t1 where query_id is
936
set to query_id of original query.
939
static void mark_used_tables_as_free_for_reuse(THD *thd, TABLE *table)
941
for (; table ; table= table->next)
943
if (table->query_id == thd->query_id)
946
table->file->ha_reset();
541
953
Auxiliary function to close all tables in the open_tables list.
543
@param session Thread context.
955
@param thd Thread context.
545
957
@remark It should not ordinarily be called directly.
548
void Session::close_open_tables()
960
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;
962
bool found_old_table= 0;
964
safe_mutex_assert_not_owner(&LOCK_open);
966
VOID(pthread_mutex_lock(&LOCK_open));
968
while (thd->open_tables)
969
found_old_table|= close_thread_table(thd, &thd->open_tables);
970
thd->some_tables_deleted= 0;
972
/* Free tables to hold down open files */
973
while (open_cache.records > table_cache_size && unused_tables)
974
VOID(hash_delete(&open_cache,(uchar*) unused_tables)); /* purecov: tested */
562
975
if (found_old_table)
564
977
/* Tell threads waiting for refresh that something has happened */
565
978
broadcast_refresh();
981
VOID(pthread_mutex_unlock(&LOCK_open));
986
Close all tables used by the current substatement, or all tables
987
used by this thread if we are on the upper level.
990
close_thread_tables()
994
Unlocks tables and frees derived tables.
995
Put all normal tables used by thread in free list.
997
It will only close/mark as free for reuse tables opened by this
998
substatement, it will also check if we are closing tables after
999
execution of complete query (i.e. we are on upper level) and will
1000
leave prelocked mode if needed.
1003
void close_thread_tables(THD *thd)
1008
We are assuming here that thd->derived_tables contains ONLY derived
1009
tables for this substatement. i.e. instead of approach which uses
1010
query_id matching for determining which of the derived tables belong
1011
to this substatement we rely on the ability of substatements to
1012
save/restore thd->derived_tables during their execution.
1014
TODO: Probably even better approach is to simply associate list of
1015
derived tables with (sub-)statement instead of thread and destroy
1016
them at the end of its execution.
1018
if (thd->derived_tables)
1022
Close all derived tables generated in queries like
1023
SELECT * FROM (SELECT * FROM t1)
1025
for (table= thd->derived_tables ; table ; table= next)
1028
free_tmp_table(thd, table);
1030
thd->derived_tables= 0;
1034
Mark all temporary tables used by this statement as free for reuse.
1036
mark_temp_tables_as_free_for_reuse(thd);
1038
Let us commit transaction for statement. Since in 5.0 we only have
1039
one statement transaction and don't allow several nested statement
1040
transactions this call will do nothing if we are inside of stored
1041
function or trigger (i.e. statement transaction is already active and
1042
does not belong to statement for which we do close_thread_tables()).
1043
TODO: This should be fixed in later releases.
1045
if (!(thd->state_flags & Open_tables_state::BACKUPS_AVAIL))
1047
thd->main_da.can_overwrite_status= true;
1048
ha_autocommit_or_rollback(thd, thd->is_error());
1049
thd->main_da.can_overwrite_status= false;
1050
thd->transaction.stmt.reset();
1053
if (thd->locked_tables)
1056
/* Ensure we are calling ha_reset() for all used tables */
1057
mark_used_tables_as_free_for_reuse(thd, thd->open_tables);
1060
We are under simple LOCK TABLES so should not do anything else.
1068
For RBR we flush the pending event just before we unlock all the
1069
tables. This means that we are at the end of a topmost
1070
statement, so we ensure that the STMT_END_F flag is set on the
1071
pending event. For statements that are *inside* stored
1072
functions, the pending event will not be flushed: that will be
1073
handled either before writing a query log event (inside
1074
binlog_query()) or when preparing a pending event.
1076
thd->binlog_flush_pending_rows_event(true);
1077
mysql_unlock_tables(thd, thd->lock);
1081
Note that we need to hold LOCK_open while changing the
1082
open_tables list. Another thread may work on it.
1083
(See: remove_table_from_cache(), mysql_wait_completed_table())
1084
Closing a MERGE child before the parent would be fatal if the
1085
other thread tries to abort the MERGE lock in between.
1087
if (thd->open_tables)
1088
close_open_tables(thd);
1094
/* move one table to free list */
1096
bool close_thread_table(THD *thd, TABLE **table_ptr)
1098
bool found_old_table= 0;
1099
TABLE *table= *table_ptr;
1101
assert(table->key_read == 0);
1102
assert(!table->file || table->file->inited == handler::NONE);
1104
*table_ptr=table->next;
1106
if (table->needs_reopen_or_name_lock() ||
1107
thd->version != refresh_version || !table->db_stat)
1109
VOID(hash_delete(&open_cache,(uchar*) table));
1115
Open placeholders have TABLE::db_stat set to 0, so they should be
1116
handled by the first alternative.
1118
assert(!table->open_placeholder);
1120
/* Free memory and reset for next loop */
1121
table->file->ha_reset();
1125
table->next=unused_tables; /* Link in last */
1126
table->prev=unused_tables->prev;
1127
unused_tables->prev=table;
1128
table->prev->next=table;
1131
unused_tables=table->next=table->prev=table;
1133
return(found_old_table);
1137
/* close_temporary_tables' internal, 4 is due to uint4korr definition */
1138
static inline uint tmpkeyval(THD *thd __attribute__((__unused__)),
1141
return uint4korr(table->s->table_cache_key.str + table->s->table_cache_key.length - 4);
1146
Close all temporary tables created by 'CREATE TEMPORARY TABLE' for thread
1147
creates one DROP TEMPORARY TABLE binlog event for each pseudo-thread
1150
void close_temporary_tables(THD *thd)
1155
/* Assume thd->options has OPTION_QUOTE_SHOW_CREATE */
1156
bool was_quote_show= true;
1158
if (!thd->temporary_tables)
1161
if (!mysql_bin_log.is_open() || thd->current_stmt_binlog_row_based)
1164
for (table= thd->temporary_tables; table; table= tmp_next)
1166
tmp_next= table->next;
1167
close_temporary(table, 1, 1);
1169
thd->temporary_tables= 0;
1173
/* Better add "if exists", in case a RESET MASTER has been done */
1174
const char stub[]= "DROP /*!40005 TEMPORARY */ TABLE IF EXISTS ";
1175
uint stub_len= sizeof(stub) - 1;
1177
String s_query= String(buf, sizeof(buf), system_charset_info);
1178
bool found_user_tables= false;
1180
memcpy(buf, stub, stub_len);
1183
Insertion sort of temp tables by pseudo_thread_id to build ordered list
1184
of sublists of equal pseudo_thread_id
1187
for (prev_table= thd->temporary_tables, table= prev_table->next;
1189
prev_table= table, table= table->next)
1191
TABLE *prev_sorted /* same as for prev_table */, *sorted;
1192
if (is_user_table(table))
1194
if (!found_user_tables)
1195
found_user_tables= true;
1196
for (prev_sorted= NULL, sorted= thd->temporary_tables; sorted != table;
1197
prev_sorted= sorted, sorted= sorted->next)
1199
if (!is_user_table(sorted) ||
1200
tmpkeyval(thd, sorted) > tmpkeyval(thd, table))
1202
/* move into the sorted part of the list from the unsorted */
1203
prev_table->next= table->next;
1204
table->next= sorted;
1207
prev_sorted->next= table;
1211
thd->temporary_tables= table;
1220
/* We always quote db,table names though it is slight overkill */
1221
if (found_user_tables &&
1222
!(was_quote_show= test(thd->options & OPTION_QUOTE_SHOW_CREATE)))
1224
thd->options |= OPTION_QUOTE_SHOW_CREATE;
1227
/* scan sorted tmps to generate sequence of DROP */
1228
for (table= thd->temporary_tables; table; table= next)
1230
if (is_user_table(table))
1232
my_thread_id save_pseudo_thread_id= thd->variables.pseudo_thread_id;
1233
/* Set pseudo_thread_id to be that of the processed table */
1234
thd->variables.pseudo_thread_id= tmpkeyval(thd, table);
1236
Loop forward through all tables within the sublist of
1237
common pseudo_thread_id to create single DROP query.
1239
for (s_query.length(stub_len);
1240
table && is_user_table(table) &&
1241
tmpkeyval(thd, table) == thd->variables.pseudo_thread_id;
1245
We are going to add 4 ` around the db/table names and possible more
1246
due to special characters in the names
1248
append_identifier(thd, &s_query, table->s->db.str, strlen(table->s->db.str));
1249
s_query.append('.');
1250
append_identifier(thd, &s_query, table->s->table_name.str,
1251
strlen(table->s->table_name.str));
1252
s_query.append(',');
1254
close_temporary(table, 1, 1);
1257
CHARSET_INFO *cs_save= thd->variables.character_set_client;
1258
thd->variables.character_set_client= system_charset_info;
1259
Query_log_event qinfo(thd, s_query.ptr(),
1260
s_query.length() - 1 /* to remove trailing ',' */,
1262
thd->variables.character_set_client= cs_save;
1264
Imagine the thread had created a temp table, then was doing a
1265
SELECT, and the SELECT was killed. Then it's not clever to
1266
mark the statement above as "killed", because it's not really
1267
a statement updating data, and there are 99.99% chances it
1268
will succeed on slave. If a real update (one updating a
1269
persistent table) was killed on the master, then this real
1270
update will be logged with error_code=killed, rightfully
1271
causing the slave to stop.
1273
qinfo.error_code= 0;
1274
mysql_bin_log.write(&qinfo);
1275
thd->variables.pseudo_thread_id= save_pseudo_thread_id;
1280
close_temporary(table, 1, 1);
1283
if (!was_quote_show)
1284
thd->options&= ~OPTION_QUOTE_SHOW_CREATE; /* restore option */
1285
thd->temporary_tables=0;
570
1289
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.
1292
find_table_in_list()
1293
table Pointer to table list
1294
offset Offset to which list in table structure to use
1295
db_name Data base name
1296
table_name Table name
1299
This is called by find_table_in_local_list() and
1300
find_table_in_global_list().
1303
NULL Table not found
1304
# Pointer to found table.
587
TableList *find_table_in_list(TableList *table,
588
TableList *TableList::*link,
590
const char *table_name)
1307
TABLE_LIST *find_table_in_list(TABLE_LIST *table,
1308
TABLE_LIST *TABLE_LIST::*link,
1309
const char *db_name,
1310
const char *table_name)
592
1312
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)
1314
if ((table->table == 0 || table->table->s->tmp_table == NO_TMP_TABLE) &&
1315
strcmp(table->db, db_name) == 0 &&
1316
strcmp(table->table_name, table_name) == 0)
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)
1413
Issue correct error message in case we found 2 duplicate tables which
1414
prevent some update operation
1417
update_non_unique_table_error()
1418
update table which we try to update
1419
operation name of update operation
1420
duplicate duplicate table which we found
1423
here we hide view underlying tables if we have them
1426
void update_non_unique_table_error(TABLE_LIST *update,
1427
const char *operation __attribute__((__unused__)),
1428
TABLE_LIST *duplicate __attribute__((__unused__)))
1430
my_error(ER_UPDATE_TABLE_USED, MYF(0), update->alias);
1434
TABLE *find_temporary_table(THD *thd, const char *db, const char *table_name)
1436
TABLE_LIST table_list;
1438
table_list.db= (char*) db;
1439
table_list.table_name= (char*) table_name;
1440
return find_temporary_table(thd, &table_list);
1444
TABLE *find_temporary_table(THD *thd, TABLE_LIST *table_list)
766
1446
char key[MAX_DBKEY_LENGTH];
767
1447
uint key_length;
769
key_length= TableIdentifier::createKey(key, new_db, table_name);
771
for (Table *table= temporary_tables ; table ; table= table->getNext())
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))
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
1450
key_length= create_table_def_key(thd, key, table_list, 1);
1451
for (table=thd->temporary_tables ; table ; table= table->next)
1453
if (table->s->table_cache_key.length == key_length &&
1454
!memcmp(table->s->table_cache_key.str, key, key_length))
1457
return(0); // Not a temporary table
801
1462
Drop a temporary table.
803
Try to locate the table in the list of session->temporary_tables.
1464
Try to locate the table in the list of thd->temporary_tables.
804
1465
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
1466
- if the table is being used by some outer statement, fail.
1467
- if the table is in thd->locked_tables, unlock it and
1468
remove it from the list of locked tables. Currently only transactional
1469
temporary tables are present in the locked_tables list.
1470
- Close the temporary table, remove its .FRM
1471
- remove the table from the list of temporary tables
812
1473
This function is used to drop user temporary tables, as well as
813
1474
internal tables created in CREATE TEMPORARY TABLE ... SELECT
814
or ALTER Table. Even though part of the work done by this function
1475
or ALTER TABLE. Even though part of the work done by this function
815
1476
is redundant when the table is internal, as long as we
816
1477
link both internal and user temporary tables into the same
817
session->temporary_tables list, it's impossible to tell here whether
1478
thd->temporary_tables list, it's impossible to tell here whether
818
1479
we're dealing with an internal or a user temporary table.
820
1481
@retval 0 the table was found and dropped successfully.
821
1482
@retval 1 the table was not found in the list of temporary tables
823
1484
@retval -1 the table is in use by a outer query
826
int Session::drop_temporary_table(TableList *table_list)
1487
int drop_temporary_table(THD *thd, TABLE_LIST *table_list)
830
if (not (table= find_temporary_table(table_list)))
1491
if (!(table= find_temporary_table(thd, table_list)))
833
1494
/* 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);
1495
if (table->query_id && table->query_id != thd->query_id)
1497
my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
1502
If LOCK TABLES list is not empty and contains this table,
1503
unlock the table and remove the table from this list.
1505
mysql_lock_remove(thd, thd->locked_tables, table, false);
1506
close_temporary_table(thd, table, 1, 1);
1511
unlink from thd->temporary tables and close temporary table
1514
void close_temporary_table(THD *thd, TABLE *table,
1515
bool free_share, bool delete_table)
1519
table->prev->next= table->next;
1520
if (table->prev->next)
1521
table->next->prev= table->prev;
1525
/* removing the item from the list */
1526
assert(table == thd->temporary_tables);
1528
slave must reset its temporary list pointer to zero to exclude
1529
passing non-zero value to end_slave via rli->save_temporary_tables
1530
when no temp tables opened, see an invariant below.
1532
thd->temporary_tables= table->next;
1533
if (thd->temporary_tables)
1534
table->next->prev= 0;
1536
if (thd->slave_thread)
1538
/* natural invariant of temporary_tables */
1539
assert(slave_open_temp_tables || !thd->temporary_tables);
1540
slave_open_temp_tables--;
1542
close_temporary(table, free_share, delete_table);
1548
Close and delete a temporary table
1551
This dosn't unlink table from thd->temporary
1552
If this is needed, use close_temporary_table()
1555
void close_temporary(TABLE *table, bool free_share, bool delete_table)
1557
handlerton *table_type= table->s->db_type();
1559
free_io_cache(table);
1562
Check that temporary table has not been created with
1563
frm_only because it has then not been created in any storage engine
1566
rm_temporary_table(table_type, table->s->path.str,
1567
table->s->tmp_table == TMP_TABLE_FRM_FILE_ONLY);
1570
free_table_share(table->s);
1571
my_free((char*) table,MYF(0));
1578
Used by ALTER TABLE when the table is a temporary one. It changes something
1579
only if the ALTER contained a RENAME clause (otherwise, table_name is the old
1581
Prepares a table cache key, which is the concatenation of db, table_name and
1582
thd->slave_proxy_id, separated by '\0'.
1585
bool rename_temporary_table(THD* thd, TABLE *table, const char *db,
1586
const char *table_name)
1590
TABLE_SHARE *share= table->s;
1591
TABLE_LIST table_list;
1593
if (!(key=(char*) alloc_root(&share->mem_root, MAX_DBKEY_LENGTH)))
1594
return(1); /* purecov: inspected */
1596
table_list.db= (char*) db;
1597
table_list.table_name= (char*) table_name;
1598
key_length= create_table_def_key(thd, key, &table_list, 1);
1599
share->set_table_cache_key(key, key_length);
1604
/* move table first in unused links */
1606
static void relink_unused(TABLE *table)
1608
if (table != unused_tables)
1610
table->prev->next=table->next; /* Remove from unused list */
1611
table->next->prev=table->prev;
1612
table->next=unused_tables; /* Link in unused tables */
1613
table->prev=unused_tables->prev;
1614
unused_tables->prev->next=table;
1615
unused_tables->prev=table;
1616
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
1622
Remove all instances of table from thread's open list and
1625
@param thd Thread context
1626
@param find Table to remove
1627
@param unlock true - free all locks on tables removed that are
1628
done with LOCK TABLES
1631
@note When unlock parameter is false or current thread doesn't have
1632
any tables locked with LOCK TABLES, tables are assumed to be
1633
not locked (for example already unlocked).
854
void Session::unlink_open_table(Table *find)
1636
void unlink_open_table(THD *thd, TABLE *find, bool unlock)
856
1638
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);
1639
uint key_length= find->s->table_cache_key.length;
1640
TABLE *list, **prev;
1642
safe_mutex_assert_owner(&LOCK_open);
1644
memcpy(key, find->s->table_cache_key.str, key_length);
863
1646
Note that we need to hold LOCK_open while changing the
864
1647
open_tables list. Another thread may work on it.
866
1649
Closing a MERGE child before the parent would be fatal if the
867
1650
other thread tries to abort the MERGE lock in between.
869
for (prev= &open_tables; *prev; )
1652
for (prev= &thd->open_tables; *prev; )
873
if (list->getShare()->getCacheKeySize() == key_length &&
874
not memcmp(&list->getShare()->getCacheKey()[0], key, key_length))
1656
if (list->s->table_cache_key.length == key_length &&
1657
!memcmp(list->s->table_cache_key.str, key, key_length))
1659
if (unlock && thd->locked_tables)
1660
mysql_lock_remove(thd, thd->locked_tables, list, true);
876
1662
/* Remove table from open_tables list. */
877
*prev= list->getNext();
879
1664
/* Close table. */
1665
VOID(hash_delete(&open_cache,(uchar*) list)); // Close table
884
1669
/* Step to next entry in open_tables list. */
885
prev= list->getNextPtr();
889
1674
// Notify any 'refresh' threads
890
1675
broadcast_refresh();
895
Auxiliary routine which closes and drops open table.
897
@param session Thread handle
898
@param table Table object for table to be dropped
899
@param db_name Name of database for this table
900
@param table_name Name of this table
902
@note This routine assumes that table to be closed is open only
903
by calling thread so we needn't wait until other threads
904
will close the table. Also unless called under implicit or
905
explicit LOCK TABLES mode it assumes that table to be
906
dropped is already unlocked. In the former case it will
907
also remove lock on the table. But one should not rely on
908
this behaviour as it may change in future.
909
Currently, however, this function is never called for a
910
table that was locked with LOCK TABLES.
1681
Auxiliary routine which closes and drops open table.
1683
@param thd Thread handle
1684
@param table TABLE object for table to be dropped
1685
@param db_name Name of database for this table
1686
@param table_name Name of this table
1688
@note This routine assumes that table to be closed is open only
1689
by calling thread so we needn't wait until other threads
1690
will close the table. Also unless called under implicit or
1691
explicit LOCK TABLES mode it assumes that table to be
1692
dropped is already unlocked. In the former case it will
1693
also remove lock on the table. But one should not rely on
1694
this behaviour as it may change in future.
1695
Currently, however, this function is never called for a
1696
table that was locked with LOCK TABLES.
913
void Session::drop_open_table(Table *table, TableIdentifier &identifier)
1699
void drop_open_table(THD *thd, TABLE *table, const char *db_name,
1700
const char *table_name)
915
if (table->getShare()->getType())
917
close_temporary_table(table);
1702
if (table->s->tmp_table)
1703
close_temporary_table(thd, table, 1, 1);
921
boost::mutex::scoped_lock scoped_lock(LOCK_open); /* Close and drop a table (AUX routine) */
1706
handlerton *table_type= table->s->db_type();
1707
VOID(pthread_mutex_lock(&LOCK_open));
923
1709
unlink_open_table() also tells threads waiting for refresh or close
924
1710
that something has happened.
926
unlink_open_table(table);
927
quick_rm_table(*this, identifier);
1712
unlink_open_table(thd, table, false);
1713
quick_rm_table(table_type, db_name, table_name, 0);
1714
VOID(pthread_mutex_unlock(&LOCK_open));
933
Wait for condition but allow the user to send a kill to mysqld
1720
Wait for condition but allow the user to send a kill to mysqld
937
session Thread Cursor
938
mutex mutex that is currently hold that is associated with condition
939
Will be unlocked on return
940
cond Condition to wait for
1723
wait_for_condition()
1725
mutex mutex that is currently hold that is associated with condition
1726
Will be unlocked on return
1727
cond Condition to wait for
943
void Session::wait_for_condition(boost::mutex &mutex, boost::condition_variable &cond)
1730
void wait_for_condition(THD *thd, pthread_mutex_t *mutex, pthread_cond_t *cond)
945
1732
/* Wait until the current table is up to date */
946
const char *saved_proc_info;
947
mysys_var->current_mutex= &mutex;
948
mysys_var->current_cond= &cond;
949
saved_proc_info= get_proc_info();
950
set_proc_info("Waiting for table");
952
(void) pthread_cond_wait(cond.native_handle(), mutex.native_handle());
1733
const char *proc_info;
1734
thd->mysys_var->current_mutex= mutex;
1735
thd->mysys_var->current_cond= cond;
1736
proc_info=thd->proc_info;
1737
thd_proc_info(thd, "Waiting for table");
1739
(void) pthread_cond_wait(cond, mutex);
955
1742
We must unlock mutex first to avoid deadlock becasue conditions are
1018
1841
object to its original state.
1020
1843
*table= orig_table;
1024
share= table->getMutableShare();
1026
1849
We want to prevent other connections from opening this table until end
1027
1850
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,
1851
not yet finished (for example CREATE TRIGGER have to change .TRG file,
1029
1852
or we might want to drop table if CREATE TABLE ... SELECT fails).
1030
1853
This also allows us to assume that no other connection will sneak in
1031
1854
before we will get table-level lock on this table.
1033
share->resetVersion();
1034
table->in_use = this;
1857
table->in_use = thd;
1038
table->setNext(open_tables);
1861
table->next= thd->open_tables;
1862
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.
1867
TABLE object should be already in THD::open_tables list so we just
1868
need to set TABLE::next correctly.
1047
table->setNext(orig_table.getNext());
1870
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;
1873
table->tablenr=thd->current_tablenr++;
1874
table->used_fields=0;
1875
table->const_table=0;
1876
table->null_row= table->maybe_null= table->force_index= 0;
1877
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
1883
Create and insert into table cache placeholder for table
1884
which will prevent its opening (or creation) (a.k.a lock
1887
@param thd Thread context
1888
@param key Table cache key for name to be locked
1889
@param key_length Table cache key length
1891
@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)
1895
TABLE *table_cache_insert_placeholder(THD *thd, const char *key,
1077
safe_mutex_assert_owner(LOCK_open.native_handle());
1902
safe_mutex_assert_owner(&LOCK_open);
1080
1905
Create a table entry with the right key and with an old refresh version
1906
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))
1909
if (!my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),
1910
&table, sizeof(*table),
1911
&share, sizeof(*share),
1912
&key_buff, key_length,
1917
share->set_table_cache_key(key_buff, key, key_length);
1918
share->tmp_table= INTERNAL_TMP_TABLE; // for intern_close_table
1920
table->locked_by_name=1;
1922
if (my_hash_insert(&open_cache, (uchar*)table))
1924
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.
1933
Obtain an exclusive name lock on the table if it is not cached
1936
@param thd Thread context
1937
@param db Name of database
1938
@param table_name Name of table
1939
@param[out] table Out parameter which is either:
1940
- set to NULL if table cache contains record for
1942
- set to point to the TABLE instance used for
1945
@note This function takes into account all records for table in table
1946
cache, even placeholders used for name-locking. This means that
1947
'table' parameter can be set to NULL for some situations when
1948
table does not really exist.
1950
@retval true Error occured (OOM)
1951
@retval false Success. 'table' parameter set according to above rules.
1117
bool Session::lock_table_name_if_not_cached(TableIdentifier &identifier, Table **table)
1954
bool lock_table_name_if_not_cached(THD *thd, const char *db,
1955
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())
1957
char key[MAX_DBKEY_LENGTH];
1960
key_length= (uint)(strmov(strmov(key, db) + 1, table_name) - key) + 1;
1961
VOID(pthread_mutex_lock(&LOCK_open));
1963
if (hash_search(&open_cache, (uchar *)key, key_length))
1965
VOID(pthread_mutex_unlock(&LOCK_open));
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;
1969
if (!(*table= table_cache_insert_placeholder(thd, key, key_length)))
1971
VOID(pthread_mutex_unlock(&LOCK_open));
1974
(*table)->open_placeholder= 1;
1975
(*table)->next= thd->open_tables;
1976
thd->open_tables= *table;
1977
VOID(pthread_mutex_unlock(&LOCK_open));
1983
Check that table exists in table definition cache, on disk
1984
or in some storage engine.
1986
@param thd Thread context
1987
@param table Table list element
1988
@param[out] exists Out parameter which is set to true if table
1989
exists and to false otherwise.
1991
@note This function assumes that caller owns LOCK_open mutex.
1992
It also assumes that the fact that there are no name-locks
1993
on the table was checked beforehand.
1995
@note If there is no .FRM file for the table but it exists in one
1996
of engines (e.g. it was created on another node of NDB cluster)
1997
this function will fetch and create proper .FRM file for it.
1999
@retval true Some error occured
2000
@retval false No error. 'exists' out parameter set accordingly.
2003
bool check_if_table_exists(THD *thd, TABLE_LIST *table, bool *exists)
2005
char path[FN_REFLEN];
2008
safe_mutex_assert_owner(&LOCK_open);
2012
if (get_cached_table_share(table->db, table->table_name))
2015
build_table_filename(path, sizeof(path) - 1, table->db, table->table_name,
2018
if (!access(path, F_OK))
2021
/* .FRM file doesn't exist. Check if some engine can provide it. */
2023
rc= ha_create_table_from_engine(thd, table->db, table->table_name);
2027
/* Table does not exists in engines as well. */
2033
/* Table exists in some engine and .FRM for it was created. */
2038
my_printf_error(ER_UNKNOWN_ERROR, "Failed to open '%-.64s', error while "
2039
"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.
2051
table_list Open first table in list.
2052
refresh INOUT Pointer to memory that will be set to 1 if
2053
we need to close all tables and reopen them.
2054
If this is a NULL pointer, then the table is not
2055
put in the thread-open-list.
2056
flags Bitmap of flags to modify how open works:
2057
MYSQL_LOCK_IGNORE_FLUSH - Open table even if
2058
someone has done a flush or namelock on it.
2059
No version number checking is done.
2060
MYSQL_OPEN_TEMPORARY_ONLY - Open only temporary
2061
table not the base table or view.
1163
Uses a cache of open tables to find a table not in use.
2064
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.
2066
If table list element for the table to be opened has "create" flag
2067
set and table does not exist, this function will automatically insert
2068
a placeholder for exclusive name lock into the open tables cache and
2069
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.
2072
NULL Open failed. If refresh is set then one should close
2073
all other tables and retry the open.
2074
# Success. Pointer to TABLE object for open table.
1177
Table *Session::openTable(TableList *table_list, bool *refresh, uint32_t flags)
2078
TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
2079
bool *refresh, uint flags)
1180
const char *alias= table_list->alias;
2081
register TABLE *table;
2082
char key[MAX_DBKEY_LENGTH];
2083
unsigned int key_length;
2084
char *alias= table_list->alias;
2085
HASH_SEARCH_STATE state;
1182
/* Parsing of partitioning information from .frm needs session->lex set up. */
1183
assert(lex->is_lex_started);
2087
/* Parsing of partitioning information from .frm needs thd->lex set up. */
2088
assert(thd->lex->is_lex_started);
1185
2090
/* find a unused table in the open table cache */
1189
2094
/* 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;
2095
if (check_stack_overrun(thd, STACK_MIN_SIZE_FOR_OPEN, (uchar *)&alias))
2101
key_length= (create_table_def_key(thd, key, table_list, 1) -
2102
TMP_TABLE_KEY_EXTRA);
1201
2105
Unless requested otherwise, try to resolve this table in the list
1202
2106
of temporary tables of this thread. In MySQL temporary tables
1203
2107
are always thread-local and "shadow" possible base tables with the
1204
2108
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();
2109
TODO: move this block into a separate function.
2112
for (table= thd->temporary_tables; table ; table=table->next)
2114
if (table->s->table_cache_key.length == key_length +
2115
TMP_TABLE_KEY_EXTRA &&
2116
!memcmp(table->s->table_cache_key.str, key,
2117
key_length + TMP_TABLE_KEY_EXTRA))
2120
We're trying to use the same temporary table twice in a query.
2121
Right now we don't support this because a temporary table
2122
is always represented by only one TABLE object in THD, and
2123
it can not be cloned. Emit an error for an unsupported behaviour.
2125
if (table->query_id)
2127
my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
2130
table->query_id= thd->query_id;
2131
thd->thread_specific_used= true;
2137
if (flags & MYSQL_OPEN_TEMPORARY_ONLY)
2139
my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->db, table_list->table_name);
2144
The table is not temporary - if we're in pre-locked or LOCK TABLES
2145
mode, let's try to find the requested table in the list of pre-opened
2146
and locked tables. If the table is not there, return an error - we can't
2147
open not pre-opened tables in pre-locked/LOCK TABLES mode.
2148
TODO: move this block into a separate function.
2150
if (thd->locked_tables)
2151
{ // Using table locks
2152
TABLE *best_table= 0;
2153
int best_distance= INT_MIN;
2154
bool check_if_used= false;
2155
for (table=thd->open_tables; table ; table=table->next)
2157
if (table->s->table_cache_key.length == key_length &&
2158
!memcmp(table->s->table_cache_key.str, key, key_length))
2160
if (check_if_used && table->query_id &&
2161
table->query_id != thd->query_id)
2164
If we are in stored function or trigger we should ensure that
2165
we won't change table that is already used by calling statement.
2166
So if we are opening table for writing, we should check that it
2167
is not already open by some calling stamement.
2169
my_error(ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG, MYF(0),
2170
table->s->table_name.str);
2174
When looking for a usable TABLE, ignore MERGE children, as they
2175
belong to their parent and cannot be used explicitly.
2177
if (!my_strcasecmp(system_charset_info, table->alias, alias) &&
2178
table->query_id != thd->query_id) /* skip tables already used */
2180
int distance= ((int) table->reginfo.lock_type -
2181
(int) table_list->lock_type);
2183
Find a table that either has the exact lock type requested,
2184
or has the best suitable lock. In case there is no locked
2185
table that has an equal or higher lock than requested,
2186
we us the closest matching lock to be able to produce an error
2187
message about wrong lock mode on the table. The best_table
2188
is changed if bd < 0 <= d or bd < d < 0 or 0 <= d < bd.
2190
distance < 0 - No suitable lock found
2191
distance > 0 - we have lock mode higher then we require
2192
distance == 0 - we have lock mode exactly which we need
2194
if ((best_distance < 0 && distance > best_distance) || (distance >= 0 && distance < best_distance))
2196
best_distance= distance;
2198
if (best_distance == 0 && !check_if_used)
2201
If we have found perfect match and we don't need to check that
2202
table is not used by one of calling statements (assuming that
2203
we are inside of function or trigger) we can finish iterating
2204
through open tables list.
2215
table->query_id= thd->query_id;
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 */
2219
No table in the locked tables list. In case of explicit LOCK TABLES
2220
this can happen if a user did not include the able into the list.
2221
In case of pre-locked mode locked tables list is generated automatically,
2222
so we may only end up here if the table did not exist when
2223
locked tables list was created.
2225
my_error(ER_TABLE_NOT_LOCKED, MYF(0), alias);
1288
2284
an implicit "pending locks queue" - see
1289
2285
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)
2287
for (table= (TABLE*) hash_first(&open_cache, (uchar*) key, key_length,
2289
table && table->in_use ;
2290
table= (TABLE*) hash_next(&open_cache, (uchar*) key, key_length,
1297
table= (*iter).second;
1299
if (not table->in_use)
1302
2294
Here we flush tables marked for flush.
1303
Normally, table->getShare()->version contains the value of
2295
Normally, table->s->version contains the value of
1304
2296
refresh_version from the moment when this table was
1305
2297
(re-)opened and added to the cache.
1306
2298
If since then we did (or just started) FLUSH TABLES
1307
2299
statement, refresh_version has been increased.
1308
For "name-locked" Table instances, table->getShare()->version is set
2300
For "name-locked" TABLE instances, table->s->version is set
1309
2301
to 0 (see lock_table_name for details).
1310
2302
In case there is a pending FLUSH TABLES or a name lock, we
1311
2303
need to back off and re-start opening tables.
1312
2304
If we do not back off now, we may dead lock in case of lock
1313
2305
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
2306
c1: name lock t1; -- sort of exclusive lock
2307
c2: open t2; -- sort of shared lock
2308
c1: name lock t2; -- blocks
2309
c2: open t1; -- blocks
1319
2311
if (table->needs_reopen_or_name_lock())
1321
if (flags & DRIZZLE_LOCK_IGNORE_FLUSH)
2313
if (flags & MYSQL_LOCK_IGNORE_FLUSH)
1323
2315
/* Force close at once after usage */
1324
version= table->getShare()->getVersion();
2316
thd->version= table->s->version;
1328
2320
/* Avoid self-deadlocks by detecting self-dependencies. */
1329
if (table->open_placeholder && table->in_use == this)
2321
if (table->open_placeholder && table->in_use == thd)
1332
my_error(ER_UPDATE_TABLE_USED, MYF(0), table->getMutableShare()->getTableName());
2323
VOID(pthread_mutex_unlock(&LOCK_open));
2324
my_error(ER_UPDATE_TABLE_USED, MYF(0), table->s->table_name.str);
1337
2329
Back off, part 1: mark the table as "unused" for the
1338
2330
purpose of name-locking by setting table->db_stat to 0. Do
1339
2331
that only for the tables in this thread that have an old
1340
table->getShare()->version (this is an optimization (?)).
2332
table->s->version (this is an optimization (?)).
1341
2333
table->db_stat == 0 signals wait_for_locked_table_names
1342
2334
that the tables in question are not used any more. See
1343
2335
table_is_used call for details.
2337
Notice that HANDLER tables were already taken care of by
2338
the earlier call to mysql_ha_flush() in this same critical
1345
close_old_data_files(false, false);
2341
close_old_data_files(thd,thd->open_tables,0,0);
1348
2343
Back-off part 2: try to avoid "busy waiting" on the table:
1349
2344
if the table is in use by some other thread, we suspend
1350
2345
and wait till the operation is complete: when any
1351
operation that juggles with table->getShare()->version completes,
2346
operation that juggles with table->s->version completes,
1352
2347
it broadcasts COND_refresh condition variable.
1353
2348
If 'old' table we met is in use by current thread we return
1354
2349
without waiting since in this situation it's this thread
1355
2350
which is responsible for broadcasting on COND_refresh
1356
(and this was done already in Session::close_old_data_files()).
2351
(and this was done already in close_old_data_files()).
1357
2352
Good example of such situation is when we have statement
1358
2353
that needs two instances of table and FLUSH TABLES comes
1359
2354
after we open first instance but before we open second
1362
if (table->in_use != this)
2357
if (table->in_use != thd)
1364
2359
/* wait_for_conditionwill unlock LOCK_open for us */
1365
wait_for_condition(LOCK_open, COND_refresh);
2360
wait_for_condition(thd, &LOCK_open, &COND_refresh);
2364
VOID(pthread_mutex_unlock(&LOCK_open));
1372
2367
There is a refresh in progress for this table.
1373
2368
Signal the caller that it has to try again.
1382
unused_tables.unlink(table);
1383
table->in_use= this;
2377
/* Unlink the table from "unused_tables" list. */
2378
if (table == unused_tables)
2380
unused_tables=unused_tables->next; // Remove from link
2381
if (table == unused_tables)
2384
table->prev->next=table->next; /* Remove from unused list */
2385
table->next->prev=table->prev;
1387
/* Insert a new Table instance into the open cache */
2390
/* Insert a new TABLE instance into the open cache */
1389
2392
/* Free cache if too big */
1390
unused_tables.cull();
2393
while (open_cache.records > table_cache_size && unused_tables)
2394
VOID(hash_delete(&open_cache,(uchar*) unused_tables)); /* purecov: tested */
1392
if (table_list->isCreate())
2396
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))
2400
if (check_if_table_exists(thd, table_list, &exists))
2402
VOID(pthread_mutex_unlock(&LOCK_open));
1399
2409
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)))
2411
if (!(table= table_cache_insert_placeholder(thd, key, key_length)))
2413
VOID(pthread_mutex_unlock(&LOCK_open));
1407
2417
Link placeholder to the open tables list so it will be automatically
1408
2418
removed once tables are closed. Also mark it so it won't be ignored
1409
2419
by other trying to take name-lock.
1411
table->open_placeholder= true;
1412
table->setNext(open_tables);
2421
table->open_placeholder= 1;
2422
table->next= thd->open_tables;
2423
thd->open_tables= table;
2424
VOID(pthread_mutex_unlock(&LOCK_open));
1418
2427
/* Table exists. Let us try to open it. */
1421
2430
/* make a new table */
2431
if (!(table=(TABLE*) my_malloc(sizeof(*table),MYF(MY_WME))))
2433
VOID(pthread_mutex_unlock(&LOCK_open));
1429
error= open_unireg_entry(this, table, alias, identifier);
1436
(void)add_table(table);
2437
error= open_unireg_entry(thd, table, table_list, alias, key, key_length,
2438
mem_root, (flags & OPEN_VIEW_NO_PARSE));
2439
/* Combine the follow two */
2442
my_free((uchar*)table, MYF(0));
2443
VOID(pthread_mutex_unlock(&LOCK_open));
2448
my_free((uchar*)table, MYF(0));
2449
VOID(pthread_mutex_unlock(&LOCK_open));
2452
VOID(my_hash_insert(&open_cache,(uchar*) table));
2455
VOID(pthread_mutex_unlock(&LOCK_open));
1442
table->setNext(open_tables); /* Link into simple list */
2458
table->next=thd->open_tables; /* Link into simple list */
2459
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())
2461
table->reginfo.lock_type=TL_READ; /* Assume read */
2464
assert(table->s->ref_count > 0 || table->s->tmp_table != NO_TMP_TABLE);
2466
if (thd->lex->need_correct_ident())
1451
2467
table->alias_name_used= my_strcasecmp(table_alias_charset,
1452
table->getMutableShare()->getTableName(), alias);
2468
table->s->table_name.str, alias);
1453
2469
/* Fix alias if table name changes */
1454
if (strcmp(table->getAlias(), alias))
2470
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);
2472
uint length=(uint) strlen(alias)+1;
2473
table->alias= (char*) my_realloc((char*) table->alias, length,
2475
memcpy((char*) table->alias, alias, length);
1461
2477
/* 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;
2478
table->tablenr=thd->current_tablenr++;
2479
table->used_fields=0;
2480
table->const_table=0;
2481
table->null_row= table->maybe_null= table->force_index= 0;
1468
2482
table->status=STATUS_NO_RECORD;
1469
table->insert_values.clear();
2483
table->insert_values= 0;
2484
table->fulltext_searched= 0;
2485
table->file->ft_handler= 0;
1470
2486
/* Catch wrong handling of the auto_increment_field_not_null. */
1471
2487
assert(!table->auto_increment_field_not_null);
1472
2488
table->auto_increment_field_not_null= false;
1473
2489
if (table->timestamp_field)
1475
2490
table->timestamp_field_type= table->timestamp_field->get_auto_set_type();
1477
2491
table->pos_in_table_list= table_list;
1478
2492
table->clear_column_bitmaps();
1479
2493
assert(table->key_read == 0);
2498
TABLE *find_locked_table(THD *thd, const char *db,const char *table_name)
2500
char key[MAX_DBKEY_LENGTH];
2501
uint key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
2503
for (TABLE *table=thd->open_tables; table ; table=table->next)
2505
if (table->s->table_cache_key.length == key_length &&
2506
!memcmp(table->s->table_cache_key.str, key, key_length))
1487
2514
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.
2521
The data file for the table is already closed and the share is released
2522
The table has a 'dummy' share that mainly contains database and table name.
1499
1 error. The old table object is not changed.
2526
1 error. The old table object is not changed.
1502
bool reopen_table(Table *table)
2529
bool reopen_table(TABLE *table)
1508
TableList table_list;
1509
Session *session= table->in_use;
2535
TABLE_LIST table_list;
2536
THD *thd= table->in_use;
1511
assert(table->getShare()->ref_count == 0);
2538
assert(table->s->ref_count == 0);
1512
2539
assert(!table->sort.io_cache);
1514
2541
#ifdef EXTRA_DEBUG
1515
2542
if (table->db_stat)
1516
errmsg_printf(ERRMSG_LVL_ERROR, _("Table %s had a open data Cursor in reopen_table"),
2543
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();
2546
bzero((char*) &table_list, sizeof(TABLE_LIST));
2547
table_list.db= table->s->db.str;
2548
table_list.table_name= table->s->table_name.str;
1521
2549
table_list.table= table;
1523
if (wait_for_locked_table_names(session, &table_list))
1524
return true; // Thread was killed
2551
if (wait_for_locked_table_names(thd, &table_list))
2552
return(1); // Thread was killed
1526
if (open_unireg_entry(session, &tmp, &table_list,
1528
table->getShare()->getCacheKey(),
1529
table->getShare()->getCacheKeySize()))
2554
if (open_unireg_entry(thd, &tmp, &table_list,
2556
table->s->table_cache_key.str,
2557
table->s->table_cache_key.length,
1532
2561
/* This list copies variables set by open_table */
1558
2589
(*field)->table= (*field)->orig_table= table;
1559
2590
(*field)->table_name= &table->alias;
1561
for (key=0 ; key < table->getShare()->keys ; key++)
2592
for (key=0 ; key < table->s->keys ; key++)
1563
2594
for (part=0 ; part < table->key_info[key].usable_key_parts ; part++)
1564
2595
table->key_info[key].key_part[part].field->table= table;
2598
Do not attach MERGE children here. The children might be reopened
2599
after the parent. Attach children after reopening all tables that
2600
require reopen. See for example reopen_tables().
1567
2603
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.
2612
Close all instances of a table open by this thread and replace
2613
them with exclusive name-locks.
2615
@param thd Thread context
2616
@param db Database name for the table to be closed
2617
@param table_name Name of the table to be closed
2619
@note This function assumes that if we are not under LOCK TABLES,
2620
then there is only one table open and locked. This means that
2621
the function probably has to be adjusted before it can be used
2622
anywhere outside ALTER TABLE.
2624
@note Must not use TABLE_SHARE::table_name/db of the table being closed,
2625
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)
2628
void close_data_files_and_morph_locks(THD *thd, const char *db,
2629
const char *table_name)
1595
safe_mutex_assert_owner(LOCK_open.native_handle()); /* Adjust locks at the end of ALTER TABLEL */
2633
safe_mutex_assert_owner(&LOCK_open);
1600
2638
If we are not under LOCK TABLES we should have only one table
1601
2639
open and locked so it makes sense to remove the lock at once.
1603
mysql_unlock_tables(this, lock);
2641
mysql_unlock_tables(thd, thd->lock);
1608
2646
Note that open table list may contain a name-lock placeholder
1609
for target table name if we process ALTER Table ... RENAME.
2647
for target table name if we process ALTER TABLE ... RENAME.
1610
2648
So loop below makes sense even if we are not under LOCK TABLES.
1612
for (Table *table= open_tables; table ; table=table->getNext())
2650
for (table=thd->open_tables; table ; table=table->next)
1614
if (table->getShare()->getCacheKey() == identifier.getKey())
2652
if (!strcmp(table->s->table_name.str, table_name) &&
2653
!strcmp(table->s->db.str, db))
1616
table->open_placeholder= true;
2655
if (thd->locked_tables)
2657
mysql_lock_remove(thd, thd->locked_tables, table, true);
2659
table->open_placeholder= 1;
1617
2660
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.
2668
Reopen all tables with closed data files.
2670
@param thd Thread context
2671
@param get_locks Should we get locks after reopening tables ?
2672
@param mark_share_as_old Mark share as old to protect from a impending
2675
@note Since this function can't properly handle prelocking and
2676
create placeholders it should be used in very special
2677
situations like FLUSH TABLES or ALTER TABLE. In general
2678
case one should just repeat open_tables()/lock_tables()
2679
combination when one needs tables to be reopened (for
2680
example see open_and_lock_tables()).
2682
@note One should have lock on LOCK_open when calling this.
2684
@return false in case of success, true - otherwise.
1643
bool Session::reopen_tables(bool get_locks, bool)
2687
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
2689
TABLE *table,*next,**prev;
2690
TABLE **tables,**tables_ptr; // For locks
1647
2691
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());
2692
const uint flags= MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN |
2693
MYSQL_LOCK_IGNORE_GLOBAL_READ_LOCK |
2694
MYSQL_LOCK_IGNORE_FLUSH;
2696
if (!thd->open_tables)
2699
safe_mutex_assert_owner(&LOCK_open);
1659
2703
The ptr is checked later
1660
2704
Do not handle locks of MERGE children.
1664
for (table= open_tables; table ; table=table->getNext())
2707
for (table= thd->open_tables; table ; table=table->next)
1668
tables= new Table *[opens];
2709
tables= (TABLE**) my_alloca(sizeof(TABLE*)*opens);
1672
tables= &open_tables;
2712
tables= &thd->open_tables;
1674
2713
tables_ptr =tables;
1677
for (table= open_tables; table ; table=next)
2715
prev= &thd->open_tables;
2716
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);
2718
uint db_stat=table->db_stat;
2720
if (!tables || (!db_stat && reopen_table(table)))
2722
my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
2723
VOID(hash_delete(&open_cache,(uchar*) table));
2730
/* Do not handle locks of MERGE children. */
2731
if (get_locks && !db_stat)
2732
*tables_ptr++= table; // need new lock on this
2733
if (mark_share_as_old)
2735
table->s->version=0;
2736
table->open_placeholder= 0;
1686
2741
if (tables != tables_ptr) // Should we get back old locks
1688
DrizzleLock *local_lock;
1690
2745
We should always get these locks. Anyway, we must not go into
1691
2746
wait_for_tables() as it tries to acquire LOCK_open, which is
1692
2747
already locked.
1694
some_tables_deleted= false;
1696
if ((local_lock= mysql_lock_tables(this, tables, (uint32_t) (tables_ptr - tables),
2749
thd->some_tables_deleted=0;
2750
if ((lock= mysql_lock_tables(thd, tables, (uint) (tables_ptr - tables),
1697
2751
flags, ¬_used)))
2753
thd->locked_tables=mysql_lock_merge(thd->locked_tables,lock);
1925
2979
if (table->db_stat)
1927
2981
table->db_stat= 0;
1928
table->cursor->close();
2982
table->file->close();
1933
2987
/* We already have a name lock, remove copy */
1934
remove_table(table);
2988
VOID(hash_delete(&open_cache,(uchar*) table));
1940
prev= table->getNextPtr();
1945
2999
broadcast_refresh();
3000
if (thd->locked_tables && thd->locked_tables->table_count == 0)
3002
my_free((uchar*) thd->locked_tables,MYF(0));
3003
thd->locked_tables=0;
1952
If we have the table open, which only happens when a LOCK Table has been
3010
If we have the table open, which only happens when a LOCK TABLE has been
1953
3011
done on the table, change the lock type to a lock that will abort all
1954
3012
other threads trying to get the lock.
1957
void abort_locked_tables(Session *session, const drizzled::TableIdentifier &identifier)
3015
void abort_locked_tables(THD *thd,const char *db, const char *table_name)
1960
for (table= session->open_tables; table ; table= table->getNext())
3018
for (table= thd->open_tables; table ; table= table->next)
1962
if (table->getShare()->getCacheKey() == identifier.getKey())
3020
if (!strcmp(table->s->table_name.str, table_name) &&
3021
!strcmp(table->s->db.str, db))
1964
3023
/* If MERGE child, forward lock handling to parent. */
1965
mysql_lock_abort(session, table);
3024
mysql_lock_abort(thd, table, true);
1972
Load a table definition from cursor and open unireg table
3032
Function to assign a new table map id to a table share.
3036
share - Pointer to table share structure
3040
We are intentionally not checking that share->mutex is locked
3041
since this function should only be called when opening a table
3042
share and before it is entered into the table_def_cache (meaning
3043
that it cannot be fetched by another thread, even accidentally).
3048
The LOCK_open mutex is locked
3052
share->table_map_id is given a value that with a high certainty is
3053
not used by any other table (the only case where a table id can be
3054
reused is on wrap-around, which means more than 4 billion table
3055
share opens have been executed while one table was open all the
3058
share->table_map_id is not ~0UL.
3060
void assign_new_table_id(TABLE_SHARE *share)
3062
static ulong last_table_id= ~0UL;
3065
assert(share != NULL);
3066
safe_mutex_assert_owner(&LOCK_open);
3068
ulong tid= ++last_table_id; /* get next id */
3070
There is one reserved number that cannot be used. Remember to
3071
change this when 6-byte global table id's are introduced.
3073
if (unlikely(tid == ~0UL))
3074
tid= ++last_table_id;
3075
share->table_map_id= tid;
3077
/* Post conditions */
3078
assert(share->table_map_id != ~0UL);
3084
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
3089
entry Store open table definition here
3090
table_list TABLE_LIST with db, table_name & belong_to_view
3092
cache_key Key for share_cache
3093
cache_key_length length of cache_key
3094
mem_root temporary mem_root for parsing
3095
flags the OPEN_VIEW_NO_PARSE flag to be passed to
3096
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
3099
Extra argument for open is taken from thd->open_options
3100
One must have a lock on LOCK_open when calling this function
1992
static int open_unireg_entry(Session *session,
3107
static int open_unireg_entry(THD *thd, TABLE *entry, TABLE_LIST *table_list,
1994
3108
const char *alias,
1995
TableIdentifier &identifier)
3109
char *cache_key, uint cache_key_length,
3110
MEM_ROOT *mem_root __attribute__((__unused__)),
3111
uint flags __attribute__((__unused__)))
1999
uint32_t discover_retry_count= 0;
3115
uint discover_retry_count= 0;
2001
safe_mutex_assert_owner(LOCK_open.native_handle());
3117
safe_mutex_assert_owner(&LOCK_open);
2003
if (not (share= TableShare::getShareCreate(session,
3119
if (!(share= get_table_share_with_create(thd, table_list, cache_key,
3122
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)))
3126
while ((error= open_table_from_share(thd, share, alias,
3127
(uint) (HA_OPEN_KEYFILE |
3131
(READ_KEYINFO | COMPUTE_TYPES |
3133
thd->open_options, entry, OTM_OPEN)))
2017
3135
if (error == 7) // Table def changed
2019
share->resetVersion(); // Mark share as old
3137
share->version= 0; // Mark share as old
2020
3138
if (discover_retry_count++) // Retry once
2025
3143
Here we should wait until all threads has released the table.
2026
3144
For now we do one retry. This may cause a deadlock if there
2027
3145
is other threads waiting for other tables used by this thread.
2029
3147
Proper fix would be to if the second retry failed:
2030
3148
- Mark that table def changed
2031
3149
- Return from open table
2239
3535
table_list->lock_type= lock_type;
2240
3536
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)))
3537
if (thd->locked_tables)
3539
if (check_lock_and_start_stmt(thd, table, lock_type))
3544
assert(thd->lock == 0); // You must lock everything at once
3545
if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)
3546
if (! (thd->lock= mysql_lock_tables(thd, &table_list->table, 1,
3547
lock_flags, &refresh)))
3552
thd_proc_info(thd, 0);
3558
Open all tables in list, locks them and optionally process derived tables.
3561
open_and_lock_tables_derived()
3562
thd - thread handler
3563
tables - list of tables for open&locking
3564
derived - if to handle derived tables
3571
The lock will automaticaly be freed by close_thread_tables()
3574
There are two convenience functions:
3575
- simple_open_n_lock_tables(thd, tables) without derived handling
3576
- open_and_lock_tables(thd, tables) with derived handling
3577
Both inline functions call open_and_lock_tables_derived() with
3578
the third argument set appropriately.
3581
int open_and_lock_tables_derived(THD *thd, TABLE_LIST *tables, bool derived)
3588
if (open_tables(thd, &tables, &counter, 0))
3591
if (!lock_tables(thd, tables, counter, &need_reopen))
3595
close_tables_for_reopen(thd, &tables);
3598
(mysql_handle_derived(thd->lex, &mysql_derived_prepare) ||
3599
(thd->fill_derived_tables() &&
3600
mysql_handle_derived(thd->lex, &mysql_derived_filling))))
3601
return(true); /* purecov: inspected */
3607
Open all tables in list and process derived tables
3610
open_normal_and_derived_tables
3611
thd - thread handler
3612
tables - list of tables for open
3613
flags - bitmap of flags to modify how the tables will be open:
3614
MYSQL_LOCK_IGNORE_FLUSH - open table even if someone has
3615
done a flush or namelock on it.
3622
This is to be used on prepare stage when you don't read any
3623
data from the tables.
3626
bool open_normal_and_derived_tables(THD *thd, TABLE_LIST *tables, uint flags)
3629
assert(!thd->fill_derived_tables());
3630
if (open_tables(thd, &tables, &counter, flags) ||
3631
mysql_handle_derived(thd->lex, &mysql_derived_prepare))
3632
return(true); /* purecov: inspected */
3638
Decide on logging format to use for the statement.
3640
Compute the capabilities vector for the involved storage engines
3641
and mask out the flags for the binary log. Right now, the binlog
3642
flags only include the capabilities of the storage engines, so this
3645
We now have three alternatives that prevent the statement from
3648
1. If there are no capabilities left (all flags are clear) it is
3649
not possible to log the statement at all, so we roll back the
3650
statement and report an error.
3652
2. Statement mode is set, but the capabilities indicate that
3653
statement format is not possible.
3655
3. Row mode is set, but the capabilities indicate that row
3656
format is not possible.
3658
4. Statement is unsafe, but the capabilities indicate that row
3659
format is not possible.
3661
If we are in MIXED mode, we then decide what logging format to use:
3663
1. If the statement is unsafe, row-based logging is used.
3665
2. If statement-based logging is not possible, row-based logging is
3668
3. Otherwise, statement-based logging is used.
3670
@param thd Client thread
3671
@param tables Tables involved in the query
3674
int decide_logging_format(THD *thd, TABLE_LIST *tables)
3676
if (mysql_bin_log.is_open() && (thd->options & OPTION_BIN_LOG))
3678
handler::Table_flags flags_some_set= handler::Table_flags();
3679
handler::Table_flags flags_all_set= ~handler::Table_flags();
3680
my_bool multi_engine= false;
3681
void* prev_ht= NULL;
3682
for (TABLE_LIST *table= tables; table; table= table->next_global)
3684
if (!table->placeholder() && table->lock_type >= TL_WRITE_ALLOW_WRITE)
3686
ulonglong const flags= table->table->file->ha_table_flags();
3687
if (prev_ht && prev_ht != table->table->file->ht)
3689
prev_ht= table->table->file->ht;
3690
flags_all_set &= flags;
3691
flags_some_set |= flags;
3696
if (flags_all_set == 0)
3698
my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
3699
"Statement cannot be logged to the binary log in"
3700
" row-based nor statement-based format");
3702
else if (thd->variables.binlog_format == BINLOG_FORMAT_STMT &&
3703
(flags_all_set & HA_BINLOG_STMT_CAPABLE) == 0)
3705
my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
3706
"Statement-based format required for this statement,"
3707
" but not allowed by this combination of engines");
3709
else if ((thd->variables.binlog_format == BINLOG_FORMAT_ROW ||
3710
thd->lex->is_stmt_unsafe()) &&
3711
(flags_all_set & HA_BINLOG_ROW_CAPABLE) == 0)
3713
my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
3714
"Row-based format required for this statement,"
3715
" but not allowed by this combination of engines");
3719
If more than one engine is involved in the statement and at
3720
least one is doing it's own logging (is *self-logging*), the
3721
statement cannot be logged atomically, so we generate an error
3722
rather than allowing the binlog to become corrupt.
3725
(flags_some_set & HA_HAS_OWN_BINLOGGING))
3727
error= ER_BINLOG_LOGGING_IMPOSSIBLE;
3728
my_error(error, MYF(0),
3729
"Statement cannot be written atomically since more"
3730
" than one engine involved and at least one engine"
3731
" is self-logging");
3738
We switch to row-based format if we are in mixed mode and one of
3739
the following are true:
3741
1. If the statement is unsafe
3742
2. If statement format cannot be used
3744
Observe that point to cannot be decided before the tables
3745
involved in a statement has been checked, i.e., we cannot put
3746
this code in reset_current_stmt_binlog_row_based(), it has to be
3749
if (thd->lex->is_stmt_unsafe() ||
3750
(flags_all_set & HA_BINLOG_STMT_CAPABLE) == 0)
3752
thd->set_current_stmt_binlog_row_based_if_mixed();
2254
3760
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).
3765
tables Tables to lock
3766
count Number of opened tables
3767
need_reopen Out parameter which if true indicates that some
3768
tables were dropped or altered during this call
3769
and therefore invoker should reopen tables and
3770
try to lock them once again (in this case
3771
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
3774
You can't call lock_tables twice, as this would break the dead-lock-free
3775
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.
3778
If query for which we are calling this function marked as requring
3779
prelocking, this function will do implicit LOCK TABLES and change
3780
thd::prelocked_mode accordingly.
2281
int Session::lock_tables(TableList *tables, uint32_t count, bool *need_reopen)
3787
int lock_tables(THD *thd, TABLE_LIST *tables, uint count, bool *need_reopen)
2284
Session *session= this;
2287
3792
We can't meet statement requiring prelocking if we already
2318
3874
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 ...
3877
open_temporary_table()
3879
path Path (without .frm)
3881
table_name Table name
3882
link_in_list 1 if table should be linked into thd->temporary_tables
3885
Used by alter_table to open a temporary table and when creating
3886
a temporary table with CREATE TEMPORARY ...
2337
Table *Session::open_temporary_table(TableIdentifier &identifier,
3893
TABLE *open_temporary_table(THD *thd, const char *path, const char *db,
3894
const char *table_name, bool link_in_list,
3895
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 |
3899
char cache_key[MAX_DBKEY_LENGTH], *saved_cache_key, *tmp_path;
3901
TABLE_LIST table_list;
3903
table_list.db= (char*) db;
3904
table_list.table_name= (char*) table_name;
3905
/* Create the cache_key for temporary tables */
3906
key_length= create_table_def_key(thd, cache_key, &table_list, 1);
3908
if (!(tmp_table= (TABLE*) my_malloc(sizeof(*tmp_table) + sizeof(*share) +
3909
strlen(path)+1 + key_length,
3911
return(0); /* purecov: inspected */
3913
share= (TABLE_SHARE*) (tmp_table+1);
3914
tmp_path= (char*) (share+1);
3915
saved_cache_key= strmov(tmp_path, path)+1;
3916
memcpy(saved_cache_key, cache_key, key_length);
3918
init_tmp_table_share(thd, share, saved_cache_key, key_length,
3919
strend(saved_cache_key)+1, tmp_path);
3921
if (open_table_def(thd, share, 0) ||
3922
open_table_from_share(thd, share, table_name,
3923
(open_mode == OTM_ALTER) ? 0 :
3924
(uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
3926
(open_mode == OTM_ALTER) ?
3927
(READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD |
3929
: (READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD),
2359
3930
ha_open_options,
3931
tmp_table, open_mode))
2362
3933
/* 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
3934
free_table_share(share);
3935
my_free((char*) tmp_table,MYF(0));
3939
tmp_table->reginfo.lock_type= TL_WRITE; // Simulate locked
3940
if (open_mode == OTM_ALTER)
3943
Temporary table has been created with frm_only
3944
and has not been created in any storage engine
3946
share->tmp_table= TMP_TABLE_FRM_FILE_ONLY;
3949
share->tmp_table= (tmp_table->file->has_transactions() ?
3950
TRANSACTIONAL_TMP_TABLE : NON_TRANSACTIONAL_TMP_TABLE);
2371
3952
if (link_in_list)
2373
3954
/* 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;
3955
tmp_table->next= thd->temporary_tables;
3956
if (tmp_table->next)
3957
tmp_table->next->prev= tmp_table;
3958
thd->temporary_tables= tmp_table;
3959
thd->temporary_tables->prev= 0;
3960
if (thd->slave_thread)
3961
slave_open_temp_tables++;
3963
tmp_table->pos_in_table_list= 0;
3968
bool rm_temporary_table(handlerton *base, char *path, bool frm_only)
3974
strmov(ext= strend(path), reg_ext);
3975
if (my_delete(path,MYF(0)))
3976
error=1; /* purecov: inspected */
3977
*ext= 0; // remove extension
3978
file= get_new_handler((TABLE_SHARE*) 0, current_thd->mem_root, base);
3979
if (!frm_only && file && file->ha_delete_table(path))
3982
sql_print_warning("Could not remove temporary table: '%s', error: %d",
2388
3990
/*****************************************************************************
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
******************************************************************************/
3991
* The following find_field_in_XXX procedures implement the core of the
3992
* name resolution functionality. The entry point to resolve a column name in a
3993
* list of tables is 'find_field_in_tables'. It calls 'find_field_in_table_ref'
3994
* for each table reference. In turn, depending on the type of table reference,
3995
* 'find_field_in_table_ref' calls one of the 'find_field_in_XXX' procedures
3996
* below specific for the type of table reference.
3997
******************************************************************************/
2397
3999
/* Special Field pointers as return values of find_field_in_XXX functions. */
2398
4000
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)
4001
Field *view_ref_found= (Field*) 0x2;
4003
#define WRONG_GRANT (Field*) -1
4005
static void update_field_dependencies(THD *thd, Field *field, TABLE *table)
2403
if (session->mark_used_columns != MARK_COLUMNS_NONE)
4007
if (thd->mark_used_columns != MARK_COLUMNS_NONE)
2405
MyBitmap *current_bitmap, *other_bitmap;
4009
MY_BITMAP *current_bitmap, *other_bitmap;
2408
4012
We always want to register the used keys, as the column bitmap may have
2409
4013
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)
4016
table->covering_keys.intersect(field->part_of_key);
4017
table->merge_keys.merge(field->part_of_key);
4019
if (thd->mark_used_columns == MARK_COLUMNS_READ)
2417
4021
current_bitmap= table->read_set;
2418
4022
other_bitmap= table->write_set;
2702
4434
natural join, thus if the field is not qualified, we will search
2703
4435
directly the top-most NATURAL/USING join.
2705
fld= find_field_in_natural_join(session, table_list, name, length, ref,
4437
fld= find_field_in_natural_join(thd, table_list, name, length, ref,
2706
4438
register_tree_change, actual_table);
2711
if (session->mark_used_columns != MARK_COLUMNS_NONE)
2714
Get rw_set correct for this field so that the Cursor
2715
knows that this field is involved in the query and gets
2718
Field *field_to_set= NULL;
2719
if (fld == view_ref_found)
2721
Item *it= (*ref)->real_item();
2722
if (it->type() == Item::FIELD_ITEM)
2723
field_to_set= ((Item_field*)it)->field;
2726
if (session->mark_used_columns == MARK_COLUMNS_READ)
2727
it->walk(&Item::register_field_in_read_map, 1, (unsigned char *) 0);
2734
Table *table= field_to_set->getTable();
2735
if (session->mark_used_columns == MARK_COLUMNS_READ)
2736
table->setReadSet(field_to_set->field_index);
2738
table->setWriteSet(field_to_set->field_index);
4443
if (thd->mark_used_columns != MARK_COLUMNS_NONE)
4446
Get rw_set correct for this field so that the handler
4447
knows that this field is involved in the query and gets
4450
Field *field_to_set= NULL;
4451
if (fld == view_ref_found)
4453
Item *it= (*ref)->real_item();
4454
if (it->type() == Item::FIELD_ITEM)
4455
field_to_set= ((Item_field*)it)->field;
4458
if (thd->mark_used_columns == MARK_COLUMNS_READ)
4459
it->walk(&Item::register_field_in_read_map, 1, (uchar *) 0);
4466
TABLE *table= field_to_set->table;
4467
if (thd->mark_used_columns == MARK_COLUMNS_READ)
4468
bitmap_set_bit(table->read_set, field_to_set->field_index);
4470
bitmap_set_bit(table->write_set, field_to_set->field_index);
4479
Find field in table, no side effects, only purpose is to check for field
4480
in table object and get reference to the field if found.
4483
find_field_in_table_sef()
4485
table table where to find
4486
name Name of field searched for
4489
0 field is not found
4493
Field *find_field_in_table_sef(TABLE *table, const char *name)
4496
if (table->s->name_hash.records)
4498
field_ptr= (Field**)hash_search(&table->s->name_hash,(uchar*) name,
4503
field_ptr points to field in TABLE_SHARE. Convert it to the matching
4506
field_ptr= (table->field + (field_ptr - table->s->field));
4511
if (!(field_ptr= table->field))
4513
for (; *field_ptr; ++field_ptr)
4514
if (!my_strcasecmp(system_charset_info, (*field_ptr)->field_name, name))
2747
4525
Find field in table list.
2750
find_field_in_tables()
2751
session pointer to current thread structure
2752
item field item that should be found
2753
first_table list of tables to be searched for item
2754
last_table end of the list of tables to search for item. If NULL
2755
then search to the end of the list 'first_table'.
2756
ref if 'item' is resolved to a view field, ref is set to
2757
point to the found view field
2758
report_error Degree of error reporting:
2759
- IGNORE_ERRORS then do not report any error
2760
- IGNORE_EXCEPT_NON_UNIQUE report only non-unique
2761
fields, suppress all other errors
2762
- REPORT_EXCEPT_NON_UNIQUE report all other errors
2763
except when non-unique fields were found
2765
register_tree_change true if ref is not a stack variable and we
2766
to need register changes in item tree
4528
find_field_in_tables()
4529
thd pointer to current thread structure
4530
item field item that should be found
4531
first_table list of tables to be searched for item
4532
last_table end of the list of tables to search for item. If NULL
4533
then search to the end of the list 'first_table'.
4534
ref if 'item' is resolved to a view field, ref is set to
4535
point to the found view field
4536
report_error Degree of error reporting:
4537
- IGNORE_ERRORS then do not report any error
4538
- IGNORE_EXCEPT_NON_UNIQUE report only non-unique
4539
fields, suppress all other errors
4540
- REPORT_EXCEPT_NON_UNIQUE report all other errors
4541
except when non-unique fields were found
4543
check_privileges need to check privileges
4544
register_tree_change true if ref is not a stack variable and we
4545
to need register changes in item tree
2769
0 If error: the found field is not unique, or there are
2770
no sufficient access priviliges for the found field,
2771
or the field is qualified with non-existing table.
2772
not_found_field The function was called with report_error ==
2773
(IGNORE_ERRORS || IGNORE_EXCEPT_NON_UNIQUE) and a
2774
field was not found.
2775
view_ref_found View field is found, item passed through ref parameter
2776
found field If a item was resolved to some field
4548
0 If error: the found field is not unique, or there are
4549
no sufficient access priviliges for the found field,
4550
or the field is qualified with non-existing table.
4551
not_found_field The function was called with report_error ==
4552
(IGNORE_ERRORS || IGNORE_EXCEPT_NON_UNIQUE) and a
4553
field was not found.
4554
view_ref_found View field is found, item passed through ref parameter
4555
found field If a item was resolved to some field
2780
find_field_in_tables(Session *session, Item_ident *item,
2781
TableList *first_table, TableList *last_table,
2782
Item **ref, find_item_error_report_type report_error,
2783
bool register_tree_change)
4559
find_field_in_tables(THD *thd, Item_ident *item,
4560
TABLE_LIST *first_table, TABLE_LIST *last_table,
4561
Item **ref, find_item_error_report_type report_error,
4562
bool check_privileges, bool register_tree_change)
2785
4564
Field *found=0;
2786
4565
const char *db= item->db_name;
2787
4566
const char *table_name= item->table_name;
2788
4567
const char *name= item->field_name;
2789
uint32_t length=(uint32_t) strlen(name);
4568
uint length=(uint) strlen(name);
2790
4569
char name_buff[NAME_LEN+1];
2791
TableList *cur_table= first_table;
2792
TableList *actual_table;
4570
TABLE_LIST *cur_table= first_table;
4571
TABLE_LIST *actual_table;
2793
4572
bool allow_rowid;
2795
4574
if (!table_name || !table_name[0])
4419
6319
On INSERT or UPDATE fields are checked to be from the same table,
4420
6320
thus we safely can take table from the first field.
4422
table= (*ptr)->getTable();
6322
table= (*ptr)->table;
4423
6323
table->auto_increment_field_not_null= false;
4425
while ((field = *ptr++) && ! session->is_error())
6325
while ((field = *ptr++) && ! thd->is_error())
4428
table= field->getTable();
6328
table= field->table;
4429
6329
if (field == table->next_number_field)
4430
6330
table->auto_increment_field_not_null= true;
4431
6331
if (value->save_in_field(field, 0) < 0)
4435
return(session->is_error());
6334
return(thd->is_error());
4439
6338
table->auto_increment_field_not_null= false;
4445
bool drizzle_rm_tmp_tables()
6343
my_bool mysql_rm_tmp_tables(void)
4449
assert(drizzle_tmpdir.size());
4451
if (!(session= new Session(plugin::Listen::getNullClient())))
4453
session->thread_stack= (char*) &session;
4454
session->storeGlobals();
4456
plugin::StorageEngine::removeLostTemporaryTables(*session, drizzle_tmpdir.c_str());
4458
session->lockForDelete();
6346
char filePath[FN_REFLEN], *tmpdir, filePathCopy[FN_REFLEN];
6352
if (!(thd= new THD))
6354
thd->thread_stack= (char*) &thd;
6355
thd->store_globals();
6357
for (i=0; i<=mysql_tmpdir_list.max; i++)
6359
tmpdir=mysql_tmpdir_list.list[i];
6360
/* See if the directory exists */
6361
if (!(dirp = my_dir(tmpdir,MYF(MY_WME | MY_DONT_SORT))))
6364
/* Remove all SQLxxx tables from directory */
6366
for (idx=0 ; idx < (uint) dirp->number_off_files ; idx++)
6368
file=dirp->dir_entry+idx;
6370
/* skiping . and .. */
6371
if (file->name[0] == '.' && (!file->name[1] ||
6372
(file->name[1] == '.' && !file->name[2])))
6375
if (!bcmp((uchar*) file->name, (uchar*) tmp_file_prefix,
6376
tmp_file_prefix_length))
6378
char *ext= fn_ext(file->name);
6379
uint ext_len= strlen(ext);
6380
uint filePath_len= snprintf(filePath, sizeof(filePath),
6381
"%s%c%s", tmpdir, FN_LIBCHAR,
6383
if (!bcmp((uchar*) reg_ext, (uchar*) ext, ext_len))
6385
handler *handler_file= 0;
6386
/* We should cut file extention before deleting of table */
6387
memcpy(filePathCopy, filePath, filePath_len - ext_len);
6388
filePathCopy[filePath_len - ext_len]= 0;
6389
init_tmp_table_share(thd, &share, "", 0, "", filePathCopy);
6390
if (!open_table_def(thd, &share, 0) &&
6391
((handler_file= get_new_handler(&share, thd->mem_root,
6394
handler_file->ha_delete_table(filePathCopy);
6395
delete handler_file;
6397
free_table_share(&share);
6400
File can be already deleted by tmp_table.file->delete_table().
6401
So we hide error messages which happnes during deleting of these
6404
VOID(my_delete(filePath, MYF(0)));
6410
my_pthread_setspecific_ptr(THR_THD, 0);
4466
6416
/*****************************************************************************
4467
unireg support functions
4468
*****************************************************************************/
6417
unireg support functions
6418
*****************************************************************************/
4471
6421
Invalidate any cache entries that are for some DB
4474
remove_db_from_cache()
4475
db Database name. This will be in lower case if
4476
lower_case_table_name is set
6424
remove_db_from_cache()
6425
db Database name. This will be in lower case if
6426
lower_case_table_name is set
4479
We can't use hash_delete when looping hash_elements. We mark them first
4480
and afterwards delete those marked unused.
6429
We can't use hash_delete when looping hash_elements. We mark them first
6430
and afterwards delete those marked unused.
4483
void remove_db_from_cache(const SchemaIdentifier &schema_identifier)
6433
void remove_db_from_cache(const char *db)
4485
safe_mutex_assert_owner(LOCK_open.native_handle());
4487
for (TableOpenCache::const_iterator iter= get_open_cache().begin();
4488
iter != get_open_cache().end();
6435
for (uint idx=0 ; idx < open_cache.records ; idx++)
4491
Table *table= (*iter).second;
4493
if (not schema_identifier.getPath().compare(table->getMutableShare()->getSchemaName()))
6437
TABLE *table=(TABLE*) hash_element(&open_cache,idx);
6438
if (!strcmp(table->s->db.str, db))
4495
table->getMutableShare()->resetVersion(); /* Free when thread is ready */
4496
if (not table->in_use)
4497
unused_tables.relink(table);
6440
table->s->version= 0L; /* Free when thread is ready */
6442
relink_unused(table);
4501
unused_tables.cullByVersion();
6445
while (unused_tables && !unused_tables->s->version)
6446
VOID(hash_delete(&open_cache,(uchar*) unused_tables));
6451
free all unused tables
6454
This is called by 'handle_manager' when one wants to periodicly flush
6455
all not used tables.
6460
(void) pthread_mutex_lock(&LOCK_open);
6461
while (unused_tables)
6462
hash_delete(&open_cache,(uchar*) unused_tables);
6463
(void) pthread_mutex_unlock(&LOCK_open);
added
removed
server/sql_base.cc
