1
/*****************************************************************************
3
Copyright (c) 2000, 2009, Innobase Oy. All Rights Reserved.
5
This program is free software; you can redistribute it and/or modify it under
6
the terms of the GNU General Public License as published by the Free Software
7
Foundation; version 2 of the License.
9
This program is distributed in the hope that it will be useful, but WITHOUT
10
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
13
You should have received a copy of the GNU General Public License along with
14
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
15
Place, Suite 330, Boston, MA 02111-1307 USA
17
*****************************************************************************/
19
/**************************************************//**
21
Interface between Innobase row operations and MySQL.
22
Contains also create table and other data dictionary operations.
24
Created 9/17/2000 Heikki Tuuri
25
*******************************************************/
27
#include "row0mysql.h"
30
#include "row0mysql.ic"
34
#include "row0merge.h"
39
#include "pars0pars.h"
40
#include "dict0dict.h"
41
#include "dict0crea.h"
42
#include "dict0load.h"
43
#include "dict0boot.h"
45
#include "trx0purge.h"
48
#include "lock0lock.h"
53
#include "ibuf0ibuf.h"
57
/** Provide optional 4.x backwards compatibility for 5.0 and above */
58
UNIV_INTERN ibool row_rollback_on_timeout = FALSE;
60
/** Chain node of the list of tables to drop in the background. */
61
typedef struct row_mysql_drop_struct row_mysql_drop_t;
63
/** Chain node of the list of tables to drop in the background. */
64
struct row_mysql_drop_struct{
65
char* table_name; /*!< table name */
66
UT_LIST_NODE_T(row_mysql_drop_t)row_mysql_drop_list;
67
/*!< list chain node */
70
/** @brief List of tables we should drop in background.
72
ALTER TABLE in MySQL requires that the table handler can drop the
73
table in background when there are no queries to it any
74
more. Protected by kernel_mutex. */
75
static UT_LIST_BASE_NODE_T(row_mysql_drop_t) row_mysql_drop_list;
76
/** Flag: has row_mysql_drop_list been initialized? */
77
static ibool row_mysql_drop_list_inited = FALSE;
79
/** Magic table names for invoking various monitor threads */
81
static const char S_innodb_monitor[] = "innodb_monitor";
82
static const char S_innodb_lock_monitor[] = "innodb_lock_monitor";
83
static const char S_innodb_tablespace_monitor[] = "innodb_tablespace_monitor";
84
static const char S_innodb_table_monitor[] = "innodb_table_monitor";
85
static const char S_innodb_mem_validate[] = "innodb_mem_validate";
88
/** Evaluates to true if str1 equals str2_onstack, used for comparing
89
the magic table names.
90
@param str1 in: string to compare
91
@param str1_len in: length of str1, in bytes, including terminating NUL
92
@param str2_onstack in: char[] array containing a NUL terminated string
93
@return TRUE if str1 equals str2_onstack */
94
#define STR_EQ(str1, str1_len, str2_onstack) \
95
((str1_len) == sizeof(str2_onstack) \
96
&& memcmp(str1, str2_onstack, sizeof(str2_onstack)) == 0)
98
/*******************************************************************//**
99
Determine if the given name is a name reserved for MySQL system tables.
100
@return TRUE if name is a MySQL system table name */
103
row_mysql_is_system_table(
104
/*======================*/
107
if (strncmp(name, "mysql/", 6) != 0) {
112
return(0 == strcmp(name + 6, "host")
113
|| 0 == strcmp(name + 6, "user")
114
|| 0 == strcmp(name + 6, "db"));
117
/*********************************************************************//**
118
If a table is not yet in the drop list, adds the table to the list of tables
119
which the master thread drops in background. We need this on Unix because in
120
ALTER TABLE MySQL may call drop table even if the table has running queries on
121
it. Also, if there are running foreign key checks on the table, we drop the
123
@return TRUE if the table was not yet in the drop list, and was added there */
126
row_add_table_to_background_drop_list(
127
/*==================================*/
128
const char* name); /*!< in: table name */
130
/*******************************************************************//**
131
Delays an INSERT, DELETE or UPDATE operation if the purge is lagging. */
134
row_mysql_delay_if_needed(void)
135
/*===========================*/
137
if (srv_dml_needed_delay) {
138
os_thread_sleep(srv_dml_needed_delay);
142
/*******************************************************************//**
143
Frees the blob heap in prebuilt when no longer needed. */
146
row_mysql_prebuilt_free_blob_heap(
147
/*==============================*/
148
row_prebuilt_t* prebuilt) /*!< in: prebuilt struct of a
149
ha_innobase:: table handle */
151
mem_heap_free(prebuilt->blob_heap);
152
prebuilt->blob_heap = NULL;
155
/*******************************************************************//**
156
Stores a >= 5.0.3 format true VARCHAR length to dest, in the MySQL row
158
@return pointer to the data, we skip the 1 or 2 bytes at the start
159
that are used to store the len */
162
row_mysql_store_true_var_len(
163
/*=========================*/
164
byte* dest, /*!< in: where to store */
165
ulint len, /*!< in: length, must fit in two bytes */
166
ulint lenlen) /*!< in: storage length of len: either 1 or 2 bytes */
169
ut_a(len < 256 * 256);
171
mach_write_to_2_little_endian(dest, len);
179
mach_write_to_1(dest, len);
184
/*******************************************************************//**
185
Reads a >= 5.0.3 format true VARCHAR length, in the MySQL row format, and
186
returns a pointer to the data.
187
@return pointer to the data, we skip the 1 or 2 bytes at the start
188
that are used to store the len */
191
row_mysql_read_true_varchar(
192
/*========================*/
193
ulint* len, /*!< out: variable-length field length */
194
const byte* field, /*!< in: field in the MySQL format */
195
ulint lenlen) /*!< in: storage length of len: either 1
199
*len = mach_read_from_2_little_endian(field);
206
*len = mach_read_from_1(field);
211
/*******************************************************************//**
212
Stores a reference to a BLOB in the MySQL format. */
215
row_mysql_store_blob_ref(
216
/*=====================*/
217
byte* dest, /*!< in: where to store */
218
ulint col_len,/*!< in: dest buffer size: determines into
219
how many bytes the BLOB length is stored,
220
the space for the length may vary from 1
222
const void* data, /*!< in: BLOB data; if the value to store
223
is SQL NULL this should be NULL pointer */
224
ulint len) /*!< in: BLOB length; if the value to store
225
is SQL NULL this should be 0; remember
226
also to set the NULL bit in the MySQL record
229
/* MySQL might assume the field is set to zero except the length and
230
the pointer fields */
232
memset(dest, '\0', col_len);
234
/* In dest there are 1 - 4 bytes reserved for the BLOB length,
235
and after that 8 bytes reserved for the pointer to the data.
236
In 32-bit architectures we only use the first 4 bytes of the pointer
239
ut_a(col_len - 8 > 1 || len < 256);
240
ut_a(col_len - 8 > 2 || len < 256 * 256);
241
ut_a(col_len - 8 > 3 || len < 256 * 256 * 256);
243
mach_write_to_n_little_endian(dest, col_len - 8, len);
245
memcpy(dest + col_len - 8, &data, sizeof data);
248
/*******************************************************************//**
249
Reads a reference to a BLOB in the MySQL format.
250
@return pointer to BLOB data */
253
row_mysql_read_blob_ref(
254
/*====================*/
255
ulint* len, /*!< out: BLOB length */
256
const byte* ref, /*!< in: BLOB reference in the
258
ulint col_len) /*!< in: BLOB reference length
263
*len = mach_read_from_n_little_endian(ref, col_len - 8);
265
memcpy(&data, ref + col_len - 8, sizeof data);
270
/**************************************************************//**
271
Stores a non-SQL-NULL field given in the MySQL format in the InnoDB format.
272
The counterpart of this function is row_sel_field_store_in_mysql_format() in
274
@return up to which byte we used buf in the conversion */
277
row_mysql_store_col_in_innobase_format(
278
/*===================================*/
279
dfield_t* dfield, /*!< in/out: dfield where dtype
280
information must be already set when
281
this function is called! */
282
byte* buf, /*!< in/out: buffer for a converted
283
integer value; this must be at least
284
col_len long then! */
285
ibool row_format_col, /*!< TRUE if the mysql_data is from
286
a MySQL row, FALSE if from a MySQL
288
in MySQL, a true VARCHAR storage
289
format differs in a row and in a
290
key value: in a key value the length
291
is always stored in 2 bytes! */
292
const byte* mysql_data, /*!< in: MySQL column value, not
293
SQL NULL; NOTE that dfield may also
294
get a pointer to mysql_data,
295
therefore do not discard this as long
296
as dfield is used! */
297
ulint col_len, /*!< in: MySQL column length; NOTE that
298
this is the storage length of the
299
column in the MySQL format row, not
300
necessarily the length of the actual
301
payload data; if the column is a true
302
VARCHAR then this is irrelevant */
303
ulint comp) /*!< in: nonzero=compact format */
305
const byte* ptr = mysql_data;
306
const dtype_t* dtype;
310
dtype = dfield_get_type(dfield);
314
if (type == DATA_INT) {
315
/* Store integer data in Innobase in a big-endian format,
316
sign bit negated if the data is a signed integer. In MySQL,
317
integers are stored in a little-endian format. */
319
byte* p = buf + col_len;
330
if (!(dtype->prtype & DATA_UNSIGNED)) {
337
} else if ((type == DATA_VARCHAR
338
|| type == DATA_VARMYSQL
339
|| type == DATA_BINARY)) {
341
if (dtype_get_mysql_type(dtype) == DATA_MYSQL_TRUE_VARCHAR) {
342
/* The length of the actual data is stored to 1 or 2
343
bytes at the start of the field */
345
if (row_format_col) {
346
if (dtype->prtype & DATA_LONG_TRUE_VARCHAR) {
352
/* In a MySQL key value, lenlen is always 2 */
356
ptr = row_mysql_read_true_varchar(&col_len, mysql_data,
359
/* Remove trailing spaces from old style VARCHAR
362
/* Handle UCS2 strings differently. */
363
ulint mbminlen = dtype_get_mbminlen(dtype);
369
/* Trim "half-chars", just in case. */
372
while (col_len >= 2 && ptr[col_len - 2] == 0x00
373
&& ptr[col_len - 1] == 0x20) {
380
&& ptr[col_len - 1] == 0x20) {
385
} else if (comp && type == DATA_MYSQL
386
&& dtype_get_mbminlen(dtype) == 1
387
&& dtype_get_mbmaxlen(dtype) > 1) {
388
/* In some cases we strip trailing spaces from UTF-8 and other
389
multibyte charsets, from FIXED-length CHAR columns, to save
390
space. UTF-8 would otherwise normally use 3 * the string length
391
bytes to store an ASCII string! */
393
/* We assume that this CHAR field is encoded in a
394
variable-length character set where spaces have
395
1:1 correspondence to 0x20 bytes, such as UTF-8.
397
Consider a CHAR(n) field, a field of n characters.
398
It will contain between n * mbminlen and n * mbmaxlen bytes.
399
We will try to truncate it to n bytes by stripping
400
space padding. If the field contains single-byte
401
characters only, it will be truncated to n characters.
402
Consider a CHAR(5) field containing the string ".a "
403
where "." denotes a 3-byte character represented by
404
the bytes "$%&". After our stripping, the string will
405
be stored as "$%&a " (5 bytes). The string ".abc "
406
will be stored as "$%&abc" (6 bytes).
408
The space padding will be restored in row0sel.c, function
409
row_sel_field_store_in_mysql_format(). */
413
ut_a(!(dtype_get_len(dtype) % dtype_get_mbmaxlen(dtype)));
415
n_chars = dtype_get_len(dtype) / dtype_get_mbmaxlen(dtype);
417
/* Strip space padding. */
418
while (col_len > n_chars && ptr[col_len - 1] == 0x20) {
421
} else if (type == DATA_BLOB && row_format_col) {
423
ptr = row_mysql_read_blob_ref(&col_len, mysql_data, col_len);
426
dfield_set_data(dfield, ptr, col_len);
431
/**************************************************************//**
432
Convert a row in the MySQL format to a row in the Innobase format. Note that
433
the function to convert a MySQL format key value to an InnoDB dtuple is
434
row_sel_convert_mysql_key_to_innobase() in row0sel.c. */
437
row_mysql_convert_row_to_innobase(
438
/*==============================*/
439
dtuple_t* row, /*!< in/out: Innobase row where the
440
field type information is already
442
row_prebuilt_t* prebuilt, /*!< in: prebuilt struct where template
443
must be of type ROW_MYSQL_WHOLE_ROW */
444
byte* mysql_rec) /*!< in: row in the MySQL format;
445
NOTE: do not discard as long as
446
row is used, as row may contain
447
pointers to this record! */
449
mysql_row_templ_t* templ;
453
ut_ad(prebuilt->template_type == ROW_MYSQL_WHOLE_ROW);
454
ut_ad(prebuilt->mysql_template);
456
for (i = 0; i < prebuilt->n_template; i++) {
458
templ = prebuilt->mysql_template + i;
459
dfield = dtuple_get_nth_field(row, i);
461
if (templ->mysql_null_bit_mask != 0) {
462
/* Column may be SQL NULL */
464
if (mysql_rec[templ->mysql_null_byte_offset]
465
& (byte) (templ->mysql_null_bit_mask)) {
469
dfield_set_null(dfield);
475
row_mysql_store_col_in_innobase_format(
477
prebuilt->ins_upd_rec_buff + templ->mysql_col_offset,
478
TRUE, /* MySQL row format data */
479
mysql_rec + templ->mysql_col_offset,
480
templ->mysql_col_len,
481
dict_table_is_comp(prebuilt->table));
487
/****************************************************************//**
488
Handles user errors and lock waits detected by the database engine.
489
@return TRUE if it was a lock wait and we should continue running the
493
row_mysql_handle_errors(
494
/*====================*/
495
ulint* new_err,/*!< out: possible new error encountered in
496
lock wait, or if no new error, the value
497
of trx->error_state at the entry of this
499
trx_t* trx, /*!< in: transaction */
500
que_thr_t* thr, /*!< in: query thread */
501
trx_savept_t* savept) /*!< in: savepoint or NULL */
506
err = trx->error_state;
508
ut_a(err != DB_SUCCESS);
510
trx->error_state = DB_SUCCESS;
513
case DB_LOCK_WAIT_TIMEOUT:
514
if (row_rollback_on_timeout) {
515
trx_general_rollback_for_mysql(trx, FALSE, NULL);
519
case DB_DUPLICATE_KEY:
520
case DB_FOREIGN_DUPLICATE_KEY:
521
case DB_TOO_BIG_RECORD:
522
case DB_ROW_IS_REFERENCED:
523
case DB_NO_REFERENCED_ROW:
524
case DB_CANNOT_ADD_CONSTRAINT:
525
case DB_TOO_MANY_CONCURRENT_TRXS:
526
case DB_OUT_OF_FILE_SPACE:
528
/* Roll back the latest, possibly incomplete
529
insertion or update */
531
trx_general_rollback_for_mysql(trx, TRUE, savept);
533
/* MySQL will roll back the latest SQL statement */
536
srv_suspend_mysql_thread(thr);
538
if (trx->error_state != DB_SUCCESS) {
539
que_thr_stop_for_mysql(thr);
541
goto handle_new_error;
549
case DB_LOCK_TABLE_FULL:
550
/* Roll back the whole transaction; this resolution was added
551
to version 3.23.43 */
553
trx_general_rollback_for_mysql(trx, FALSE, NULL);
556
case DB_MUST_GET_MORE_FILE_SPACE:
557
fputs("InnoDB: The database cannot continue"
558
" operation because of\n"
559
"InnoDB: lack of space. You must add"
560
" a new data file to\n"
561
"InnoDB: my.cnf and restart the database.\n", stderr);
566
fputs("InnoDB: We detected index corruption"
567
" in an InnoDB type table.\n"
568
"InnoDB: You have to dump + drop + reimport"
569
" the table or, in\n"
570
"InnoDB: a case of widespread corruption,"
572
"InnoDB: tables and recreate the"
573
" whole InnoDB tablespace.\n"
574
"InnoDB: If the mysqld server crashes"
575
" after the startup or when\n"
576
"InnoDB: you dump the tables, look at\n"
577
"InnoDB: " REFMAN "forcing-recovery.html"
578
" for help.\n", stderr);
581
fprintf(stderr, "InnoDB: unknown error code %lu\n",
586
if (trx->error_state != DB_SUCCESS) {
587
*new_err = trx->error_state;
592
trx->error_state = DB_SUCCESS;
597
/********************************************************************//**
598
Create a prebuilt struct for a MySQL table handle.
599
@return own: a prebuilt struct */
604
dict_table_t* table) /*!< in: Innobase table handle */
606
row_prebuilt_t* prebuilt;
608
dict_index_t* clust_index;
612
heap = mem_heap_create(sizeof *prebuilt + 128);
614
prebuilt = mem_heap_zalloc(heap, sizeof *prebuilt);
616
prebuilt->magic_n = ROW_PREBUILT_ALLOCATED;
617
prebuilt->magic_n2 = ROW_PREBUILT_ALLOCATED;
619
prebuilt->table = table;
621
prebuilt->sql_stat_start = TRUE;
622
prebuilt->heap = heap;
624
prebuilt->pcur = btr_pcur_create_for_mysql();
625
prebuilt->clust_pcur = btr_pcur_create_for_mysql();
627
prebuilt->select_lock_type = LOCK_NONE;
628
prebuilt->stored_select_lock_type = 99999999;
630
prebuilt->search_tuple = dtuple_create(
631
heap, 2 * dict_table_get_n_cols(table));
633
clust_index = dict_table_get_first_index(table);
635
/* Make sure that search_tuple is long enough for clustered index */
636
ut_a(2 * dict_table_get_n_cols(table) >= clust_index->n_fields);
638
ref_len = dict_index_get_n_unique(clust_index);
640
ref = dtuple_create(heap, ref_len);
642
dict_index_copy_types(ref, clust_index, ref_len);
644
prebuilt->clust_ref = ref;
646
prebuilt->autoinc_error = 0;
647
prebuilt->autoinc_offset = 0;
649
/* Default to 1, we will set the actual value later in
650
ha_innobase::get_auto_increment(). */
651
prebuilt->autoinc_increment = 1;
653
prebuilt->autoinc_last_value = 0;
658
/********************************************************************//**
659
Free a prebuilt struct for a MySQL table handle. */
664
row_prebuilt_t* prebuilt, /*!< in, own: prebuilt struct */
665
ibool dict_locked) /*!< in: TRUE=data dictionary locked */
670
(prebuilt->magic_n != ROW_PREBUILT_ALLOCATED
671
|| prebuilt->magic_n2 != ROW_PREBUILT_ALLOCATED)) {
674
"InnoDB: Error: trying to free a corrupt\n"
675
"InnoDB: table handle. Magic n %lu,"
676
" magic n2 %lu, table name ",
677
(ulong) prebuilt->magic_n,
678
(ulong) prebuilt->magic_n2);
679
ut_print_name(stderr, NULL, TRUE, prebuilt->table->name);
682
mem_analyze_corruption(prebuilt);
687
prebuilt->magic_n = ROW_PREBUILT_FREED;
688
prebuilt->magic_n2 = ROW_PREBUILT_FREED;
690
btr_pcur_free_for_mysql(prebuilt->pcur);
691
btr_pcur_free_for_mysql(prebuilt->clust_pcur);
693
if (prebuilt->mysql_template) {
694
mem_free(prebuilt->mysql_template);
697
if (prebuilt->ins_graph) {
698
que_graph_free_recursive(prebuilt->ins_graph);
701
if (prebuilt->sel_graph) {
702
que_graph_free_recursive(prebuilt->sel_graph);
705
if (prebuilt->upd_graph) {
706
que_graph_free_recursive(prebuilt->upd_graph);
709
if (prebuilt->blob_heap) {
710
mem_heap_free(prebuilt->blob_heap);
713
if (prebuilt->old_vers_heap) {
714
mem_heap_free(prebuilt->old_vers_heap);
717
for (i = 0; i < MYSQL_FETCH_CACHE_SIZE; i++) {
718
if (prebuilt->fetch_cache[i] != NULL) {
720
if ((ROW_PREBUILT_FETCH_MAGIC_N != mach_read_from_4(
721
(prebuilt->fetch_cache[i]) - 4))
722
|| (ROW_PREBUILT_FETCH_MAGIC_N != mach_read_from_4(
723
(prebuilt->fetch_cache[i])
724
+ prebuilt->mysql_row_len))) {
725
fputs("InnoDB: Error: trying to free"
726
" a corrupt fetch buffer.\n", stderr);
728
mem_analyze_corruption(
729
prebuilt->fetch_cache[i]);
734
mem_free((prebuilt->fetch_cache[i]) - 4);
738
dict_table_decrement_handle_count(prebuilt->table, dict_locked);
740
mem_heap_free(prebuilt->heap);
743
/*********************************************************************//**
744
Updates the transaction pointers in query graphs stored in the prebuilt
748
row_update_prebuilt_trx(
749
/*====================*/
750
row_prebuilt_t* prebuilt, /*!< in/out: prebuilt struct
752
trx_t* trx) /*!< in: transaction handle */
754
if (trx->magic_n != TRX_MAGIC_N) {
756
"InnoDB: Error: trying to use a corrupt\n"
757
"InnoDB: trx handle. Magic n %lu\n",
758
(ulong) trx->magic_n);
760
mem_analyze_corruption(trx);
765
if (prebuilt->magic_n != ROW_PREBUILT_ALLOCATED) {
767
"InnoDB: Error: trying to use a corrupt\n"
768
"InnoDB: table handle. Magic n %lu, table name ",
769
(ulong) prebuilt->magic_n);
770
ut_print_name(stderr, trx, TRUE, prebuilt->table->name);
773
mem_analyze_corruption(prebuilt);
780
if (prebuilt->ins_graph) {
781
prebuilt->ins_graph->trx = trx;
784
if (prebuilt->upd_graph) {
785
prebuilt->upd_graph->trx = trx;
788
if (prebuilt->sel_graph) {
789
prebuilt->sel_graph->trx = trx;
793
/*********************************************************************//**
794
Gets pointer to a prebuilt dtuple used in insertions. If the insert graph
795
has not yet been built in the prebuilt struct, then this function first
797
@return prebuilt dtuple; the column type information is also set in it */
800
row_get_prebuilt_insert_row(
801
/*========================*/
802
row_prebuilt_t* prebuilt) /*!< in: prebuilt struct in MySQL
807
dict_table_t* table = prebuilt->table;
809
ut_ad(prebuilt && table && prebuilt->trx);
811
if (prebuilt->ins_node == NULL) {
813
/* Not called before for this handle: create an insert node
814
and query graph to the prebuilt struct */
816
node = ins_node_create(INS_DIRECT, table, prebuilt->heap);
818
prebuilt->ins_node = node;
820
if (prebuilt->ins_upd_rec_buff == NULL) {
821
prebuilt->ins_upd_rec_buff = mem_heap_alloc(
822
prebuilt->heap, prebuilt->mysql_row_len);
825
row = dtuple_create(prebuilt->heap,
826
dict_table_get_n_cols(table));
828
dict_table_copy_types(row, table);
830
ins_node_set_new_row(node, row);
832
prebuilt->ins_graph = que_node_get_parent(
833
pars_complete_graph_for_exec(node,
836
prebuilt->ins_graph->state = QUE_FORK_ACTIVE;
839
return(prebuilt->ins_node->row);
842
/*********************************************************************//**
843
Updates the table modification counter and calculates new estimates
844
for table and index statistics if necessary. */
847
row_update_statistics_if_needed(
848
/*============================*/
849
dict_table_t* table) /*!< in: table */
853
counter = table->stat_modified_counter;
855
table->stat_modified_counter = counter + 1;
857
/* Calculate new statistics if 1 / 16 of table has been modified
858
since the last time a statistics batch was run, or if
859
stat_modified_counter > 2 000 000 000 (to avoid wrap-around).
860
We calculate statistics at most every 16th round, since we may have
861
a counter table which is very small and updated very often. */
863
if (counter > 2000000000
864
|| ((ib_int64_t)counter > 16 + table->stat_n_rows / 16)) {
866
dict_update_statistics(table);
870
/*********************************************************************//**
871
Unlocks AUTO_INC type locks that were possibly reserved by a trx. */
874
row_unlock_table_autoinc_for_mysql(
875
/*===============================*/
876
trx_t* trx) /*!< in/out: transaction */
878
mutex_enter(&kernel_mutex);
880
lock_release_autoinc_locks(trx);
882
mutex_exit(&kernel_mutex);
885
/*********************************************************************//**
886
Sets an AUTO_INC type lock on the table mentioned in prebuilt. The
887
AUTO_INC lock gives exclusive access to the auto-inc counter of the
888
table. The lock is reserved only for the duration of an SQL statement.
889
It is not compatible with another AUTO_INC or exclusive lock on the
891
@return error code or DB_SUCCESS */
894
row_lock_table_autoinc_for_mysql(
895
/*=============================*/
896
row_prebuilt_t* prebuilt) /*!< in: prebuilt struct in the MySQL
899
trx_t* trx = prebuilt->trx;
900
ins_node_t* node = prebuilt->ins_node;
901
const dict_table_t* table = prebuilt->table;
907
ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
909
/* If we already hold an AUTOINC lock on the table then do nothing.
910
Note: We peek at the value of the current owner without acquiring
911
the kernel mutex. **/
912
if (trx == table->autoinc_trx) {
917
trx->op_info = "setting auto-inc lock";
920
row_get_prebuilt_insert_row(prebuilt);
921
node = prebuilt->ins_node;
924
/* We use the insert query graph as the dummy graph needed
925
in the lock module call */
927
thr = que_fork_get_first_thr(prebuilt->ins_graph);
929
que_thr_move_to_run_state_for_mysql(thr, trx);
932
thr->run_node = node;
933
thr->prev_node = node;
935
/* It may be that the current session has not yet started
936
its transaction, or it has been committed: */
938
trx_start_if_not_started(trx);
940
err = lock_table(0, prebuilt->table, LOCK_AUTO_INC, thr);
942
trx->error_state = err;
944
if (err != DB_SUCCESS) {
945
que_thr_stop_for_mysql(thr);
947
was_lock_wait = row_mysql_handle_errors(&err, trx, thr, NULL);
958
que_thr_stop_for_mysql_no_error(thr, trx);
965
/*********************************************************************//**
966
Sets a table lock on the table mentioned in prebuilt.
967
@return error code or DB_SUCCESS */
970
row_lock_table_for_mysql(
971
/*=====================*/
972
row_prebuilt_t* prebuilt, /*!< in: prebuilt struct in the MySQL
974
dict_table_t* table, /*!< in: table to lock, or NULL
975
if prebuilt->table should be
977
prebuilt->select_lock_type */
978
ulint mode) /*!< in: lock mode of table
979
(ignored if table==NULL) */
981
trx_t* trx = prebuilt->trx;
987
ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
989
trx->op_info = "setting table lock";
991
if (prebuilt->sel_graph == NULL) {
992
/* Build a dummy select query graph */
993
row_prebuild_sel_graph(prebuilt);
996
/* We use the select query graph as the dummy graph needed
997
in the lock module call */
999
thr = que_fork_get_first_thr(prebuilt->sel_graph);
1001
que_thr_move_to_run_state_for_mysql(thr, trx);
1004
thr->run_node = thr;
1005
thr->prev_node = thr->common.parent;
1007
/* It may be that the current session has not yet started
1008
its transaction, or it has been committed: */
1010
trx_start_if_not_started(trx);
1013
err = lock_table(0, table, mode, thr);
1015
err = lock_table(0, prebuilt->table,
1016
prebuilt->select_lock_type, thr);
1019
trx->error_state = err;
1021
if (err != DB_SUCCESS) {
1022
que_thr_stop_for_mysql(thr);
1024
was_lock_wait = row_mysql_handle_errors(&err, trx, thr, NULL);
1026
if (was_lock_wait) {
1035
que_thr_stop_for_mysql_no_error(thr, trx);
1042
/*********************************************************************//**
1043
Does an insert for MySQL.
1044
@return error code or DB_SUCCESS */
1047
row_insert_for_mysql(
1048
/*=================*/
1049
byte* mysql_rec, /*!< in: row in the MySQL format */
1050
row_prebuilt_t* prebuilt) /*!< in: prebuilt struct in MySQL
1053
trx_savept_t savept;
1056
ibool was_lock_wait;
1057
trx_t* trx = prebuilt->trx;
1058
ins_node_t* node = prebuilt->ins_node;
1061
ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
1063
if (prebuilt->table->ibd_file_missing) {
1064
ut_print_timestamp(stderr);
1065
fprintf(stderr, " InnoDB: Error:\n"
1066
"InnoDB: MySQL is trying to use a table handle"
1067
" but the .ibd file for\n"
1068
"InnoDB: table %s does not exist.\n"
1069
"InnoDB: Have you deleted the .ibd file"
1070
" from the database directory under\n"
1071
"InnoDB: the MySQL datadir, or have you"
1072
" used DISCARD TABLESPACE?\n"
1073
"InnoDB: Look from\n"
1074
"InnoDB: " REFMAN "innodb-troubleshooting.html\n"
1075
"InnoDB: how you can resolve the problem.\n",
1076
prebuilt->table->name);
1080
if (UNIV_UNLIKELY(prebuilt->magic_n != ROW_PREBUILT_ALLOCATED)) {
1082
"InnoDB: Error: trying to free a corrupt\n"
1083
"InnoDB: table handle. Magic n %lu, table name ",
1084
(ulong) prebuilt->magic_n);
1085
ut_print_name(stderr, trx, TRUE, prebuilt->table->name);
1088
mem_analyze_corruption(prebuilt);
1093
if (UNIV_UNLIKELY(srv_created_new_raw || srv_force_recovery)) {
1094
fputs("InnoDB: A new raw disk partition was initialized or\n"
1095
"InnoDB: innodb_force_recovery is on: we do not allow\n"
1096
"InnoDB: database modifications by the user. Shut down\n"
1097
"InnoDB: mysqld and edit my.cnf so that"
1098
" newraw is replaced\n"
1099
"InnoDB: with raw, and innodb_force_... is removed.\n",
1105
trx->op_info = "inserting";
1107
row_mysql_delay_if_needed();
1109
trx_start_if_not_started(trx);
1112
row_get_prebuilt_insert_row(prebuilt);
1113
node = prebuilt->ins_node;
1116
row_mysql_convert_row_to_innobase(node->row, prebuilt, mysql_rec);
1118
savept = trx_savept_take(trx);
1120
thr = que_fork_get_first_thr(prebuilt->ins_graph);
1122
if (prebuilt->sql_stat_start) {
1123
node->state = INS_NODE_SET_IX_LOCK;
1124
prebuilt->sql_stat_start = FALSE;
1126
node->state = INS_NODE_ALLOC_ROW_ID;
1129
que_thr_move_to_run_state_for_mysql(thr, trx);
1132
thr->run_node = node;
1133
thr->prev_node = node;
1137
err = trx->error_state;
1139
if (err != DB_SUCCESS) {
1140
que_thr_stop_for_mysql(thr);
1142
/* TODO: what is this? */ thr->lock_state= QUE_THR_LOCK_ROW;
1144
was_lock_wait = row_mysql_handle_errors(&err, trx, thr,
1146
thr->lock_state= QUE_THR_LOCK_NOLOCK;
1148
if (was_lock_wait) {
1157
que_thr_stop_for_mysql_no_error(thr, trx);
1159
prebuilt->table->stat_n_rows++;
1161
srv_n_rows_inserted++;
1163
if (prebuilt->table->stat_n_rows == 0) {
1164
/* Avoid wrap-over */
1165
prebuilt->table->stat_n_rows--;
1168
row_update_statistics_if_needed(prebuilt->table);
1174
/*********************************************************************//**
1175
Builds a dummy query graph used in selects. */
1178
row_prebuild_sel_graph(
1179
/*===================*/
1180
row_prebuilt_t* prebuilt) /*!< in: prebuilt struct in MySQL
1185
ut_ad(prebuilt && prebuilt->trx);
1187
if (prebuilt->sel_graph == NULL) {
1189
node = sel_node_create(prebuilt->heap);
1191
prebuilt->sel_graph = que_node_get_parent(
1192
pars_complete_graph_for_exec(node,
1196
prebuilt->sel_graph->state = QUE_FORK_ACTIVE;
1200
/*********************************************************************//**
1201
Creates an query graph node of 'update' type to be used in the MySQL
1203
@return own: update node */
1206
row_create_update_node_for_mysql(
1207
/*=============================*/
1208
dict_table_t* table, /*!< in: table to update */
1209
mem_heap_t* heap) /*!< in: mem heap from which allocated */
1213
node = upd_node_create(heap);
1215
node->in_mysql_interface = TRUE;
1216
node->is_delete = FALSE;
1217
node->searched_update = FALSE;
1218
node->select = NULL;
1219
node->pcur = btr_pcur_create_for_mysql();
1220
node->table = table;
1222
node->update = upd_create(dict_table_get_n_cols(table), heap);
1224
node->update_n_fields = dict_table_get_n_cols(table);
1226
UT_LIST_INIT(node->columns);
1227
node->has_clust_rec_x_lock = TRUE;
1228
node->cmpl_info = 0;
1230
node->table_sym = NULL;
1231
node->col_assign_list = NULL;
1236
/*********************************************************************//**
1237
Gets pointer to a prebuilt update vector used in updates. If the update
1238
graph has not yet been built in the prebuilt struct, then this function
1240
@return prebuilt update vector */
1243
row_get_prebuilt_update_vector(
1244
/*===========================*/
1245
row_prebuilt_t* prebuilt) /*!< in: prebuilt struct in MySQL
1248
dict_table_t* table = prebuilt->table;
1251
ut_ad(prebuilt && table && prebuilt->trx);
1253
if (prebuilt->upd_node == NULL) {
1255
/* Not called before for this handle: create an update node
1256
and query graph to the prebuilt struct */
1258
node = row_create_update_node_for_mysql(table, prebuilt->heap);
1260
prebuilt->upd_node = node;
1262
prebuilt->upd_graph = que_node_get_parent(
1263
pars_complete_graph_for_exec(node,
1266
prebuilt->upd_graph->state = QUE_FORK_ACTIVE;
1269
return(prebuilt->upd_node->update);
1272
/*********************************************************************//**
1273
Does an update or delete of a row for MySQL.
1274
@return error code or DB_SUCCESS */
1277
row_update_for_mysql(
1278
/*=================*/
1279
byte* mysql_rec, /*!< in: the row to be updated, in
1281
row_prebuilt_t* prebuilt) /*!< in: prebuilt struct in MySQL
1284
trx_savept_t savept;
1287
ibool was_lock_wait;
1288
dict_index_t* clust_index;
1289
/* ulint ref_len; */
1291
dict_table_t* table = prebuilt->table;
1292
trx_t* trx = prebuilt->trx;
1294
ut_ad(prebuilt && trx);
1295
ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
1296
UT_NOT_USED(mysql_rec);
1298
if (prebuilt->table->ibd_file_missing) {
1299
ut_print_timestamp(stderr);
1300
fprintf(stderr, " InnoDB: Error:\n"
1301
"InnoDB: MySQL is trying to use a table handle"
1302
" but the .ibd file for\n"
1303
"InnoDB: table %s does not exist.\n"
1304
"InnoDB: Have you deleted the .ibd file"
1305
" from the database directory under\n"
1306
"InnoDB: the MySQL datadir, or have you"
1307
" used DISCARD TABLESPACE?\n"
1308
"InnoDB: Look from\n"
1309
"InnoDB: " REFMAN "innodb-troubleshooting.html\n"
1310
"InnoDB: how you can resolve the problem.\n",
1311
prebuilt->table->name);
1315
if (UNIV_UNLIKELY(prebuilt->magic_n != ROW_PREBUILT_ALLOCATED)) {
1317
"InnoDB: Error: trying to free a corrupt\n"
1318
"InnoDB: table handle. Magic n %lu, table name ",
1319
(ulong) prebuilt->magic_n);
1320
ut_print_name(stderr, trx, TRUE, prebuilt->table->name);
1323
mem_analyze_corruption(prebuilt);
1328
if (UNIV_UNLIKELY(srv_created_new_raw || srv_force_recovery)) {
1329
fputs("InnoDB: A new raw disk partition was initialized or\n"
1330
"InnoDB: innodb_force_recovery is on: we do not allow\n"
1331
"InnoDB: database modifications by the user. Shut down\n"
1332
"InnoDB: mysqld and edit my.cnf so that newraw"
1334
"InnoDB: with raw, and innodb_force_... is removed.\n",
1340
trx->op_info = "updating or deleting";
1342
row_mysql_delay_if_needed();
1344
trx_start_if_not_started(trx);
1346
node = prebuilt->upd_node;
1348
clust_index = dict_table_get_first_index(table);
1350
if (prebuilt->pcur->btr_cur.index == clust_index) {
1351
btr_pcur_copy_stored_position(node->pcur, prebuilt->pcur);
1353
btr_pcur_copy_stored_position(node->pcur,
1354
prebuilt->clust_pcur);
1357
ut_a(node->pcur->rel_pos == BTR_PCUR_ON);
1359
/* MySQL seems to call rnd_pos before updating each row it
1360
has cached: we can get the correct cursor position from
1361
prebuilt->pcur; NOTE that we cannot build the row reference
1362
from mysql_rec if the clustered index was automatically
1363
generated for the table: MySQL does not know anything about
1364
the row id used as the clustered index key */
1366
savept = trx_savept_take(trx);
1368
thr = que_fork_get_first_thr(prebuilt->upd_graph);
1370
node->state = UPD_NODE_UPDATE_CLUSTERED;
1372
ut_ad(!prebuilt->sql_stat_start);
1374
que_thr_move_to_run_state_for_mysql(thr, trx);
1377
thr->run_node = node;
1378
thr->prev_node = node;
1382
err = trx->error_state;
1384
if (err != DB_SUCCESS) {
1385
que_thr_stop_for_mysql(thr);
1387
if (err == DB_RECORD_NOT_FOUND) {
1388
trx->error_state = DB_SUCCESS;
1394
thr->lock_state= QUE_THR_LOCK_ROW;
1395
was_lock_wait = row_mysql_handle_errors(&err, trx, thr,
1397
thr->lock_state= QUE_THR_LOCK_NOLOCK;
1399
if (was_lock_wait) {
1408
que_thr_stop_for_mysql_no_error(thr, trx);
1410
if (node->is_delete) {
1411
if (prebuilt->table->stat_n_rows > 0) {
1412
prebuilt->table->stat_n_rows--;
1415
srv_n_rows_deleted++;
1417
srv_n_rows_updated++;
1420
row_update_statistics_if_needed(prebuilt->table);
1427
/*********************************************************************//**
1428
This can only be used when srv_locks_unsafe_for_binlog is TRUE or
1429
this session is using a READ COMMITTED isolation level. Before
1430
calling this function we must use trx_reset_new_rec_lock_info() and
1431
trx_register_new_rec_lock() to store the information which new record locks
1432
really were set. This function removes a newly set lock under prebuilt->pcur,
1433
and also under prebuilt->clust_pcur. Currently, this is only used and tested
1434
in the case of an UPDATE or a DELETE statement, where the row lock is of the
1436
Thus, this implements a 'mini-rollback' that releases the latest record
1438
@return error code or DB_SUCCESS */
1441
row_unlock_for_mysql(
1442
/*=================*/
1443
row_prebuilt_t* prebuilt, /*!< in: prebuilt struct in MySQL
1445
ibool has_latches_on_recs)/*!< TRUE if called so that we have
1446
the latches on the records under pcur
1447
and clust_pcur, and we do not need to
1448
reposition the cursors. */
1450
btr_pcur_t* pcur = prebuilt->pcur;
1451
btr_pcur_t* clust_pcur = prebuilt->clust_pcur;
1452
trx_t* trx = prebuilt->trx;
1454
ut_ad(prebuilt && trx);
1455
ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
1458
(!srv_locks_unsafe_for_binlog
1459
&& trx->isolation_level != TRX_ISO_READ_COMMITTED)) {
1462
"InnoDB: Error: calling row_unlock_for_mysql though\n"
1463
"InnoDB: innodb_locks_unsafe_for_binlog is FALSE and\n"
1464
"InnoDB: this session is not using"
1465
" READ COMMITTED isolation level.\n");
1470
trx->op_info = "unlock_row";
1472
if (prebuilt->new_rec_locks >= 1) {
1475
dict_index_t* index;
1476
trx_id_t rec_trx_id;
1481
/* Restore the cursor position and find the record */
1483
if (!has_latches_on_recs) {
1484
btr_pcur_restore_position(BTR_SEARCH_LEAF, pcur, &mtr);
1487
rec = btr_pcur_get_rec(pcur);
1488
index = btr_pcur_get_btr_cur(pcur)->index;
1490
if (prebuilt->new_rec_locks >= 2) {
1491
/* Restore the cursor position and find the record
1492
in the clustered index. */
1494
if (!has_latches_on_recs) {
1495
btr_pcur_restore_position(BTR_SEARCH_LEAF,
1499
rec = btr_pcur_get_rec(clust_pcur);
1500
index = btr_pcur_get_btr_cur(clust_pcur)->index;
1503
if (UNIV_UNLIKELY(!dict_index_is_clust(index))) {
1504
/* This is not a clustered index record. We
1505
do not know how to unlock the record. */
1509
/* If the record has been modified by this
1510
transaction, do not unlock it. */
1512
if (index->trx_id_offset) {
1513
rec_trx_id = trx_read_trx_id(rec
1514
+ index->trx_id_offset);
1516
mem_heap_t* heap = NULL;
1517
ulint offsets_[REC_OFFS_NORMAL_SIZE];
1518
ulint* offsets = offsets_;
1520
rec_offs_init(offsets_);
1521
offsets = rec_get_offsets(rec, index, offsets,
1522
ULINT_UNDEFINED, &heap);
1524
rec_trx_id = row_get_rec_trx_id(rec, index, offsets);
1526
if (UNIV_LIKELY_NULL(heap)) {
1527
mem_heap_free(heap);
1531
if (ut_dulint_cmp(rec_trx_id, trx->id) != 0) {
1532
/* We did not update the record: unlock it */
1534
rec = btr_pcur_get_rec(pcur);
1535
index = btr_pcur_get_btr_cur(pcur)->index;
1537
lock_rec_unlock(trx, btr_pcur_get_block(pcur),
1538
rec, prebuilt->select_lock_type);
1540
if (prebuilt->new_rec_locks >= 2) {
1541
rec = btr_pcur_get_rec(clust_pcur);
1542
index = btr_pcur_get_btr_cur(clust_pcur)->index;
1544
lock_rec_unlock(trx,
1545
btr_pcur_get_block(clust_pcur),
1547
prebuilt->select_lock_type);
1559
/**********************************************************************//**
1560
Does a cascaded delete or set null in a foreign key operation.
1561
@return error code or DB_SUCCESS */
1564
row_update_cascade_for_mysql(
1565
/*=========================*/
1566
que_thr_t* thr, /*!< in: query thread */
1567
upd_node_t* node, /*!< in: update node used in the cascade
1568
or set null operation */
1569
dict_table_t* table) /*!< in: table where we do the operation */
1574
trx = thr_get_trx(thr);
1576
thr->run_node = node;
1577
thr->prev_node = node;
1581
err = trx->error_state;
1583
/* Note that the cascade node is a subnode of another InnoDB
1584
query graph node. We do a normal lock wait in this node, but
1585
all errors are handled by the parent node. */
1587
if (err == DB_LOCK_WAIT) {
1588
/* Handle lock wait here */
1590
que_thr_stop_for_mysql(thr);
1592
srv_suspend_mysql_thread(thr);
1594
/* Note that a lock wait may also end in a lock wait timeout,
1595
or this transaction is picked as a victim in selective
1596
deadlock resolution */
1598
if (trx->error_state != DB_SUCCESS) {
1600
return(trx->error_state);
1603
/* Retry operation after a normal lock wait */
1608
if (err != DB_SUCCESS) {
1613
if (node->is_delete) {
1614
if (table->stat_n_rows > 0) {
1615
table->stat_n_rows--;
1618
srv_n_rows_deleted++;
1620
srv_n_rows_updated++;
1623
row_update_statistics_if_needed(table);
1628
/*********************************************************************//**
1629
Checks if a table is such that we automatically created a clustered
1630
index on it (on row id).
1631
@return TRUE if the clustered index was generated automatically */
1634
row_table_got_default_clust_index(
1635
/*==============================*/
1636
const dict_table_t* table) /*!< in: table */
1638
const dict_index_t* clust_index;
1640
clust_index = dict_table_get_first_index(table);
1642
return(dict_index_get_nth_col(clust_index, 0)->mtype == DATA_SYS);
1645
/*********************************************************************//**
1646
Calculates the key number used inside MySQL for an Innobase index. We have
1647
to take into account if we generated a default clustered index for the table
1648
@return the key number used inside MySQL */
1651
row_get_mysql_key_number_for_index(
1652
/*===============================*/
1653
const dict_index_t* index) /*!< in: index */
1655
const dict_index_t* ind;
1661
ind = dict_table_get_first_index(index->table);
1663
while (index != ind) {
1664
ind = dict_table_get_next_index(ind);
1668
if (row_table_got_default_clust_index(index->table)) {
1676
/*********************************************************************//**
1677
Locks the data dictionary in shared mode from modifications, for performing
1678
foreign key check, rollback, or other operation invisible to MySQL. */
1681
row_mysql_freeze_data_dictionary_func(
1682
/*==================================*/
1683
trx_t* trx, /*!< in/out: transaction */
1684
const char* file, /*!< in: file name */
1685
ulint line) /*!< in: line number */
1687
ut_a(trx->dict_operation_lock_mode == 0);
1689
rw_lock_s_lock_func(&dict_operation_lock, 0, file, line);
1691
trx->dict_operation_lock_mode = RW_S_LATCH;
1694
/*********************************************************************//**
1695
Unlocks the data dictionary shared lock. */
1698
row_mysql_unfreeze_data_dictionary(
1699
/*===============================*/
1700
trx_t* trx) /*!< in/out: transaction */
1702
ut_a(trx->dict_operation_lock_mode == RW_S_LATCH);
1704
rw_lock_s_unlock(&dict_operation_lock);
1706
trx->dict_operation_lock_mode = 0;
1709
/*********************************************************************//**
1710
Locks the data dictionary exclusively for performing a table create or other
1711
data dictionary modification operation. */
1714
row_mysql_lock_data_dictionary_func(
1715
/*================================*/
1716
trx_t* trx, /*!< in/out: transaction */
1717
const char* file, /*!< in: file name */
1718
ulint line) /*!< in: line number */
1720
ut_a(trx->dict_operation_lock_mode == 0
1721
|| trx->dict_operation_lock_mode == RW_X_LATCH);
1723
/* Serialize data dictionary operations with dictionary mutex:
1724
no deadlocks or lock waits can occur then in these operations */
1726
rw_lock_x_lock_func(&dict_operation_lock, 0, file, line);
1727
trx->dict_operation_lock_mode = RW_X_LATCH;
1729
mutex_enter(&(dict_sys->mutex));
1732
/*********************************************************************//**
1733
Unlocks the data dictionary exclusive lock. */
1736
row_mysql_unlock_data_dictionary(
1737
/*=============================*/
1738
trx_t* trx) /*!< in/out: transaction */
1740
ut_a(trx->dict_operation_lock_mode == RW_X_LATCH);
1742
/* Serialize data dictionary operations with dictionary mutex:
1743
no deadlocks can occur then in these operations */
1745
mutex_exit(&(dict_sys->mutex));
1746
rw_lock_x_unlock(&dict_operation_lock);
1748
trx->dict_operation_lock_mode = 0;
1751
/*********************************************************************//**
1752
Creates a table for MySQL. If the name of the table ends in
1753
one of "innodb_monitor", "innodb_lock_monitor", "innodb_tablespace_monitor",
1754
"innodb_table_monitor", then this will also start the printing of monitor
1755
output by the master thread. If the table name ends in "innodb_mem_validate",
1756
InnoDB will try to invoke mem_validate().
1757
@return error code or DB_SUCCESS */
1760
row_create_table_for_mysql(
1761
/*=======================*/
1762
dict_table_t* table, /*!< in, own: table definition
1764
trx_t* trx) /*!< in: transaction handle */
1769
const char* table_name;
1770
ulint table_name_len;
1774
ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
1775
#ifdef UNIV_SYNC_DEBUG
1776
ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_EX));
1777
#endif /* UNIV_SYNC_DEBUG */
1778
ut_ad(mutex_own(&(dict_sys->mutex)));
1779
ut_ad(trx->dict_operation_lock_mode == RW_X_LATCH);
1781
if (srv_created_new_raw) {
1782
fputs("InnoDB: A new raw disk partition was initialized:\n"
1783
"InnoDB: we do not allow database modifications"
1785
"InnoDB: Shut down mysqld and edit my.cnf so that newraw"
1786
" is replaced with raw.\n", stderr);
1788
dict_mem_table_free(table);
1789
trx_commit_for_mysql(trx);
1794
trx->op_info = "creating table";
1796
if (row_mysql_is_system_table(table->name)) {
1799
"InnoDB: Error: trying to create a MySQL system"
1800
" table %s of type InnoDB.\n"
1801
"InnoDB: MySQL system tables must be"
1802
" of the MyISAM type!\n",
1807
/* Check that no reserved column names are used. */
1808
for (i = 0; i < dict_table_get_n_user_cols(table); i++) {
1809
if (dict_col_name_is_reserved(
1810
dict_table_get_col_name(table, i))) {
1816
trx_start_if_not_started(trx);
1818
/* The table name is prefixed with the database name and a '/'.
1819
Certain table names starting with 'innodb_' have their special
1820
meaning regardless of the database name. Thus, we need to
1821
ignore the database name prefix in the comparisons. */
1822
table_name = strchr(table->name, '/');
1825
table_name_len = strlen(table_name) + 1;
1827
if (STR_EQ(table_name, table_name_len, S_innodb_monitor)) {
1829
/* Table equals "innodb_monitor":
1830
start monitor prints */
1832
srv_print_innodb_monitor = TRUE;
1834
/* The lock timeout monitor thread also takes care
1835
of InnoDB monitor prints */
1837
os_event_set(srv_lock_timeout_thread_event);
1838
} else if (STR_EQ(table_name, table_name_len,
1839
S_innodb_lock_monitor)) {
1841
srv_print_innodb_monitor = TRUE;
1842
srv_print_innodb_lock_monitor = TRUE;
1843
os_event_set(srv_lock_timeout_thread_event);
1844
} else if (STR_EQ(table_name, table_name_len,
1845
S_innodb_tablespace_monitor)) {
1847
srv_print_innodb_tablespace_monitor = TRUE;
1848
os_event_set(srv_lock_timeout_thread_event);
1849
} else if (STR_EQ(table_name, table_name_len,
1850
S_innodb_table_monitor)) {
1852
srv_print_innodb_table_monitor = TRUE;
1853
os_event_set(srv_lock_timeout_thread_event);
1854
} else if (STR_EQ(table_name, table_name_len,
1855
S_innodb_mem_validate)) {
1856
/* We define here a debugging feature intended for
1859
fputs("Validating InnoDB memory:\n"
1860
"to use this feature you must compile InnoDB with\n"
1861
"UNIV_MEM_DEBUG defined in univ.i and"
1862
" the server must be\n"
1863
"quiet because allocation from a mem heap"
1864
" is not protected\n"
1865
"by any semaphore.\n", stderr);
1866
#ifdef UNIV_MEM_DEBUG
1867
ut_a(mem_validate());
1868
fputs("Memory validated\n", stderr);
1869
#else /* UNIV_MEM_DEBUG */
1870
fputs("Memory NOT validated (recompile with UNIV_MEM_DEBUG)\n",
1872
#endif /* UNIV_MEM_DEBUG */
1875
heap = mem_heap_create(512);
1877
trx_set_dict_operation(trx, TRX_DICT_OP_TABLE);
1879
node = tab_create_graph_create(table, heap);
1881
thr = pars_complete_graph_for_exec(node, trx, heap);
1883
ut_a(thr == que_fork_start_command(que_node_get_parent(thr)));
1884
que_run_threads(thr);
1886
err = trx->error_state;
1888
if (UNIV_UNLIKELY(err != DB_SUCCESS)) {
1889
trx->error_state = DB_SUCCESS;
1890
trx_general_rollback_for_mysql(trx, FALSE, NULL);
1894
case DB_OUT_OF_FILE_SPACE:
1895
ut_print_timestamp(stderr);
1896
fputs(" InnoDB: Warning: cannot create table ",
1898
ut_print_name(stderr, trx, TRUE, table->name);
1899
fputs(" because tablespace full\n", stderr);
1901
if (dict_table_get_low(table->name)) {
1903
row_drop_table_for_mysql(table->name, trx, FALSE);
1904
trx_commit_for_mysql(trx);
1908
case DB_DUPLICATE_KEY:
1909
ut_print_timestamp(stderr);
1910
fputs(" InnoDB: Error: table ", stderr);
1911
ut_print_name(stderr, trx, TRUE, table->name);
1912
fputs(" already exists in InnoDB internal\n"
1913
"InnoDB: data dictionary. Have you deleted"
1915
"InnoDB: and not used DROP TABLE?"
1916
" Have you used DROP DATABASE\n"
1917
"InnoDB: for InnoDB tables in"
1918
" MySQL version <= 3.23.43?\n"
1919
"InnoDB: See the Restrictions section"
1920
" of the InnoDB manual.\n"
1921
"InnoDB: You can drop the orphaned table"
1922
" inside InnoDB by\n"
1923
"InnoDB: creating an InnoDB table with"
1924
" the same name in another\n"
1925
"InnoDB: database and copying the .frm file"
1926
" to the current database.\n"
1927
"InnoDB: Then MySQL thinks the table exists,"
1928
" and DROP TABLE will\n"
1929
"InnoDB: succeed.\n"
1930
"InnoDB: You can look for further help from\n"
1931
"InnoDB: " REFMAN "innodb-troubleshooting.html\n",
1934
/* We may also get err == DB_ERROR if the .ibd file for the
1935
table already exists */
1940
que_graph_free((que_t*) que_node_get_parent(thr));
1947
/*********************************************************************//**
1948
Does an index creation operation for MySQL. TODO: currently failure
1949
to create an index results in dropping the whole table! This is no problem
1950
currently as all indexes must be created at the same time as the table.
1951
@return error number or DB_SUCCESS */
1954
row_create_index_for_mysql(
1955
/*=======================*/
1956
dict_index_t* index, /*!< in, own: index definition
1958
trx_t* trx, /*!< in: transaction handle */
1959
const ulint* field_lengths) /*!< in: if not NULL, must contain
1960
dict_index_get_n_fields(index)
1961
actual field lengths for the
1962
index columns, which are
1963
then checked for not being too
1974
#ifdef UNIV_SYNC_DEBUG
1975
ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_EX));
1976
#endif /* UNIV_SYNC_DEBUG */
1977
ut_ad(mutex_own(&(dict_sys->mutex)));
1978
ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
1980
trx->op_info = "creating index";
1982
/* Copy the table name because we may want to drop the
1983
table later, after the index object is freed (inside
1984
que_run_threads()) and thus index->table_name is not available. */
1985
table_name = mem_strdup(index->table_name);
1987
trx_start_if_not_started(trx);
1989
/* Check that the same column does not appear twice in the index.
1990
Starting from 4.0.14, InnoDB should be able to cope with that, but
1991
safer not to allow them. */
1993
for (i = 0; i < dict_index_get_n_fields(index); i++) {
1996
for (j = 0; j < i; j++) {
1998
dict_index_get_nth_field(index, j)->name,
1999
dict_index_get_nth_field(index, i)->name)) {
2000
ut_print_timestamp(stderr);
2002
fputs(" InnoDB: Error: column ", stderr);
2003
ut_print_name(stderr, trx, FALSE,
2004
dict_index_get_nth_field(
2006
fputs(" appears twice in ", stderr);
2007
dict_index_name_print(stderr, trx, index);
2009
"InnoDB: This is not allowed"
2010
" in InnoDB.\n", stderr);
2012
err = DB_COL_APPEARS_TWICE_IN_INDEX;
2014
goto error_handling;
2018
/* Check also that prefix_len and actual length
2019
< DICT_MAX_INDEX_COL_LEN */
2021
len = dict_index_get_nth_field(index, i)->prefix_len;
2023
if (field_lengths) {
2024
len = ut_max(len, field_lengths[i]);
2027
if (len >= DICT_MAX_INDEX_COL_LEN) {
2028
err = DB_TOO_BIG_RECORD;
2030
goto error_handling;
2034
heap = mem_heap_create(512);
2036
trx_set_dict_operation(trx, TRX_DICT_OP_TABLE);
2038
/* Note that the space id where we store the index is inherited from
2039
the table in dict_build_index_def_step() in dict0crea.c. */
2041
node = ind_create_graph_create(index, heap);
2043
thr = pars_complete_graph_for_exec(node, trx, heap);
2045
ut_a(thr == que_fork_start_command(que_node_get_parent(thr)));
2046
que_run_threads(thr);
2048
err = trx->error_state;
2050
que_graph_free((que_t*) que_node_get_parent(thr));
2053
if (err != DB_SUCCESS) {
2054
/* We have special error handling here */
2056
trx->error_state = DB_SUCCESS;
2058
trx_general_rollback_for_mysql(trx, FALSE, NULL);
2060
row_drop_table_for_mysql(table_name, trx, FALSE);
2062
trx_commit_for_mysql(trx);
2064
trx->error_state = DB_SUCCESS;
2069
mem_free(table_name);
2074
/*********************************************************************//**
2075
Scans a table create SQL string and adds to the data dictionary
2076
the foreign key constraints declared in the string. This function
2077
should be called after the indexes for a table have been created.
2078
Each foreign key constraint must be accompanied with indexes in
2079
bot participating tables. The indexes are allowed to contain more
2080
fields than mentioned in the constraint. Check also that foreign key
2081
constraints which reference this table are ok.
2082
@return error code or DB_SUCCESS */
2085
row_table_add_foreign_constraints(
2086
/*==============================*/
2087
trx_t* trx, /*!< in: transaction */
2088
const char* sql_string, /*!< in: table create statement where
2089
foreign keys are declared like:
2090
FOREIGN KEY (a, b) REFERENCES table2(c, d),
2091
table2 can be written also with the
2092
database name before it: test.table2 */
2093
const char* name, /*!< in: table full name in the
2095
database_name/table_name */
2096
ibool reject_fks) /*!< in: if TRUE, fail with error
2097
code DB_CANNOT_ADD_CONSTRAINT if
2098
any foreign keys are found. */
2102
ut_ad(mutex_own(&(dict_sys->mutex)));
2103
#ifdef UNIV_SYNC_DEBUG
2104
ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_EX));
2105
#endif /* UNIV_SYNC_DEBUG */
2108
trx->op_info = "adding foreign keys";
2110
trx_start_if_not_started(trx);
2112
trx_set_dict_operation(trx, TRX_DICT_OP_TABLE);
2114
err = dict_create_foreign_constraints(trx, sql_string, name,
2116
if (err == DB_SUCCESS) {
2117
/* Check that also referencing constraints are ok */
2118
err = dict_load_foreigns(name, TRUE);
2121
if (err != DB_SUCCESS) {
2122
/* We have special error handling here */
2124
trx->error_state = DB_SUCCESS;
2126
trx_general_rollback_for_mysql(trx, FALSE, NULL);
2128
row_drop_table_for_mysql(name, trx, FALSE);
2130
trx_commit_for_mysql(trx);
2132
trx->error_state = DB_SUCCESS;
2138
/*********************************************************************//**
2139
Drops a table for MySQL as a background operation. MySQL relies on Unix
2140
in ALTER TABLE to the fact that the table handler does not remove the
2141
table before all handles to it has been removed. Furhermore, the MySQL's
2142
call to drop table must be non-blocking. Therefore we do the drop table
2143
as a background operation, which is taken care of by the master thread
2145
@return error code or DB_SUCCESS */
2148
row_drop_table_for_mysql_in_background(
2149
/*===================================*/
2150
const char* name) /*!< in: table name */
2155
trx = trx_allocate_for_background();
2157
/* If the original transaction was dropping a table referenced by
2158
foreign keys, we must set the following to be able to drop the
2161
trx->check_foreigns = FALSE;
2163
/* fputs("InnoDB: Error: Dropping table ", stderr);
2164
ut_print_name(stderr, trx, TRUE, name);
2165
fputs(" in background drop list\n", stderr); */
2167
/* Try to drop the table in InnoDB */
2169
error = row_drop_table_for_mysql(name, trx, FALSE);
2171
/* Flush the log to reduce probability that the .frm files and
2172
the InnoDB data dictionary get out-of-sync if the user runs
2173
with innodb_flush_log_at_trx_commit = 0 */
2175
log_buffer_flush_to_disk();
2177
trx_commit_for_mysql(trx);
2179
trx_free_for_background(trx);
2181
return((int) error);
2184
/*********************************************************************//**
2185
The master thread in srv0srv.c calls this regularly to drop tables which
2186
we must drop in background after queries to them have ended. Such lazy
2187
dropping of tables is needed in ALTER TABLE on Unix.
2188
@return how many tables dropped + remaining tables in list */
2191
row_drop_tables_for_mysql_in_background(void)
2192
/*=========================================*/
2194
row_mysql_drop_t* drop;
2195
dict_table_t* table;
2197
ulint n_tables_dropped = 0;
2199
mutex_enter(&kernel_mutex);
2201
if (!row_mysql_drop_list_inited) {
2203
UT_LIST_INIT(row_mysql_drop_list);
2204
row_mysql_drop_list_inited = TRUE;
2207
drop = UT_LIST_GET_FIRST(row_mysql_drop_list);
2209
n_tables = UT_LIST_GET_LEN(row_mysql_drop_list);
2211
mutex_exit(&kernel_mutex);
2214
/* All tables dropped */
2216
return(n_tables + n_tables_dropped);
2219
mutex_enter(&(dict_sys->mutex));
2220
table = dict_table_get_low(drop->table_name);
2221
mutex_exit(&(dict_sys->mutex));
2223
if (table == NULL) {
2224
/* If for some reason the table has already been dropped
2225
through some other mechanism, do not try to drop it */
2227
goto already_dropped;
2230
if (DB_SUCCESS != row_drop_table_for_mysql_in_background(
2231
drop->table_name)) {
2232
/* If the DROP fails for some table, we return, and let the
2233
main thread retry later */
2235
return(n_tables + n_tables_dropped);
2241
mutex_enter(&kernel_mutex);
2243
UT_LIST_REMOVE(row_mysql_drop_list, row_mysql_drop_list, drop);
2245
ut_print_timestamp(stderr);
2246
fputs(" InnoDB: Dropped table ", stderr);
2247
ut_print_name(stderr, NULL, TRUE, drop->table_name);
2248
fputs(" in background drop queue.\n", stderr);
2250
mem_free(drop->table_name);
2254
mutex_exit(&kernel_mutex);
2259
/*********************************************************************//**
2260
Get the background drop list length. NOTE: the caller must own the kernel
2262
@return how many tables in list */
2265
row_get_background_drop_list_len_low(void)
2266
/*======================================*/
2268
ut_ad(mutex_own(&kernel_mutex));
2270
if (!row_mysql_drop_list_inited) {
2272
UT_LIST_INIT(row_mysql_drop_list);
2273
row_mysql_drop_list_inited = TRUE;
2276
return(UT_LIST_GET_LEN(row_mysql_drop_list));
2279
/*********************************************************************//**
2280
If a table is not yet in the drop list, adds the table to the list of tables
2281
which the master thread drops in background. We need this on Unix because in
2282
ALTER TABLE MySQL may call drop table even if the table has running queries on
2283
it. Also, if there are running foreign key checks on the table, we drop the
2285
@return TRUE if the table was not yet in the drop list, and was added there */
2288
row_add_table_to_background_drop_list(
2289
/*==================================*/
2290
const char* name) /*!< in: table name */
2292
row_mysql_drop_t* drop;
2294
mutex_enter(&kernel_mutex);
2296
if (!row_mysql_drop_list_inited) {
2298
UT_LIST_INIT(row_mysql_drop_list);
2299
row_mysql_drop_list_inited = TRUE;
2302
/* Look if the table already is in the drop list */
2303
drop = UT_LIST_GET_FIRST(row_mysql_drop_list);
2305
while (drop != NULL) {
2306
if (strcmp(drop->table_name, name) == 0) {
2307
/* Already in the list */
2309
mutex_exit(&kernel_mutex);
2314
drop = UT_LIST_GET_NEXT(row_mysql_drop_list, drop);
2317
drop = mem_alloc(sizeof(row_mysql_drop_t));
2319
drop->table_name = mem_strdup(name);
2321
UT_LIST_ADD_LAST(row_mysql_drop_list, row_mysql_drop_list, drop);
2323
/* fputs("InnoDB: Adding table ", stderr);
2324
ut_print_name(stderr, trx, TRUE, drop->table_name);
2325
fputs(" to background drop list\n", stderr); */
2327
mutex_exit(&kernel_mutex);
2332
/*********************************************************************//**
2333
Discards the tablespace of a table which stored in an .ibd file. Discarding
2334
means that this function deletes the .ibd file and assigns a new table id for
2335
the table. Also the flag table->ibd_file_missing is set TRUE.
2336
@return error code or DB_SUCCESS */
2339
row_discard_tablespace_for_mysql(
2340
/*=============================*/
2341
const char* name, /*!< in: table name */
2342
trx_t* trx) /*!< in: transaction handle */
2344
dict_foreign_t* foreign;
2346
dict_table_t* table;
2349
pars_info_t* info = NULL;
2351
/* How do we prevent crashes caused by ongoing operations on
2352
the table? Old operations could try to access non-existent
2355
1) SQL queries, INSERT, SELECT, ...: we must get an exclusive
2356
MySQL table lock on the table before we can do DISCARD
2357
TABLESPACE. Then there are no running queries on the table.
2359
2) Purge and rollback: we assign a new table id for the
2360
table. Since purge and rollback look for the table based on
2361
the table id, they see the table as 'dropped' and discard
2364
3) Insert buffer: we remove all entries for the tablespace in
2365
the insert buffer tree; as long as the tablespace mem object
2366
does not exist, ongoing insert buffer page merges are
2367
discarded in buf0rea.c. If we recreate the tablespace mem
2368
object with IMPORT TABLESPACE later, then the tablespace will
2369
have the same id, but the tablespace_version field in the mem
2370
object is different, and ongoing old insert buffer page merges
2373
4) Linear readahead and random readahead: we use the same
2374
method as in 3) to discard ongoing operations.
2376
5) FOREIGN KEY operations: if
2377
table->n_foreign_key_checks_running > 0, we do not allow the
2378
discard. We also reserve the data dictionary latch. */
2380
ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
2382
trx->op_info = "discarding tablespace";
2383
trx_start_if_not_started(trx);
2385
/* Serialize data dictionary operations with dictionary mutex:
2386
no deadlocks can occur then in these operations */
2388
row_mysql_lock_data_dictionary(trx);
2390
table = dict_table_get_low(name);
2393
err = DB_TABLE_NOT_FOUND;
2398
if (table->space == 0) {
2399
ut_print_timestamp(stderr);
2400
fputs(" InnoDB: Error: table ", stderr);
2401
ut_print_name(stderr, trx, TRUE, name);
2403
"InnoDB: is in the system tablespace 0"
2404
" which cannot be discarded\n", stderr);
2410
if (table->n_foreign_key_checks_running > 0) {
2412
ut_print_timestamp(stderr);
2413
fputs(" InnoDB: You are trying to DISCARD table ", stderr);
2414
ut_print_name(stderr, trx, TRUE, table->name);
2416
"InnoDB: though there is a foreign key check"
2418
"InnoDB: Cannot discard the table.\n",
2426
/* Check if the table is referenced by foreign key constraints from
2427
some other table (not the table itself) */
2429
foreign = UT_LIST_GET_FIRST(table->referenced_list);
2431
while (foreign && foreign->foreign_table == table) {
2432
foreign = UT_LIST_GET_NEXT(referenced_list, foreign);
2435
if (foreign && trx->check_foreigns) {
2437
FILE* ef = dict_foreign_err_file;
2439
/* We only allow discarding a referenced table if
2440
FOREIGN_KEY_CHECKS is set to 0 */
2442
err = DB_CANNOT_DROP_CONSTRAINT;
2444
mutex_enter(&dict_foreign_err_mutex);
2446
ut_print_timestamp(ef);
2448
fputs(" Cannot DISCARD table ", ef);
2449
ut_print_name(stderr, trx, TRUE, name);
2451
"because it is referenced by ", ef);
2452
ut_print_name(stderr, trx, TRUE, foreign->foreign_table_name);
2454
mutex_exit(&dict_foreign_err_mutex);
2459
new_id = dict_hdr_get_new_id(DICT_HDR_TABLE_ID);
2461
/* Remove all locks except the table-level S and X locks. */
2462
lock_remove_all_on_table(table, FALSE);
2464
info = pars_info_create();
2466
pars_info_add_str_literal(info, "table_name", name);
2467
pars_info_add_dulint_literal(info, "new_id", new_id);
2469
err = que_eval_sql(info,
2470
"PROCEDURE DISCARD_TABLESPACE_PROC () IS\n"
2473
"SELECT ID INTO old_id\n"
2475
"WHERE NAME = :table_name\n"
2476
"LOCK IN SHARE MODE;\n"
2477
"IF (SQL % NOTFOUND) THEN\n"
2481
"UPDATE SYS_TABLES SET ID = :new_id\n"
2482
" WHERE ID = old_id;\n"
2483
"UPDATE SYS_COLUMNS SET TABLE_ID = :new_id\n"
2484
" WHERE TABLE_ID = old_id;\n"
2485
"UPDATE SYS_INDEXES SET TABLE_ID = :new_id\n"
2486
" WHERE TABLE_ID = old_id;\n"
2491
if (err != DB_SUCCESS) {
2492
trx->error_state = DB_SUCCESS;
2493
trx_general_rollback_for_mysql(trx, FALSE, NULL);
2494
trx->error_state = DB_SUCCESS;
2496
dict_table_change_id_in_cache(table, new_id);
2498
success = fil_discard_tablespace(table->space);
2501
trx->error_state = DB_SUCCESS;
2502
trx_general_rollback_for_mysql(trx, FALSE, NULL);
2503
trx->error_state = DB_SUCCESS;
2507
/* Set the flag which tells that now it is legal to
2508
IMPORT a tablespace for this table */
2509
table->tablespace_discarded = TRUE;
2510
table->ibd_file_missing = TRUE;
2515
trx_commit_for_mysql(trx);
2517
row_mysql_unlock_data_dictionary(trx);
2524
/*****************************************************************//**
2525
Imports a tablespace. The space id in the .ibd file must match the space id
2526
of the table in the data dictionary.
2527
@return error code or DB_SUCCESS */
2530
row_import_tablespace_for_mysql(
2531
/*============================*/
2532
const char* name, /*!< in: table name */
2533
trx_t* trx) /*!< in: transaction handle */
2535
dict_table_t* table;
2537
ib_uint64_t current_lsn;
2538
ulint err = DB_SUCCESS;
2540
ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
2542
trx_start_if_not_started(trx);
2544
trx->op_info = "importing tablespace";
2546
current_lsn = log_get_lsn();
2548
/* It is possible, though very improbable, that the lsn's in the
2549
tablespace to be imported have risen above the current system lsn, if
2550
a lengthy purge, ibuf merge, or rollback was performed on a backup
2551
taken with ibbackup. If that is the case, reset page lsn's in the
2552
file. We assume that mysqld was shut down after it performed these
2553
cleanup operations on the .ibd file, so that it stamped the latest lsn
2554
to the FIL_PAGE_FILE_FLUSH_LSN in the first page of the .ibd file.
2556
TODO: reset also the trx id's in clustered index records and write
2557
a new space id to each data page. That would allow us to import clean
2558
.ibd files from another MySQL installation. */
2560
success = fil_reset_too_high_lsns(name, current_lsn);
2563
ut_print_timestamp(stderr);
2564
fputs(" InnoDB: Error: cannot reset lsn's in table ", stderr);
2565
ut_print_name(stderr, trx, TRUE, name);
2567
"InnoDB: in ALTER TABLE ... IMPORT TABLESPACE\n",
2572
row_mysql_lock_data_dictionary(trx);
2577
/* Serialize data dictionary operations with dictionary mutex:
2578
no deadlocks can occur then in these operations */
2580
row_mysql_lock_data_dictionary(trx);
2582
table = dict_table_get_low(name);
2585
ut_print_timestamp(stderr);
2586
fputs(" InnoDB: table ", stderr);
2587
ut_print_name(stderr, trx, TRUE, name);
2589
"InnoDB: does not exist in the InnoDB data dictionary\n"
2590
"InnoDB: in ALTER TABLE ... IMPORT TABLESPACE\n",
2593
err = DB_TABLE_NOT_FOUND;
2598
if (table->space == 0) {
2599
ut_print_timestamp(stderr);
2600
fputs(" InnoDB: Error: table ", stderr);
2601
ut_print_name(stderr, trx, TRUE, name);
2603
"InnoDB: is in the system tablespace 0"
2604
" which cannot be imported\n", stderr);
2610
if (!table->tablespace_discarded) {
2611
ut_print_timestamp(stderr);
2612
fputs(" InnoDB: Error: you are trying to"
2613
" IMPORT a tablespace\n"
2614
"InnoDB: ", stderr);
2615
ut_print_name(stderr, trx, TRUE, name);
2616
fputs(", though you have not called DISCARD on it yet\n"
2617
"InnoDB: during the lifetime of the mysqld process!\n",
2625
/* Play safe and remove all insert buffer entries, though we should
2626
have removed them already when DISCARD TABLESPACE was called */
2628
ibuf_delete_for_discarded_space(table->space);
2630
success = fil_open_single_table_tablespace(
2632
table->flags == DICT_TF_COMPACT ? 0 : table->flags,
2635
table->ibd_file_missing = FALSE;
2636
table->tablespace_discarded = FALSE;
2638
if (table->ibd_file_missing) {
2639
ut_print_timestamp(stderr);
2640
fputs(" InnoDB: cannot find or open in the"
2641
" database directory the .ibd file of\n"
2642
"InnoDB: table ", stderr);
2643
ut_print_name(stderr, trx, TRUE, name);
2645
"InnoDB: in ALTER TABLE ... IMPORT TABLESPACE\n",
2653
trx_commit_for_mysql(trx);
2655
row_mysql_unlock_data_dictionary(trx);
2662
/*********************************************************************//**
2663
Truncates a table for MySQL.
2664
@return error code or DB_SUCCESS */
2667
row_truncate_table_for_mysql(
2668
/*=========================*/
2669
dict_table_t* table, /*!< in: table handle */
2670
trx_t* trx) /*!< in: transaction handle */
2672
dict_foreign_t* foreign;
2678
dict_index_t* sys_index;
2682
ulint recreate_space = 0;
2683
pars_info_t* info = NULL;
2685
/* How do we prevent crashes caused by ongoing operations on
2686
the table? Old operations could try to access non-existent
2689
1) SQL queries, INSERT, SELECT, ...: we must get an exclusive
2690
MySQL table lock on the table before we can do TRUNCATE
2691
TABLE. Then there are no running queries on the table. This is
2692
guaranteed, because in ha_innobase::store_lock(), we do not
2693
weaken the TL_WRITE lock requested by MySQL when executing
2696
2) Purge and rollback: we assign a new table id for the
2697
table. Since purge and rollback look for the table based on
2698
the table id, they see the table as 'dropped' and discard
2701
3) Insert buffer: TRUNCATE TABLE is analogous to DROP TABLE,
2702
so we do not have to remove insert buffer records, as the
2703
insert buffer works at a low level. If a freed page is later
2704
reallocated, the allocator will remove the ibuf entries for
2707
When we truncate *.ibd files by recreating them (analogous to
2708
DISCARD TABLESPACE), we remove all entries for the table in the
2709
insert buffer tree. This is not strictly necessary, because
2710
in 6) we will assign a new tablespace identifier, but we can
2711
free up some space in the system tablespace.
2713
4) Linear readahead and random readahead: we use the same
2714
method as in 3) to discard ongoing operations. (This is only
2715
relevant for TRUNCATE TABLE by DISCARD TABLESPACE.)
2717
5) FOREIGN KEY operations: if
2718
table->n_foreign_key_checks_running > 0, we do not allow the
2719
TRUNCATE. We also reserve the data dictionary latch.
2721
6) Crash recovery: To prevent the application of pre-truncation
2722
redo log records on the truncated tablespace, we will assign
2723
a new tablespace identifier to the truncated tablespace. */
2725
ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
2728
if (srv_created_new_raw) {
2729
fputs("InnoDB: A new raw disk partition was initialized:\n"
2730
"InnoDB: we do not allow database modifications"
2732
"InnoDB: Shut down mysqld and edit my.cnf so that newraw"
2733
" is replaced with raw.\n", stderr);
2738
trx->op_info = "truncating table";
2740
trx_start_if_not_started(trx);
2742
/* Serialize data dictionary operations with dictionary mutex:
2743
no deadlocks can occur then in these operations */
2745
ut_a(trx->dict_operation_lock_mode == 0);
2746
/* Prevent foreign key checks etc. while we are truncating the
2749
row_mysql_lock_data_dictionary(trx);
2751
ut_ad(mutex_own(&(dict_sys->mutex)));
2752
#ifdef UNIV_SYNC_DEBUG
2753
ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_EX));
2754
#endif /* UNIV_SYNC_DEBUG */
2756
/* Check if the table is referenced by foreign key constraints from
2757
some other table (not the table itself) */
2759
foreign = UT_LIST_GET_FIRST(table->referenced_list);
2761
while (foreign && foreign->foreign_table == table) {
2762
foreign = UT_LIST_GET_NEXT(referenced_list, foreign);
2765
if (foreign && trx->check_foreigns) {
2766
FILE* ef = dict_foreign_err_file;
2768
/* We only allow truncating a referenced table if
2769
FOREIGN_KEY_CHECKS is set to 0 */
2771
mutex_enter(&dict_foreign_err_mutex);
2773
ut_print_timestamp(ef);
2775
fputs(" Cannot truncate table ", ef);
2776
ut_print_name(ef, trx, TRUE, table->name);
2777
fputs(" by DROP+CREATE\n"
2778
"InnoDB: because it is referenced by ", ef);
2779
ut_print_name(ef, trx, TRUE, foreign->foreign_table_name);
2781
mutex_exit(&dict_foreign_err_mutex);
2787
/* TODO: could we replace the counter n_foreign_key_checks_running
2788
with lock checks on the table? Acquire here an exclusive lock on the
2789
table, and rewrite lock0lock.c and the lock wait in srv0srv.c so that
2790
they can cope with the table having been truncated here? Foreign key
2791
checks take an IS or IX lock on the table. */
2793
if (table->n_foreign_key_checks_running > 0) {
2794
ut_print_timestamp(stderr);
2795
fputs(" InnoDB: Cannot truncate table ", stderr);
2796
ut_print_name(stderr, trx, TRUE, table->name);
2797
fputs(" by DROP+CREATE\n"
2798
"InnoDB: because there is a foreign key check"
2799
" running on it.\n",
2806
/* Remove all locks except the table-level S and X locks. */
2807
lock_remove_all_on_table(table, FALSE);
2809
trx->table_id = table->id;
2811
if (table->space && !table->dir_path_of_temp_table) {
2812
/* Discard and create the single-table tablespace. */
2813
ulint space = table->space;
2814
ulint flags = fil_space_get_flags(space);
2816
if (flags != ULINT_UNDEFINED
2817
&& fil_discard_tablespace(space)) {
2819
dict_index_t* index;
2823
if (fil_create_new_single_table_tablespace(
2824
&space, table->name, FALSE, flags,
2825
FIL_IBD_FILE_INITIAL_SIZE) != DB_SUCCESS) {
2826
ut_print_timestamp(stderr);
2828
" InnoDB: TRUNCATE TABLE %s failed to"
2829
" create a new tablespace\n",
2831
table->ibd_file_missing = 1;
2836
recreate_space = space;
2838
/* Replace the space_id in the data dictionary cache.
2839
The persisent data dictionary (SYS_TABLES.SPACE
2840
and SYS_INDEXES.SPACE) are updated later in this
2842
table->space = space;
2843
index = dict_table_get_first_index(table);
2845
index->space = space;
2846
index = dict_table_get_next_index(index);
2850
fsp_header_init(space,
2851
FIL_IBD_FILE_INITIAL_SIZE, &mtr);
2856
/* scan SYS_INDEXES for all indexes of the table */
2857
heap = mem_heap_create(800);
2859
tuple = dtuple_create(heap, 1);
2860
dfield = dtuple_get_nth_field(tuple, 0);
2862
buf = mem_heap_alloc(heap, 8);
2863
mach_write_to_8(buf, table->id);
2865
dfield_set_data(dfield, buf, 8);
2866
sys_index = dict_table_get_first_index(dict_sys->sys_indexes);
2867
dict_index_copy_types(tuple, sys_index, 1);
2870
btr_pcur_open_on_user_rec(sys_index, tuple, PAGE_CUR_GE,
2871
BTR_MODIFY_LEAF, &pcur, &mtr);
2878
if (!btr_pcur_is_on_user_rec(&pcur)) {
2879
/* The end of SYS_INDEXES has been reached. */
2883
rec = btr_pcur_get_rec(&pcur);
2885
field = rec_get_nth_field_old(rec, 0, &len);
2888
if (memcmp(buf, field, len) != 0) {
2889
/* End of indexes for the table (TABLE_ID mismatch). */
2893
if (rec_get_deleted_flag(rec, FALSE)) {
2894
/* The index has been dropped. */
2898
/* This call may commit and restart mtr
2899
and reposition pcur. */
2900
root_page_no = dict_truncate_index_tree(table, recreate_space,
2903
rec = btr_pcur_get_rec(&pcur);
2905
if (root_page_no != FIL_NULL) {
2906
page_rec_write_index_page_no(
2907
rec, DICT_SYS_INDEXES_PAGE_NO_FIELD,
2908
root_page_no, &mtr);
2909
/* We will need to commit and restart the
2910
mini-transaction in order to avoid deadlocks.
2911
The dict_truncate_index_tree() call has allocated
2912
a page in this mini-transaction, and the rest of
2913
this loop could latch another index page. */
2916
btr_pcur_restore_position(BTR_MODIFY_LEAF,
2921
btr_pcur_move_to_next_user_rec(&pcur, &mtr);
2924
btr_pcur_close(&pcur);
2927
mem_heap_free(heap);
2929
new_id = dict_hdr_get_new_id(DICT_HDR_TABLE_ID);
2931
info = pars_info_create();
2933
pars_info_add_int4_literal(info, "space", (lint) table->space);
2934
pars_info_add_dulint_literal(info, "old_id", table->id);
2935
pars_info_add_dulint_literal(info, "new_id", new_id);
2937
err = que_eval_sql(info,
2938
"PROCEDURE RENUMBER_TABLESPACE_PROC () IS\n"
2941
" SET ID = :new_id, SPACE = :space\n"
2942
" WHERE ID = :old_id;\n"
2943
"UPDATE SYS_COLUMNS SET TABLE_ID = :new_id\n"
2944
" WHERE TABLE_ID = :old_id;\n"
2945
"UPDATE SYS_INDEXES"
2946
" SET TABLE_ID = :new_id, SPACE = :space\n"
2947
" WHERE TABLE_ID = :old_id;\n"
2952
if (err != DB_SUCCESS) {
2953
trx->error_state = DB_SUCCESS;
2954
trx_general_rollback_for_mysql(trx, FALSE, NULL);
2955
trx->error_state = DB_SUCCESS;
2956
ut_print_timestamp(stderr);
2957
fputs(" InnoDB: Unable to assign a new identifier to table ",
2959
ut_print_name(stderr, trx, TRUE, table->name);
2961
"InnoDB: after truncating it. Background processes"
2962
" may corrupt the table!\n", stderr);
2965
dict_table_change_id_in_cache(table, new_id);
2969
MySQL calls ha_innobase::reset_auto_increment() which does
2972
dict_table_autoinc_lock(table);
2973
dict_table_autoinc_initialize(table, 1);
2974
dict_table_autoinc_unlock(table);
2975
dict_update_statistics(table);
2977
trx_commit_for_mysql(trx);
2981
row_mysql_unlock_data_dictionary(trx);
2985
srv_wake_master_thread();
2990
/*********************************************************************//**
2991
Drops a table for MySQL. If the name of the dropped table ends in
2992
one of "innodb_monitor", "innodb_lock_monitor", "innodb_tablespace_monitor",
2993
"innodb_table_monitor", then this will also stop the printing of monitor
2994
output by the master thread. If the data dictionary was not already locked
2995
by the transaction, the transaction will be committed. Otherwise, the
2996
data dictionary will remain locked.
2997
@return error code or DB_SUCCESS */
3000
row_drop_table_for_mysql(
3001
/*=====================*/
3002
const char* name, /*!< in: table name */
3003
trx_t* trx, /*!< in: transaction handle */
3004
ibool drop_db)/*!< in: TRUE=dropping whole database */
3006
dict_foreign_t* foreign;
3007
dict_table_t* table;
3010
const char* table_name;
3012
ibool locked_dictionary = FALSE;
3013
pars_info_t* info = NULL;
3017
if (srv_created_new_raw) {
3018
fputs("InnoDB: A new raw disk partition was initialized:\n"
3019
"InnoDB: we do not allow database modifications"
3021
"InnoDB: Shut down mysqld and edit my.cnf so that newraw"
3022
" is replaced with raw.\n", stderr);
3027
trx->op_info = "dropping table";
3029
trx_start_if_not_started(trx);
3031
/* The table name is prefixed with the database name and a '/'.
3032
Certain table names starting with 'innodb_' have their special
3033
meaning regardless of the database name. Thus, we need to
3034
ignore the database name prefix in the comparisons. */
3035
table_name = strchr(name, '/');
3038
namelen = strlen(table_name) + 1;
3040
if (namelen == sizeof S_innodb_monitor
3041
&& !memcmp(table_name, S_innodb_monitor,
3042
sizeof S_innodb_monitor)) {
3044
/* Table name equals "innodb_monitor":
3045
stop monitor prints */
3047
srv_print_innodb_monitor = FALSE;
3048
srv_print_innodb_lock_monitor = FALSE;
3049
} else if (namelen == sizeof S_innodb_lock_monitor
3050
&& !memcmp(table_name, S_innodb_lock_monitor,
3051
sizeof S_innodb_lock_monitor)) {
3052
srv_print_innodb_monitor = FALSE;
3053
srv_print_innodb_lock_monitor = FALSE;
3054
} else if (namelen == sizeof S_innodb_tablespace_monitor
3055
&& !memcmp(table_name, S_innodb_tablespace_monitor,
3056
sizeof S_innodb_tablespace_monitor)) {
3058
srv_print_innodb_tablespace_monitor = FALSE;
3059
} else if (namelen == sizeof S_innodb_table_monitor
3060
&& !memcmp(table_name, S_innodb_table_monitor,
3061
sizeof S_innodb_table_monitor)) {
3063
srv_print_innodb_table_monitor = FALSE;
3066
/* Serialize data dictionary operations with dictionary mutex:
3067
no deadlocks can occur then in these operations */
3069
if (trx->dict_operation_lock_mode != RW_X_LATCH) {
3070
/* Prevent foreign key checks etc. while we are dropping the
3073
row_mysql_lock_data_dictionary(trx);
3075
locked_dictionary = TRUE;
3078
ut_ad(mutex_own(&(dict_sys->mutex)));
3079
#ifdef UNIV_SYNC_DEBUG
3080
ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_EX));
3081
#endif /* UNIV_SYNC_DEBUG */
3083
table = dict_table_get_low(name);
3086
#if defined(BUILD_DRIZZLE)
3089
err = DB_TABLE_NOT_FOUND;
3090
ut_print_timestamp(stderr);
3092
fputs(" InnoDB: Error: table ", stderr);
3093
ut_print_name(stderr, trx, TRUE, name);
3094
fputs(" does not exist in the InnoDB internal\n"
3095
"InnoDB: data dictionary though MySQL is"
3096
" trying to drop it.\n"
3097
"InnoDB: Have you copied the .frm file"
3098
" of the table to the\n"
3099
"InnoDB: MySQL database directory"
3100
" from another database?\n"
3101
"InnoDB: You can look for further help from\n"
3102
"InnoDB: " REFMAN "innodb-troubleshooting.html\n",
3104
#endif /* BUILD_DRIZZLE */
3108
/* Check if the table is referenced by foreign key constraints from
3109
some other table (not the table itself) */
3111
foreign = UT_LIST_GET_FIRST(table->referenced_list);
3113
while (foreign && foreign->foreign_table == table) {
3115
foreign = UT_LIST_GET_NEXT(referenced_list, foreign);
3118
if (foreign && trx->check_foreigns
3119
&& !(drop_db && dict_tables_have_same_db(
3120
name, foreign->foreign_table_name))) {
3121
FILE* ef = dict_foreign_err_file;
3123
/* We only allow dropping a referenced table if
3124
FOREIGN_KEY_CHECKS is set to 0 */
3126
err = DB_CANNOT_DROP_CONSTRAINT;
3128
mutex_enter(&dict_foreign_err_mutex);
3130
ut_print_timestamp(ef);
3132
fputs(" Cannot drop table ", ef);
3133
ut_print_name(ef, trx, TRUE, name);
3135
"because it is referenced by ", ef);
3136
ut_print_name(ef, trx, TRUE, foreign->foreign_table_name);
3138
mutex_exit(&dict_foreign_err_mutex);
3143
if (foreign && trx->check_foreigns) {
3144
goto check_next_foreign;
3147
if (table->n_mysql_handles_opened > 0) {
3150
added = row_add_table_to_background_drop_list(table->name);
3153
ut_print_timestamp(stderr);
3154
fputs(" InnoDB: Warning: MySQL is"
3155
" trying to drop table ", stderr);
3156
ut_print_name(stderr, trx, TRUE, table->name);
3158
"InnoDB: though there are still"
3159
" open handles to it.\n"
3160
"InnoDB: Adding the table to the"
3161
" background drop queue.\n",
3164
/* We return DB_SUCCESS to MySQL though the drop will
3165
happen lazily later */
3168
/* The table is already in the background drop list */
3175
/* TODO: could we replace the counter n_foreign_key_checks_running
3176
with lock checks on the table? Acquire here an exclusive lock on the
3177
table, and rewrite lock0lock.c and the lock wait in srv0srv.c so that
3178
they can cope with the table having been dropped here? Foreign key
3179
checks take an IS or IX lock on the table. */
3181
if (table->n_foreign_key_checks_running > 0) {
3183
const char* table_name = table->name;
3186
added = row_add_table_to_background_drop_list(table_name);
3189
ut_print_timestamp(stderr);
3190
fputs(" InnoDB: You are trying to drop table ",
3192
ut_print_name(stderr, trx, TRUE, table_name);
3194
"InnoDB: though there is a"
3195
" foreign key check running on it.\n"
3196
"InnoDB: Adding the table to"
3197
" the background drop queue.\n",
3200
/* We return DB_SUCCESS to MySQL though the drop will
3201
happen lazily later */
3205
/* The table is already in the background drop list */
3212
/* Remove all locks there are on the table or its records */
3213
lock_remove_all_on_table(table, TRUE);
3215
trx_set_dict_operation(trx, TRX_DICT_OP_TABLE);
3216
trx->table_id = table->id;
3218
/* We use the private SQL parser of Innobase to generate the
3219
query graphs needed in deleting the dictionary data from system
3220
tables in Innobase. Deleting a row from SYS_INDEXES table also
3221
frees the file segments of the B-tree associated with the index. */
3223
info = pars_info_create();
3225
pars_info_add_str_literal(info, "table_name", name);
3227
err = que_eval_sql(info,
3228
"PROCEDURE DROP_TABLE_PROC () IS\n"
3229
"sys_foreign_id CHAR;\n"
3232
"foreign_id CHAR;\n"
3235
"SELECT ID INTO table_id\n"
3237
"WHERE NAME = :table_name\n"
3238
"LOCK IN SHARE MODE;\n"
3239
"IF (SQL % NOTFOUND) THEN\n"
3243
"SELECT ID INTO sys_foreign_id\n"
3245
"WHERE NAME = 'SYS_FOREIGN'\n"
3246
"LOCK IN SHARE MODE;\n"
3247
"IF (SQL % NOTFOUND) THEN\n"
3250
"IF (:table_name = 'SYS_FOREIGN') THEN\n"
3253
"IF (:table_name = 'SYS_FOREIGN_COLS') THEN\n"
3256
"WHILE found = 1 LOOP\n"
3257
" SELECT ID INTO foreign_id\n"
3258
" FROM SYS_FOREIGN\n"
3259
" WHERE FOR_NAME = :table_name\n"
3260
" AND TO_BINARY(FOR_NAME)\n"
3261
" = TO_BINARY(:table_name)\n"
3262
" LOCK IN SHARE MODE;\n"
3263
" IF (SQL % NOTFOUND) THEN\n"
3266
" DELETE FROM SYS_FOREIGN_COLS\n"
3267
" WHERE ID = foreign_id;\n"
3268
" DELETE FROM SYS_FOREIGN\n"
3269
" WHERE ID = foreign_id;\n"
3273
"WHILE found = 1 LOOP\n"
3274
" SELECT ID INTO index_id\n"
3275
" FROM SYS_INDEXES\n"
3276
" WHERE TABLE_ID = table_id\n"
3277
" LOCK IN SHARE MODE;\n"
3278
" IF (SQL % NOTFOUND) THEN\n"
3281
" DELETE FROM SYS_FIELDS\n"
3282
" WHERE INDEX_ID = index_id;\n"
3283
" DELETE FROM SYS_INDEXES\n"
3284
" WHERE ID = index_id\n"
3285
" AND TABLE_ID = table_id;\n"
3288
"DELETE FROM SYS_COLUMNS\n"
3289
"WHERE TABLE_ID = table_id;\n"
3290
"DELETE FROM SYS_TABLES\n"
3291
"WHERE ID = table_id;\n"
3295
if (err != DB_SUCCESS) {
3296
ut_a(err == DB_OUT_OF_FILE_SPACE);
3298
err = DB_MUST_GET_MORE_FILE_SPACE;
3300
row_mysql_handle_errors(&err, trx, NULL, NULL);
3305
const char* name_or_path;
3308
heap = mem_heap_create(200);
3310
/* Clone the name, in case it has been allocated
3311
from table->heap, which will be freed by
3312
dict_table_remove_from_cache(table) below. */
3313
name = mem_heap_strdup(heap, name);
3314
space_id = table->space;
3316
if (table->dir_path_of_temp_table != NULL) {
3318
name_or_path = mem_heap_strdup(
3319
heap, table->dir_path_of_temp_table);
3322
name_or_path = name;
3325
dict_table_remove_from_cache(table);
3327
if (dict_load_table(name) != NULL) {
3328
ut_print_timestamp(stderr);
3329
fputs(" InnoDB: Error: not able to remove table ",
3331
ut_print_name(stderr, trx, TRUE, name);
3332
fputs(" from the dictionary cache!\n", stderr);
3336
/* Do not drop possible .ibd tablespace if something went
3337
wrong: we do not want to delete valuable data of the user */
3339
if (err == DB_SUCCESS && space_id > 0) {
3340
if (!fil_space_for_table_exists_in_mem(space_id,
3347
"InnoDB: We removed now the InnoDB"
3348
" internal data dictionary entry\n"
3349
"InnoDB: of table ");
3350
ut_print_name(stderr, trx, TRUE, name);
3351
fprintf(stderr, ".\n");
3352
} else if (!fil_delete_tablespace(space_id)) {
3354
"InnoDB: We removed now the InnoDB"
3355
" internal data dictionary entry\n"
3356
"InnoDB: of table ");
3357
ut_print_name(stderr, trx, TRUE, name);
3358
fprintf(stderr, ".\n");
3360
ut_print_timestamp(stderr);
3362
" InnoDB: Error: not able to"
3363
" delete tablespace %lu of table ",
3365
ut_print_name(stderr, trx, TRUE, name);
3366
fputs("!\n", stderr);
3371
mem_heap_free(heap);
3375
if (locked_dictionary) {
3376
trx_commit_for_mysql(trx);
3378
row_mysql_unlock_data_dictionary(trx);
3383
srv_wake_master_thread();
3388
/*******************************************************************//**
3389
Drop all foreign keys in a database, see Bug#18942.
3390
Called at the end of row_drop_database_for_mysql().
3391
@return error code or DB_SUCCESS */
3394
drop_all_foreign_keys_in_db(
3395
/*========================*/
3396
const char* name, /*!< in: database name which ends to '/' */
3397
trx_t* trx) /*!< in: transaction handle */
3402
ut_a(name[strlen(name) - 1] == '/');
3404
pinfo = pars_info_create();
3406
pars_info_add_str_literal(pinfo, "dbname", name);
3408
/** true if for_name is not prefixed with dbname */
3409
#define TABLE_NOT_IN_THIS_DB \
3410
"SUBSTR(for_name, 0, LENGTH(:dbname)) <> :dbname"
3412
err = que_eval_sql(pinfo,
3413
"PROCEDURE DROP_ALL_FOREIGN_KEYS_PROC () IS\n"
3414
"foreign_id CHAR;\n"
3417
"DECLARE CURSOR cur IS\n"
3418
"SELECT ID, FOR_NAME FROM SYS_FOREIGN\n"
3419
"WHERE FOR_NAME >= :dbname\n"
3420
"LOCK IN SHARE MODE\n"
3421
"ORDER BY FOR_NAME;\n"
3425
"WHILE found = 1 LOOP\n"
3426
" FETCH cur INTO foreign_id, for_name;\n"
3427
" IF (SQL % NOTFOUND) THEN\n"
3429
" ELSIF (" TABLE_NOT_IN_THIS_DB ") THEN\n"
3431
" ELSIF (1=1) THEN\n"
3432
" DELETE FROM SYS_FOREIGN_COLS\n"
3433
" WHERE ID = foreign_id;\n"
3434
" DELETE FROM SYS_FOREIGN\n"
3435
" WHERE ID = foreign_id;\n"
3441
FALSE, /* do not reserve dict mutex,
3442
we are already holding it */
3448
/*********************************************************************//**
3449
Drops a database for MySQL.
3450
@return error code or DB_SUCCESS */
3453
row_drop_database_for_mysql(
3454
/*========================*/
3455
const char* name, /*!< in: database name which ends to '/' */
3456
trx_t* trx) /*!< in: transaction handle */
3458
dict_table_t* table;
3460
int err = DB_SUCCESS;
3461
ulint namelen = strlen(name);
3463
ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
3465
ut_a(name[namelen - 1] == '/');
3467
trx->op_info = "dropping database";
3469
trx_start_if_not_started(trx);
3471
row_mysql_lock_data_dictionary(trx);
3473
while ((table_name = dict_get_first_table_name_in_db(name))) {
3474
ut_a(memcmp(table_name, name, namelen) == 0);
3476
table = dict_table_get_low(table_name);
3480
/* Wait until MySQL does not have any queries running on
3483
if (table->n_mysql_handles_opened > 0) {
3484
row_mysql_unlock_data_dictionary(trx);
3486
ut_print_timestamp(stderr);
3487
fputs(" InnoDB: Warning: MySQL is trying to"
3488
" drop database ", stderr);
3489
ut_print_name(stderr, trx, TRUE, name);
3491
"InnoDB: though there are still"
3492
" open handles to table ", stderr);
3493
ut_print_name(stderr, trx, TRUE, table_name);
3494
fputs(".\n", stderr);
3496
os_thread_sleep(1000000);
3498
mem_free(table_name);
3503
err = row_drop_table_for_mysql(table_name, trx, TRUE);
3504
trx_commit_for_mysql(trx);
3506
if (err != DB_SUCCESS) {
3507
fputs("InnoDB: DROP DATABASE ", stderr);
3508
ut_print_name(stderr, trx, TRUE, name);
3509
fprintf(stderr, " failed with error %lu for table ",
3511
ut_print_name(stderr, trx, TRUE, table_name);
3513
mem_free(table_name);
3517
mem_free(table_name);
3520
if (err == DB_SUCCESS) {
3521
/* after dropping all tables try to drop all leftover
3522
foreign keys in case orphaned ones exist */
3523
err = (int) drop_all_foreign_keys_in_db(name, trx);
3525
if (err != DB_SUCCESS) {
3526
fputs("InnoDB: DROP DATABASE ", stderr);
3527
ut_print_name(stderr, trx, TRUE, name);
3528
fprintf(stderr, " failed with error %d while "
3529
"dropping all foreign keys", err);
3533
trx_commit_for_mysql(trx);
3535
row_mysql_unlock_data_dictionary(trx);
3542
/*********************************************************************//**
3543
Checks if a table name contains the string "/#sql" which denotes temporary
3545
@return TRUE if temporary table */
3548
row_is_mysql_tmp_table_name(
3549
/*========================*/
3550
const char* name) /*!< in: table name in the form
3551
'database/tablename' */
3553
return(strstr(name, "/#sql") != NULL);
3554
/* return(strstr(name, "/@0023sql") != NULL); */
3557
/****************************************************************//**
3558
Delete a single constraint.
3559
@return error code or DB_SUCCESS */
3562
row_delete_constraint_low(
3563
/*======================*/
3564
const char* id, /*!< in: constraint id */
3565
trx_t* trx) /*!< in: transaction handle */
3567
pars_info_t* info = pars_info_create();
3569
pars_info_add_str_literal(info, "id", id);
3571
return((int) que_eval_sql(info,
3572
"PROCEDURE DELETE_CONSTRAINT () IS\n"
3574
"DELETE FROM SYS_FOREIGN_COLS WHERE ID = :id;\n"
3575
"DELETE FROM SYS_FOREIGN WHERE ID = :id;\n"
3580
/****************************************************************//**
3581
Delete a single constraint.
3582
@return error code or DB_SUCCESS */
3585
row_delete_constraint(
3586
/*==================*/
3587
const char* id, /*!< in: constraint id */
3588
const char* database_name, /*!< in: database name, with the
3590
mem_heap_t* heap, /*!< in: memory heap */
3591
trx_t* trx) /*!< in: transaction handle */
3595
/* New format constraints have ids <databasename>/<constraintname>. */
3596
err = row_delete_constraint_low(
3597
mem_heap_strcat(heap, database_name, id), trx);
3599
if ((err == DB_SUCCESS) && !strchr(id, '/')) {
3600
/* Old format < 4.0.18 constraints have constraint ids
3601
<number>_<number>. We only try deleting them if the
3602
constraint name does not contain a '/' character, otherwise
3603
deleting a new format constraint named 'foo/bar' from
3604
database 'baz' would remove constraint 'bar' from database
3605
'foo', if it existed. */
3607
err = row_delete_constraint_low(id, trx);
3613
/*********************************************************************//**
3614
Renames a table for MySQL.
3615
@return error code or DB_SUCCESS */
3618
row_rename_table_for_mysql(
3619
/*=======================*/
3620
const char* old_name, /*!< in: old table name */
3621
const char* new_name, /*!< in: new table name */
3622
trx_t* trx, /*!< in: transaction handle */
3623
ibool commit) /*!< in: if TRUE then commit trx */
3625
dict_table_t* table;
3626
ulint err = DB_ERROR;
3627
mem_heap_t* heap = NULL;
3628
const char** constraints_to_drop = NULL;
3629
ulint n_constraints_to_drop = 0;
3630
ibool old_is_tmp, new_is_tmp;
3631
pars_info_t* info = NULL;
3633
ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
3634
ut_a(old_name != NULL);
3635
ut_a(new_name != NULL);
3637
if (srv_created_new_raw || srv_force_recovery) {
3638
fputs("InnoDB: A new raw disk partition was initialized or\n"
3639
"InnoDB: innodb_force_recovery is on: we do not allow\n"
3640
"InnoDB: database modifications by the user. Shut down\n"
3641
"InnoDB: mysqld and edit my.cnf so that newraw"
3643
"InnoDB: with raw, and innodb_force_... is removed.\n",
3647
} else if (row_mysql_is_system_table(new_name)) {
3650
"InnoDB: Error: trying to create a MySQL"
3651
" system table %s of type InnoDB.\n"
3652
"InnoDB: MySQL system tables must be"
3653
" of the MyISAM type!\n",
3659
trx->op_info = "renaming table";
3660
trx_start_if_not_started(trx);
3662
old_is_tmp = row_is_mysql_tmp_table_name(old_name);
3663
new_is_tmp = row_is_mysql_tmp_table_name(new_name);
3665
table = dict_table_get_low(old_name);
3668
#if defined(BUILD_DRIZZLE)
3671
err = DB_TABLE_NOT_FOUND;
3672
ut_print_timestamp(stderr);
3674
fputs(" InnoDB: Error: table ", stderr);
3675
ut_print_name(stderr, trx, TRUE, old_name);
3676
fputs(" does not exist in the InnoDB internal\n"
3677
"InnoDB: data dictionary though MySQL is"
3678
" trying to rename the table.\n"
3679
"InnoDB: Have you copied the .frm file"
3680
" of the table to the\n"
3681
"InnoDB: MySQL database directory"
3682
" from another database?\n"
3683
"InnoDB: You can look for further help from\n"
3684
"InnoDB: " REFMAN "innodb-troubleshooting.html\n",
3686
#endif /* BUILD_DRIZZLE */
3688
} else if (table->ibd_file_missing) {
3689
err = DB_TABLE_NOT_FOUND;
3690
ut_print_timestamp(stderr);
3692
fputs(" InnoDB: Error: table ", stderr);
3693
ut_print_name(stderr, trx, TRUE, old_name);
3694
fputs(" does not have an .ibd file"
3695
" in the database directory.\n"
3696
"InnoDB: You can look for further help from\n"
3697
"InnoDB: " REFMAN "innodb-troubleshooting.html\n",
3700
} else if (new_is_tmp) {
3701
/* MySQL is doing an ALTER TABLE command and it renames the
3702
original table to a temporary table name. We want to preserve
3703
the original foreign key constraint definitions despite the
3704
name change. An exception is those constraints for which
3705
the ALTER TABLE contained DROP FOREIGN KEY <foreign key id>.*/
3707
heap = mem_heap_create(100);
3709
err = dict_foreign_parse_drop_constraints(
3710
heap, trx, table, &n_constraints_to_drop,
3711
&constraints_to_drop);
3713
if (err != DB_SUCCESS) {
3719
/* We use the private SQL parser of Innobase to generate the query
3720
graphs needed in updating the dictionary data from system tables. */
3722
info = pars_info_create();
3724
pars_info_add_str_literal(info, "new_table_name", new_name);
3725
pars_info_add_str_literal(info, "old_table_name", old_name);
3727
err = que_eval_sql(info,
3728
"PROCEDURE RENAME_TABLE () IS\n"
3730
"UPDATE SYS_TABLES SET NAME = :new_table_name\n"
3731
" WHERE NAME = :old_table_name;\n"
3735
if (err != DB_SUCCESS) {
3738
} else if (!new_is_tmp) {
3739
/* Rename all constraints. */
3741
info = pars_info_create();
3743
pars_info_add_str_literal(info, "new_table_name", new_name);
3744
pars_info_add_str_literal(info, "old_table_name", old_name);
3748
"PROCEDURE RENAME_CONSTRAINT_IDS () IS\n"
3749
"gen_constr_prefix CHAR;\n"
3750
"new_db_name CHAR;\n"
3751
"foreign_id CHAR;\n"
3752
"new_foreign_id CHAR;\n"
3753
"old_db_name_len INT;\n"
3754
"old_t_name_len INT;\n"
3755
"new_db_name_len INT;\n"
3760
"old_db_name_len := INSTR(:old_table_name, '/')-1;\n"
3761
"new_db_name_len := INSTR(:new_table_name, '/')-1;\n"
3762
"new_db_name := SUBSTR(:new_table_name, 0,\n"
3763
" new_db_name_len);\n"
3764
"old_t_name_len := LENGTH(:old_table_name);\n"
3765
"gen_constr_prefix := CONCAT(:old_table_name,\n"
3767
"WHILE found = 1 LOOP\n"
3768
" SELECT ID INTO foreign_id\n"
3769
" FROM SYS_FOREIGN\n"
3770
" WHERE FOR_NAME = :old_table_name\n"
3771
" AND TO_BINARY(FOR_NAME)\n"
3772
" = TO_BINARY(:old_table_name)\n"
3773
" LOCK IN SHARE MODE;\n"
3774
" IF (SQL % NOTFOUND) THEN\n"
3777
" UPDATE SYS_FOREIGN\n"
3778
" SET FOR_NAME = :new_table_name\n"
3779
" WHERE ID = foreign_id;\n"
3780
" id_len := LENGTH(foreign_id);\n"
3781
" IF (INSTR(foreign_id, '/') > 0) THEN\n"
3782
" IF (INSTR(foreign_id,\n"
3783
" gen_constr_prefix) > 0)\n"
3785
" new_foreign_id :=\n"
3786
" CONCAT(:new_table_name,\n"
3787
" SUBSTR(foreign_id, old_t_name_len,\n"
3788
" id_len - old_t_name_len));\n"
3790
" new_foreign_id :=\n"
3791
" CONCAT(new_db_name,\n"
3792
" SUBSTR(foreign_id,\n"
3793
" old_db_name_len,\n"
3794
" id_len - old_db_name_len));\n"
3796
" UPDATE SYS_FOREIGN\n"
3797
" SET ID = new_foreign_id\n"
3798
" WHERE ID = foreign_id;\n"
3799
" UPDATE SYS_FOREIGN_COLS\n"
3800
" SET ID = new_foreign_id\n"
3801
" WHERE ID = foreign_id;\n"
3805
"UPDATE SYS_FOREIGN SET REF_NAME = :new_table_name\n"
3806
"WHERE REF_NAME = :old_table_name\n"
3807
" AND TO_BINARY(REF_NAME)\n"
3808
" = TO_BINARY(:old_table_name);\n"
3812
} else if (n_constraints_to_drop > 0) {
3813
/* Drop some constraints of tmp tables. */
3815
ulint db_name_len = dict_get_db_name_len(old_name) + 1;
3816
char* db_name = mem_heap_strdupl(heap, old_name,
3820
for (i = 0; i < n_constraints_to_drop; i++) {
3821
err = row_delete_constraint(constraints_to_drop[i],
3822
db_name, heap, trx);
3824
if (err != DB_SUCCESS) {
3831
if (err != DB_SUCCESS) {
3832
if (err == DB_DUPLICATE_KEY) {
3833
ut_print_timestamp(stderr);
3834
fputs(" InnoDB: Error; possible reasons:\n"
3835
"InnoDB: 1) Table rename would cause"
3836
" two FOREIGN KEY constraints\n"
3837
"InnoDB: to have the same internal name"
3838
" in case-insensitive comparison.\n"
3839
"InnoDB: 2) table ", stderr);
3840
ut_print_name(stderr, trx, TRUE, new_name);
3841
fputs(" exists in the InnoDB internal data\n"
3842
"InnoDB: dictionary though MySQL is"
3843
" trying to rename table ", stderr);
3844
ut_print_name(stderr, trx, TRUE, old_name);
3846
"InnoDB: Have you deleted the .frm file"
3847
" and not used DROP TABLE?\n"
3848
"InnoDB: You can look for further help from\n"
3849
"InnoDB: " REFMAN "innodb-troubleshooting.html\n"
3850
"InnoDB: If table ", stderr);
3851
ut_print_name(stderr, trx, TRUE, new_name);
3852
fputs(" is a temporary table #sql..., then"
3854
"InnoDB: there are still queries running"
3855
" on the table, and it will be\n"
3856
"InnoDB: dropped automatically when"
3857
" the queries end.\n"
3858
"InnoDB: You can drop the orphaned table"
3859
" inside InnoDB by\n"
3860
"InnoDB: creating an InnoDB table with"
3861
" the same name in another\n"
3862
"InnoDB: database and copying the .frm file"
3863
" to the current database.\n"
3864
"InnoDB: Then MySQL thinks the table exists,"
3865
" and DROP TABLE will\n"
3866
"InnoDB: succeed.\n", stderr);
3868
trx->error_state = DB_SUCCESS;
3869
trx_general_rollback_for_mysql(trx, FALSE, NULL);
3870
trx->error_state = DB_SUCCESS;
3872
/* The following call will also rename the .ibd data file if
3873
the table is stored in a single-table tablespace */
3875
if (!dict_table_rename_in_cache(table, new_name,
3877
trx->error_state = DB_SUCCESS;
3878
trx_general_rollback_for_mysql(trx, FALSE, NULL);
3879
trx->error_state = DB_SUCCESS;
3883
/* We only want to switch off some of the type checking in
3884
an ALTER, not in a RENAME. */
3886
err = dict_load_foreigns(
3887
new_name, !old_is_tmp || trx->check_foreigns);
3889
if (err != DB_SUCCESS) {
3890
ut_print_timestamp(stderr);
3893
fputs(" InnoDB: Error: in ALTER TABLE ",
3895
ut_print_name(stderr, trx, TRUE, new_name);
3897
"InnoDB: has or is referenced"
3898
" in foreign key constraints\n"
3899
"InnoDB: which are not compatible"
3900
" with the new table definition.\n",
3903
fputs(" InnoDB: Error: in RENAME TABLE"
3906
ut_print_name(stderr, trx, TRUE, new_name);
3908
"InnoDB: is referenced in"
3909
" foreign key constraints\n"
3910
"InnoDB: which are not compatible"
3911
" with the new table definition.\n",
3915
ut_a(dict_table_rename_in_cache(table,
3917
trx->error_state = DB_SUCCESS;
3918
trx_general_rollback_for_mysql(trx, FALSE, NULL);
3919
trx->error_state = DB_SUCCESS;
3926
trx_commit_for_mysql(trx);
3929
if (UNIV_LIKELY_NULL(heap)) {
3930
mem_heap_free(heap);
3938
/*********************************************************************//**
3939
Checks that the index contains entries in an ascending order, unique
3940
constraint is not broken, and calculates the number of index entries
3941
in the read view of the current transaction.
3942
@return TRUE if ok */
3945
row_scan_and_check_index(
3946
/*=====================*/
3947
row_prebuilt_t* prebuilt, /*!< in: prebuilt struct in MySQL */
3948
dict_index_t* index, /*!< in: index */
3949
ulint* n_rows) /*!< out: number of entries seen in the
3950
current consistent read */
3952
dtuple_t* prev_entry = NULL;
3953
ulint matched_fields;
3954
ulint matched_bytes;
3960
ibool contains_null;
3963
mem_heap_t* heap = NULL;
3965
ulint offsets_[REC_OFFS_NORMAL_SIZE];
3967
rec_offs_init(offsets_);
3971
if (!row_merge_is_index_usable(prebuilt->trx, index)) {
3972
/* A newly created index may lack some delete-marked
3973
records that may exist in the read view of
3974
prebuilt->trx. Thus, such indexes must not be
3975
accessed by consistent read. */
3979
buf = mem_alloc(UNIV_PAGE_SIZE);
3980
heap = mem_heap_create(100);
3982
/* Make a dummy template in prebuilt, which we will use
3983
in scanning the index entries */
3985
prebuilt->index = index;
3986
/* row_merge_is_index_usable() was already checked above. */
3987
prebuilt->index_usable = TRUE;
3988
prebuilt->sql_stat_start = TRUE;
3989
prebuilt->template_type = ROW_MYSQL_DUMMY_TEMPLATE;
3990
prebuilt->n_template = 0;
3991
prebuilt->need_to_access_clustered = FALSE;
3993
dtuple_set_n_fields(prebuilt->search_tuple, 0);
3995
prebuilt->select_lock_type = LOCK_NONE;
3998
ret = row_search_for_mysql(buf, PAGE_CUR_G, prebuilt, 0, 0);
4000
/* Check thd->killed every 1,000 scanned rows */
4002
if (trx_is_interrupted(prebuilt->trx)) {
4012
ut_print_timestamp(stderr);
4013
fputs(" InnoDB: Warning: CHECK TABLE on ", stderr);
4014
dict_index_name_print(stderr, prebuilt->trx, index);
4015
fprintf(stderr, " returned %lu\n", ret);
4016
/* fall through (this error is ignored by CHECK TABLE) */
4017
case DB_END_OF_INDEX:
4020
mem_heap_free(heap);
4025
*n_rows = *n_rows + 1;
4027
/* row_search... returns the index record in buf, record origin offset
4028
within buf stored in the first 4 bytes, because we have built a dummy
4031
rec = buf + mach_read_from_4(buf);
4033
offsets = rec_get_offsets(rec, index, offsets_,
4034
ULINT_UNDEFINED, &heap);
4036
if (prev_entry != NULL) {
4040
cmp = cmp_dtuple_rec_with_match(prev_entry, rec, offsets,
4043
contains_null = FALSE;
4045
/* In a unique secondary index we allow equal key values if
4046
they contain SQL NULLs */
4049
i < dict_index_get_n_ordering_defined_by_user(index);
4051
if (UNIV_SQL_NULL == dfield_get_len(
4052
dtuple_get_nth_field(prev_entry, i))) {
4054
contains_null = TRUE;
4059
fputs("InnoDB: index records in a wrong order in ",
4062
dict_index_name_print(stderr,
4063
prebuilt->trx, index);
4065
"InnoDB: prev record ", stderr);
4066
dtuple_print(stderr, prev_entry);
4068
"InnoDB: record ", stderr);
4069
rec_print_new(stderr, rec, offsets);
4072
} else if (dict_index_is_unique(index)
4075
>= dict_index_get_n_ordering_defined_by_user(
4078
fputs("InnoDB: duplicate key in ", stderr);
4084
mem_heap_t* tmp_heap = NULL;
4086
/* Empty the heap on each round. But preserve offsets[]
4087
for the row_rec_to_index_entry() call, by copying them
4088
into a separate memory heap when needed. */
4089
if (UNIV_UNLIKELY(offsets != offsets_)) {
4090
ulint size = rec_offs_get_n_alloc(offsets)
4093
tmp_heap = mem_heap_create(size);
4094
offsets = mem_heap_dup(tmp_heap, offsets, size);
4097
mem_heap_empty(heap);
4099
prev_entry = row_rec_to_index_entry(ROW_COPY_DATA, rec,
4103
if (UNIV_LIKELY_NULL(tmp_heap)) {
4104
mem_heap_free(tmp_heap);
4108
ret = row_search_for_mysql(buf, PAGE_CUR_G, prebuilt, 0, ROW_SEL_NEXT);
4113
/*********************************************************************//**
4114
Checks a table for corruption.
4115
@return DB_ERROR or DB_SUCCESS */
4118
row_check_table_for_mysql(
4119
/*======================*/
4120
row_prebuilt_t* prebuilt) /*!< in: prebuilt struct in MySQL
4123
dict_table_t* table = prebuilt->table;
4124
dict_index_t* index;
4126
ulint n_rows_in_table = ULINT_UNDEFINED;
4127
ulint ret = DB_SUCCESS;
4128
ulint old_isolation_level;
4130
if (table->ibd_file_missing) {
4131
ut_print_timestamp(stderr);
4132
fprintf(stderr, " InnoDB: Error:\n"
4133
"InnoDB: MySQL is trying to use a table handle"
4134
" but the .ibd file for\n"
4135
"InnoDB: table %s does not exist.\n"
4136
"InnoDB: Have you deleted the .ibd file"
4137
" from the database directory under\n"
4138
"InnoDB: the MySQL datadir, or have you"
4139
" used DISCARD TABLESPACE?\n"
4140
"InnoDB: Look from\n"
4141
"InnoDB: " REFMAN "innodb-troubleshooting.html\n"
4142
"InnoDB: how you can resolve the problem.\n",
4147
prebuilt->trx->op_info = "checking table";
4149
old_isolation_level = prebuilt->trx->isolation_level;
4151
/* We must run the index record counts at an isolation level
4152
>= READ COMMITTED, because a dirty read can see a wrong number
4153
of records in some index; to play safe, we use always
4154
REPEATABLE READ here */
4156
prebuilt->trx->isolation_level = TRX_ISO_REPEATABLE_READ;
4158
/* Enlarge the fatal lock wait timeout during CHECK TABLE. */
4159
mutex_enter(&kernel_mutex);
4160
srv_fatal_semaphore_wait_threshold += 7200; /* 2 hours */
4161
mutex_exit(&kernel_mutex);
4163
index = dict_table_get_first_index(table);
4165
while (index != NULL) {
4166
/* fputs("Validating index ", stderr);
4167
ut_print_name(stderr, trx, FALSE, index->name);
4168
putc('\n', stderr); */
4170
if (!btr_validate_index(index, prebuilt->trx)) {
4173
if (!row_scan_and_check_index(prebuilt,index, &n_rows)){
4177
if (trx_is_interrupted(prebuilt->trx)) {
4181
/* fprintf(stderr, "%lu entries in index %s\n", n_rows,
4184
if (index == dict_table_get_first_index(table)) {
4185
n_rows_in_table = n_rows;
4186
} else if (n_rows != n_rows_in_table) {
4190
fputs("Error: ", stderr);
4191
dict_index_name_print(stderr,
4192
prebuilt->trx, index);
4194
" contains %lu entries,"
4197
(ulong) n_rows_in_table);
4201
index = dict_table_get_next_index(index);
4204
/* Restore the original isolation level */
4205
prebuilt->trx->isolation_level = old_isolation_level;
4207
/* We validate also the whole adaptive hash index for all tables
4208
at every CHECK TABLE */
4210
if (!btr_search_validate()) {
4215
/* Restore the fatal lock wait timeout after CHECK TABLE. */
4216
mutex_enter(&kernel_mutex);
4217
srv_fatal_semaphore_wait_threshold -= 7200; /* 2 hours */
4218
mutex_exit(&kernel_mutex);
4220
prebuilt->trx->op_info = "";
4225
/*********************************************************************//**
4226
Determines if a table is a magic monitor table.
4227
@return TRUE if monitor table */
4230
row_is_magic_monitor_table(
4231
/*=======================*/
4232
const char* table_name) /*!< in: name of the table, in the
4233
form database/table_name */
4235
const char* name; /* table_name without database/ */
4238
name = strchr(table_name, '/');
4241
len = strlen(name) + 1;
4243
if (STR_EQ(name, len, S_innodb_monitor)
4244
|| STR_EQ(name, len, S_innodb_lock_monitor)
4245
|| STR_EQ(name, len, S_innodb_tablespace_monitor)
4246
|| STR_EQ(name, len, S_innodb_table_monitor)
4247
|| STR_EQ(name, len, S_innodb_mem_validate)) {
added
removed
plugin/innobase/row/row0mysql.c
