96
96
static pthread_mutex_t LOCK_table_share;
97
97
static bool table_def_inited= 0;
100
Dummy TABLE instance which is used in reopen_tables() and reattach_merge()
101
functions to mark MERGE tables and their children with which there is some
102
kind of problem and which therefore we need to close.
104
static TABLE bad_merge_marker;
99
106
static int open_unireg_entry(THD *thd, TABLE *entry, TABLE_LIST *table_list,
100
107
const char *alias,
101
108
char *cache_key, uint cache_key_length,
2798
2805
("Found table '%s.%s' with different refresh version",
2799
2806
table_list->db, table_list->table_name));
2801
/* Ignore FLUSH, but not name locks! */
2808
/* Ignore FLUSH and pending name locks, but not acquired name locks! */
2802
2809
if (flags & MYSQL_LOCK_IGNORE_FLUSH && !table->open_placeholder)
2804
DBUG_ASSERT(table->db_stat);
2805
2811
/* Force close at once after usage */
2806
2812
thd->version= table->s->version;
3225
@brief Mark merge parent and children with bad_merge_marker
3227
@param[in,out] parent the TABLE object of the parent
3230
static void mark_merge_parent_and_children_as_bad(TABLE *parent)
3232
TABLE_LIST *child_l;
3233
DBUG_ENTER("mark_merge_parent_and_children_as_bad");
3234
parent->parent= &bad_merge_marker;
3235
for (child_l= parent->child_l; ; child_l= child_l->next_global)
3237
child_l->table->parent= &bad_merge_marker;
3238
child_l->table= NULL;
3239
if (&child_l->next_global == parent->child_last_l)
3216
3247
Reattach MERGE children after reopen.
3218
3249
@param[in] thd thread context
3219
@param[in,out] err_tables_p pointer to pointer of tables in error
3251
@note If reattach failed for certain MERGE table, the table (and all
3252
it's children) are marked with bad_merge_marker.
3222
@retval FALSE OK, err_tables_p unchanged
3223
@retval TRUE Error, err_tables_p contains table(s)
3226
static bool reattach_merge(THD *thd, TABLE **err_tables_p)
3259
static bool reattach_merge(THD *thd)
3230
TABLE **prv_p= &thd->open_tables;
3231
3262
bool error= FALSE;
3232
3263
DBUG_ENTER("reattach_merge");
3234
for (table= thd->open_tables; table; table= next)
3265
for (table= thd->open_tables; table; table= table->next)
3237
DBUG_PRINT("tcache", ("check table: '%s'.'%s' 0x%lx next: 0x%lx",
3267
DBUG_PRINT("tcache", ("check table: '%s'.'%s' 0x%lx",
3238
3268
table->s->db.str, table->s->table_name.str,
3239
(long) table, (long) next));
3240
/* Reattach children for MERGE tables with "closed data files" only. */
3241
if (table->child_l && !table->children_attached)
3271
Reattach children only for MERGE tables that had children or parent
3272
with "closed data files" and were reopen. For extra safety skip MERGE
3273
tables which we failed to reopen (should not happen with current code).
3275
if (table->child_l && table->parent != &bad_merge_marker &&
3276
!table->children_attached)
3243
3278
DBUG_PRINT("tcache", ("MERGE parent, attach children"));
3244
if(table->file->extra(HA_EXTRA_ATTACH_CHILDREN))
3279
if (table->file->extra(HA_EXTRA_ATTACH_CHILDREN))
3246
3281
my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
3248
/* Remove table from open_tables. */
3252
/* Stack table on error list. */
3253
table->next= *err_tables_p;
3254
*err_tables_p= table;
3283
mark_merge_parent_and_children_as_bad(table);
3326
3352
for (table=thd->open_tables; table ; table=next)
3328
3354
uint db_stat=table->db_stat;
3355
TABLE *parent= table->child_l ? table : table->parent;
3329
3356
next=table->next;
3330
3357
DBUG_PRINT("tcache", ("open table: '%s'.'%s' 0x%lx "
3331
3358
"parent: 0x%lx db_stat: %u",
3332
3359
table->s->db.str, table->s->table_name.str,
3333
3360
(long) table, (long) table->parent, db_stat));
3334
if (table->child_l && !db_stat)
3362
If we need to reopen child or parent table in a MERGE table, then
3363
children in this MERGE table has to be already detached at this
3366
DBUG_ASSERT(db_stat || !parent || !parent->children_attached);
3368
Thanks to the above assumption the below condition will guarantee that
3369
merge_table_found is TRUE when we need to reopen child or parent table.
3370
Note that it works even in situation when it is only a child and not a
3371
parent that needs reopen (this can happen when get_locks == FALSE).
3373
if (table->child_l && !table->children_attached)
3335
3374
merge_table_found= TRUE;
3336
if (!tables || (!db_stat && reopen_table(table)))
3338
my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
3340
If we could not allocate 'tables', we may close open tables
3341
here. If a MERGE table is affected, detach the children first.
3342
It is not necessary to clear the child or parent table reference
3343
of this table because the TABLE is freed. But we need to clear
3344
the child or parent references of the other belonging tables so
3345
that they cannot be moved into the unused_tables chain with
3379
If we could not allocate 'tables' we close ALL open tables here.
3380
Before closing MERGE child or parent we need to detach children
3381
and/or clear references in/to them.
3348
if (table->child_l || table->parent)
3349
3384
detach_merge_children(table, TRUE);
3350
VOID(hash_delete(&open_cache,(uchar*) table));
3386
else if (table->parent == &bad_merge_marker)
3389
This is either a child or a parent of a MERGE table for which
3390
we already decided that we are unable to reopen it. Close it.
3392
Reset parent reference, it may be used while freeing the table.
3394
table->parent= NULL;
3396
else if (!db_stat && reopen_table(table))
3399
If we fail to reopen a child or a parent in a MERGE table and the
3400
MERGE table is affected for the first time, mark all relevant tables
3401
invalid. Otherwise handle it as usual.
3403
All in all we must end up with:
3404
- child tables are detached from parent. This was done earlier,
3405
but child<->parent references were kept valid for reopen.
3406
- parent is not in the to-be-locked tables
3407
- all child tables and parent are not in the THD::open_tables.
3408
- all child tables and parent are not in the open_cache.
3410
Please note that below we do additional pass through THD::open_tables
3411
list to achieve the last three points.
3415
mark_merge_parent_and_children_as_bad(parent);
3416
table->parent= NULL;
3364
3430
table->s->version=0;
3365
3431
table->open_placeholder= 0;
3435
my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
3436
VOID(hash_delete(&open_cache, (uchar *) table));
3371
3441
When all tables are open again, we can re-attach MERGE children to
3372
their parents. All TABLE objects are still present.
3444
If there was an error while reopening a child or a parent of a MERGE
3445
table, or while reattaching child tables to their parents, some tables
3446
may have been kept open but marked for close with bad_merge_marker.
3447
Close these tables now.
3374
DBUG_PRINT("tcache", ("re-attaching MERGE tables: %d", merge_table_found));
3375
if (!error && merge_table_found && reattach_merge(thd, &err_tables))
3449
if (tables && merge_table_found && (error|= reattach_merge(thd)))
3451
prev= &thd->open_tables;
3452
for (table= thd->open_tables; table; table= next)
3379
VOID(hash_delete(&open_cache, (uchar*) err_tables));
3380
err_tables= err_tables->next;
3455
if (table->parent == &bad_merge_marker)
3457
/* Remove merge parent from to-be-locked tables array. */
3458
if (get_locks && table->child_l)
3461
for (t= tables; t < tables_ptr; t++)
3466
memmove(t, t + 1, (tables_ptr - t) * sizeof(TABLE *));
3471
/* Reset parent reference, it may be used while freeing the table. */
3472
table->parent= NULL;
3474
VOID(hash_delete(&open_cache, (uchar *) table));
3383
3484
DBUG_PRINT("tcache", ("open tables to lock: %u",
3384
3485
(uint) (tables_ptr - tables)));
5685
5786
table->merge_keys.merge(field->part_of_key);
5687
5788
if (thd->mark_used_columns == MARK_COLUMNS_READ)
5689
current_bitmap= table->read_set;
5690
other_bitmap= table->write_set;
5789
bitmap= table->read_set;
5694
current_bitmap= table->write_set;
5695
other_bitmap= table->read_set;
5791
bitmap= table->write_set;
5699
5794
The test-and-set mechanism in the bitmap is not reliable during
6324
6423
when table_ref->field_translation != NULL.
6326
6425
if (table_ref->table && !table_ref->view)
6327
6427
found= find_field_in_table(thd, table_ref->table, name, length,
6328
6428
TRUE, &(item->cached_field_index));
6429
#ifndef NO_EMBEDDED_ACCESS_CHECKS
6430
/* Check if there are sufficient access rights to the found field. */
6431
if (found && check_privileges &&
6432
check_column_grant_in_table_ref(thd, table_ref, name, length))
6330
6437
found= find_field_in_table_ref(thd, table_ref, name, length, item->name,
6331
6438
NULL, NULL, ref, check_privileges,
8403
8510
(file->name[1] == '.' && !file->name[2])))
8406
if (!bcmp((uchar*) file->name, (uchar*) tmp_file_prefix,
8407
tmp_file_prefix_length))
8513
if (!memcmp(file->name, tmp_file_prefix,
8514
tmp_file_prefix_length))
8409
8516
char *ext= fn_ext(file->name);
8410
8517
uint ext_len= strlen(ext);
8411
8518
uint filePath_len= my_snprintf(filePath, sizeof(filePath),
8412
8519
"%s%c%s", tmpdir, FN_LIBCHAR,
8414
if (!bcmp((uchar*) reg_ext, (uchar*) ext, ext_len))
8521
if (!memcmp(reg_ext, ext, ext_len))
8416
8523
handler *handler_file= 0;
8417
8524
/* We should cut file extention before deleting of table */
added
removed
sql/sql_base.cc
