2016-02-09 11:27:40 +01:00
|
|
|
/* Copyright (c) 2010, 2015, Oracle and/or its affiliates.
|
2021-05-18 08:40:19 +03:00
|
|
|
Copyright (c) 2011, 2021, MariaDB
|
2010-08-16 14:53:30 +02:00
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; version 2 of the License.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program; if not, write to the Free Software
|
2019-05-11 21:29:06 +03:00
|
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
|
2010-08-16 14:53:30 +02:00
|
|
|
|
2017-06-18 06:42:16 +03:00
|
|
|
#include "mariadb.h"
|
|
|
|
#include "sql_class.h" // THD
|
2010-08-16 14:53:30 +02:00
|
|
|
#include "keycaches.h" // get_key_cache
|
|
|
|
#include "sql_base.h" // Open_table_context
|
|
|
|
#include "lock.h" // MYSQL_OPEN_*
|
|
|
|
#include "sql_handler.h" // mysql_ha_rm_tables
|
|
|
|
#include "partition_element.h" // PART_ADMIN
|
|
|
|
#include "sql_partition.h" // set_part_state
|
|
|
|
#include "transaction.h" // trans_rollback_stmt
|
|
|
|
#include "sql_view.h" // view_checksum
|
|
|
|
#include "sql_table.h" // mysql_recreate_table
|
|
|
|
#include "debug_sync.h" // DEBUG_SYNC
|
|
|
|
#include "sp.h" // Sroutine_hash_entry
|
|
|
|
#include "sql_parse.h" // check_table_access
|
2012-05-22 20:55:07 -07:00
|
|
|
#include "strfunc.h"
|
2010-08-16 16:25:23 +02:00
|
|
|
#include "sql_admin.h"
|
2012-12-13 23:05:12 -08:00
|
|
|
#include "sql_statistics.h"
|
2020-10-27 12:45:42 +02:00
|
|
|
#include "wsrep_mysqld.h"
|
2023-08-08 07:43:37 +03:00
|
|
|
#ifdef WITH_WSREP
|
|
|
|
#include "wsrep_trans_observer.h"
|
|
|
|
#endif
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
|
2021-08-31 18:02:38 +03:00
|
|
|
const LEX_CSTRING msg_status= {STRING_WITH_LEN("status")};
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
const LEX_CSTRING msg_repair= { STRING_WITH_LEN("repair") };
|
|
|
|
const LEX_CSTRING msg_assign_to_keycache=
|
|
|
|
{ STRING_WITH_LEN("assign_to_keycache") };
|
|
|
|
const LEX_CSTRING msg_analyze= { STRING_WITH_LEN("analyze") };
|
|
|
|
const LEX_CSTRING msg_check= { STRING_WITH_LEN("check") };
|
|
|
|
const LEX_CSTRING msg_preload_keys= { STRING_WITH_LEN("preload_keys") };
|
|
|
|
const LEX_CSTRING msg_optimize= { STRING_WITH_LEN("optimize") };
|
|
|
|
|
2010-11-25 18:17:28 +01:00
|
|
|
/* Prepare, run and cleanup for mysql_recreate_table() */
|
|
|
|
|
2022-10-28 13:43:51 +04:00
|
|
|
static bool admin_recreate_table(THD *thd, TABLE_LIST *table_list,
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
Recreate_info *recreate_info,
|
|
|
|
bool table_copy)
|
2010-11-25 18:17:28 +01:00
|
|
|
{
|
|
|
|
bool result_code;
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
TABLE_LIST *save_next_global;
|
2010-11-25 18:17:28 +01:00
|
|
|
DBUG_ENTER("admin_recreate_table");
|
|
|
|
|
|
|
|
trans_rollback_stmt(thd);
|
|
|
|
trans_rollback(thd);
|
|
|
|
close_thread_tables(thd);
|
2020-11-30 15:29:32 +02:00
|
|
|
thd->release_transactional_locks();
|
2013-06-28 01:53:41 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
table_list->table has been closed and freed. Do not reference
|
|
|
|
uninitialized data. open_tables() could fail.
|
|
|
|
*/
|
|
|
|
table_list->table= NULL;
|
|
|
|
/* Same applies to MDL ticket. */
|
|
|
|
table_list->mdl_request.ticket= NULL;
|
|
|
|
|
2011-04-25 17:22:25 +02:00
|
|
|
DEBUG_SYNC(thd, "ha_admin_try_alter");
|
2010-11-25 18:17:28 +01:00
|
|
|
tmp_disable_binlog(thd); // binlogging is done by caller if wanted
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
/* Ignore if there is more than one table in the list */
|
|
|
|
save_next_global= table_list->next_global;
|
|
|
|
table_list->next_global= 0;
|
2016-06-10 16:19:59 -04:00
|
|
|
result_code= (thd->open_temporary_tables(table_list) ||
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
mysql_recreate_table(thd, table_list, recreate_info,
|
|
|
|
table_copy));
|
|
|
|
table_list->next_global= save_next_global;
|
2010-11-25 18:17:28 +01:00
|
|
|
reenable_binlog(thd);
|
|
|
|
/*
|
|
|
|
mysql_recreate_table() can push OK or ERROR.
|
|
|
|
Clear 'OK' status. If there is an error, keep it:
|
|
|
|
we will store the error message in a result set row
|
|
|
|
and then clear.
|
|
|
|
*/
|
2013-06-15 18:32:08 +03:00
|
|
|
if (thd->get_stmt_da()->is_ok())
|
|
|
|
thd->get_stmt_da()->reset_diagnostics_area();
|
2011-04-25 17:22:25 +02:00
|
|
|
table_list->table= NULL;
|
2010-11-25 18:17:28 +01:00
|
|
|
DBUG_RETURN(result_code);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-08-16 14:53:30 +02:00
|
|
|
static int send_check_errmsg(THD *thd, TABLE_LIST* table,
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
const LEX_CSTRING *operator_name,
|
|
|
|
const char* errmsg)
|
2010-08-16 14:53:30 +02:00
|
|
|
|
|
|
|
{
|
|
|
|
Protocol *protocol= thd->protocol;
|
|
|
|
protocol->prepare_for_resend();
|
2018-01-07 18:03:44 +02:00
|
|
|
protocol->store(table->alias.str, table->alias.length, system_charset_info);
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
protocol->store(operator_name, system_charset_info);
|
|
|
|
protocol->store(&error_clex_str, system_charset_info);
|
|
|
|
protocol->store(errmsg, strlen(errmsg), system_charset_info);
|
2010-08-16 14:53:30 +02:00
|
|
|
thd->clear_error();
|
|
|
|
if (protocol->write())
|
|
|
|
return -1;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int prepare_for_repair(THD *thd, TABLE_LIST *table_list,
|
|
|
|
HA_CHECK_OPT *check_opt)
|
|
|
|
{
|
2020-10-30 15:33:18 +02:00
|
|
|
int error= 0, create_error= 0;
|
2010-08-16 14:53:30 +02:00
|
|
|
TABLE tmp_table, *table;
|
2012-05-17 01:47:28 +03:00
|
|
|
TABLE_LIST *pos_in_locked_tables= 0;
|
2020-10-30 15:33:18 +02:00
|
|
|
TABLE_SHARE *share= 0;
|
2010-08-16 14:53:30 +02:00
|
|
|
bool has_mdl_lock= FALSE;
|
|
|
|
char from[FN_REFLEN],tmp[FN_REFLEN+32];
|
|
|
|
const char **ext;
|
|
|
|
MY_STAT stat_info;
|
|
|
|
Open_table_context ot_ctx(thd, (MYSQL_OPEN_IGNORE_FLUSH |
|
|
|
|
MYSQL_OPEN_HAS_MDL_LOCK |
|
|
|
|
MYSQL_LOCK_IGNORE_TIMEOUT));
|
|
|
|
DBUG_ENTER("prepare_for_repair");
|
|
|
|
|
|
|
|
if (!(check_opt->sql_flags & TT_USEFRM))
|
|
|
|
DBUG_RETURN(0);
|
|
|
|
|
|
|
|
if (!(table= table_list->table))
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
If the table didn't exist, we have a shared metadata lock
|
|
|
|
on it that is left from mysql_admin_table()'s attempt to
|
|
|
|
open it. Release the shared metadata lock before trying to
|
|
|
|
acquire the exclusive lock to satisfy MDL asserts and avoid
|
|
|
|
deadlocks.
|
|
|
|
*/
|
2020-11-30 15:29:32 +02:00
|
|
|
thd->release_transactional_locks();
|
2010-08-16 14:53:30 +02:00
|
|
|
/*
|
|
|
|
Attempt to do full-blown table open in mysql_admin_table() has failed.
|
|
|
|
Let us try to open at least a .FRM for this table.
|
|
|
|
*/
|
|
|
|
|
2020-02-14 16:28:05 +01:00
|
|
|
MDL_REQUEST_INIT(&table_list->mdl_request, MDL_key::TABLE,
|
|
|
|
table_list->db.str, table_list->table_name.str,
|
|
|
|
MDL_EXCLUSIVE, MDL_TRANSACTION);
|
2010-08-16 14:53:30 +02:00
|
|
|
|
|
|
|
if (lock_table_names(thd, table_list, table_list->next_global,
|
2013-06-27 17:42:18 +03:00
|
|
|
thd->variables.lock_wait_timeout, 0))
|
2010-08-16 14:53:30 +02:00
|
|
|
DBUG_RETURN(0);
|
|
|
|
has_mdl_lock= TRUE;
|
|
|
|
|
2015-12-29 14:58:17 +04:00
|
|
|
share= tdc_acquire_share(thd, table_list, GTS_TABLE);
|
2010-08-18 13:29:04 +02:00
|
|
|
if (share == NULL)
|
2010-08-16 14:53:30 +02:00
|
|
|
DBUG_RETURN(0); // Can't open frm file
|
|
|
|
|
2018-01-07 18:03:44 +02:00
|
|
|
if (open_table_from_share(thd, share, &empty_clex_str, 0, 0, 0,
|
|
|
|
&tmp_table, FALSE))
|
2010-08-16 14:53:30 +02:00
|
|
|
{
|
2013-08-14 12:48:50 +04:00
|
|
|
tdc_release_share(share);
|
2010-08-16 14:53:30 +02:00
|
|
|
DBUG_RETURN(0); // Out of memory
|
|
|
|
}
|
|
|
|
table= &tmp_table;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
REPAIR TABLE ... USE_FRM for temporary tables makes little sense.
|
|
|
|
*/
|
|
|
|
if (table->s->tmp_table)
|
|
|
|
{
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
error= send_check_errmsg(thd, table_list, &msg_repair,
|
2010-08-16 14:53:30 +02:00
|
|
|
"Cannot repair temporary table from .frm file");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
User gave us USE_FRM which means that the header in the index file is
|
|
|
|
trashed.
|
|
|
|
In this case we will try to fix the table the following way:
|
|
|
|
- Rename the data file to a temporary name
|
|
|
|
- Truncate the table
|
|
|
|
- Replace the new data file with the old one
|
|
|
|
- Run a normal repair using the new index file and the old data file
|
|
|
|
*/
|
|
|
|
|
2016-06-25 20:55:43 +02:00
|
|
|
if (table->s->frm_version < FRM_VER_TRUE_VARCHAR &&
|
2014-01-22 15:16:57 +02:00
|
|
|
table->s->varchar_fields)
|
2010-08-16 14:53:30 +02:00
|
|
|
{
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
error= send_check_errmsg(thd, table_list, &msg_repair,
|
|
|
|
"Failed repairing a very old .frm file as the "
|
|
|
|
"data file format has changed between versions. "
|
|
|
|
"Please dump the table in your old system with "
|
|
|
|
"mysqldump and read it into this system with "
|
|
|
|
"mysql or mysqlimport");
|
2010-08-16 14:53:30 +02:00
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Check if this is a table type that stores index and data separately,
|
|
|
|
like ISAM or MyISAM. We assume fixed order of engine file name
|
2018-12-21 17:06:08 -03:00
|
|
|
extensions array. First element of engine file name extensions array
|
2010-08-16 14:53:30 +02:00
|
|
|
is meta/index file extention. Second element - data file extention.
|
|
|
|
*/
|
|
|
|
ext= table->file->bas_ext();
|
|
|
|
if (!ext[0] || !ext[1])
|
|
|
|
goto end; // No data file
|
|
|
|
|
Bug #56494 Segfault in upgrade_shared_lock_to_exclusive() for
REPAIR of merge table
Bug #56422 CHECK TABLE run when the table is locked reports
corruption along with timeout
The crash happened if a table maintenance statement (ANALYZE TABLE,
REPAIR TABLE, etc.) was executed on a MERGE table and opening and
locking a child table failed. This could for example happen if a child
table did not exist or if a lock timeout happened while waiting for
a conflicting metadata lock to disappear.
Since opening and locking the MERGE table and its children failed,
the tables would be closed and the metadata locks released.
However, TABLE_LIST::table for the MERGE table would still be set,
with its value invalid since the tables had been closed.
This caused the table maintenance statement to try to continue
and upgrade the metadata lock on the MERGE table. But since the lock
already had been released, this caused a segfault.
This patch fixes the problem by setting TABLE_LIST::table to NULL
if open_and_lock_tables() fails. This prevents maintenance
statements from continuing and trying to upgrade the metadata lock.
The patch includes a 5.5 version of the fix for
Bug #46339 crash on REPAIR TABLE merge table USE_FRM.
This bug caused REPAIR TABLE ... USE_FRM to give an assert
when used on merge tables.
The patch also enables the CHECK TABLE statement for log tables.
Before, CHECK TABLE for log tables gave ER_CANT_LOCK_LOG_TABLE,
yet still counted the statement as successfully executed.
With the changes to table maintenance statement error handling
in this patch, CHECK TABLE would no longer be considered as
successful in this case. This would have caused upgrade scripts
to mistakenly think that the general and slow logs are corrupted
and have to be repaired. Enabling CHECK TABLES for log tables
prevents this from happening.
Finally, the patch changes the error message from "Corrupt" to
"Operation failed" for a number of issues not related to table
corruption. For example "Lock wait timeout exceeded" and
"Deadlock found trying to get lock".
Test cases added to merge.test and check.test.
2010-09-22 10:15:41 +02:00
|
|
|
/* A MERGE table must not come here. */
|
|
|
|
DBUG_ASSERT(table->file->ht->db_type != DB_TYPE_MRG_MYISAM);
|
|
|
|
|
2010-08-16 14:53:30 +02:00
|
|
|
// Name of data file
|
|
|
|
strxmov(from, table->s->normalized_path.str, ext[1], NullS);
|
|
|
|
if (!mysql_file_stat(key_file_misc, from, &stat_info, MYF(0)))
|
|
|
|
goto end; // Can't use USE_FRM flag
|
|
|
|
|
2017-04-23 19:39:57 +03:00
|
|
|
my_snprintf(tmp, sizeof(tmp), "%s-%lx_%llx",
|
2010-08-16 14:53:30 +02:00
|
|
|
from, current_pid, thd->thread_id);
|
|
|
|
|
|
|
|
if (table_list->table)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
Table was successfully open in mysql_admin_table(). Now we need
|
|
|
|
to close it, but leave it protected by exclusive metadata lock.
|
|
|
|
*/
|
2012-05-17 01:47:28 +03:00
|
|
|
pos_in_locked_tables= table->pos_in_locked_tables;
|
2013-08-12 15:46:35 +02:00
|
|
|
if (wait_while_table_is_used(thd, table, HA_EXTRA_PREPARE_FOR_FORCED_CLOSE))
|
2010-08-16 14:53:30 +02:00
|
|
|
goto end;
|
2012-05-17 01:47:28 +03:00
|
|
|
/* Close table but don't remove from locked list */
|
|
|
|
close_all_tables_for_name(thd, table_list->table->s,
|
2013-06-15 18:32:08 +03:00
|
|
|
HA_EXTRA_NOT_USED, NULL);
|
2010-08-16 14:53:30 +02:00
|
|
|
table_list->table= 0;
|
|
|
|
}
|
2020-10-30 15:33:18 +02:00
|
|
|
else
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
Table open failed, maybe because we run out of memory.
|
|
|
|
Close all open tables and relaese all MDL locks
|
|
|
|
*/
|
|
|
|
tdc_release_share(share);
|
|
|
|
share->tdc->flush(thd, true);
|
|
|
|
share= 0;
|
|
|
|
}
|
|
|
|
|
2010-08-16 14:53:30 +02:00
|
|
|
/*
|
|
|
|
After this point we have an exclusive metadata lock on our table
|
|
|
|
in both cases when table was successfully open in mysql_admin_table()
|
|
|
|
and when it was open in prepare_for_repair().
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (my_rename(from, tmp, MYF(MY_WME)))
|
|
|
|
{
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
error= send_check_errmsg(thd, table_list, &msg_repair,
|
2010-08-16 14:53:30 +02:00
|
|
|
"Failed renaming data file");
|
|
|
|
goto end;
|
|
|
|
}
|
2018-01-07 18:03:44 +02:00
|
|
|
if (dd_recreate_table(thd, table_list->db.str, table_list->table_name.str))
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
create_error= send_check_errmsg(thd, table_list, &msg_repair,
|
2020-10-30 15:33:18 +02:00
|
|
|
"Failed generating table from .frm file");
|
2010-08-16 14:53:30 +02:00
|
|
|
/*
|
|
|
|
'FALSE' for 'using_transactions' means don't postpone
|
|
|
|
invalidation till the end of a transaction, but do it
|
|
|
|
immediately.
|
|
|
|
*/
|
|
|
|
query_cache_invalidate3(thd, table_list, FALSE);
|
|
|
|
if (mysql_file_rename(key_file_misc, tmp, from, MYF(MY_WME)))
|
|
|
|
{
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
error= send_check_errmsg(thd, table_list, &msg_repair,
|
2010-08-16 14:53:30 +02:00
|
|
|
"Failed restoring .MYD file");
|
|
|
|
goto end;
|
|
|
|
}
|
2020-10-30 15:33:18 +02:00
|
|
|
if (create_error)
|
|
|
|
goto end;
|
2010-08-16 14:53:30 +02:00
|
|
|
|
2012-05-17 01:47:28 +03:00
|
|
|
if (thd->locked_tables_list.locked_tables())
|
2010-08-16 14:53:30 +02:00
|
|
|
{
|
2018-04-20 10:10:33 +02:00
|
|
|
if (thd->locked_tables_list.reopen_tables(thd, false))
|
2012-05-17 01:47:28 +03:00
|
|
|
goto end;
|
|
|
|
/* Restore the table in the table list with the new opened table */
|
|
|
|
table_list->table= pos_in_locked_tables->table;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
Now we should be able to open the partially repaired table
|
|
|
|
to finish the repair in the handler later on.
|
|
|
|
*/
|
2015-03-10 10:24:20 +01:00
|
|
|
if (open_table(thd, table_list, &ot_ctx))
|
2012-05-17 01:47:28 +03:00
|
|
|
{
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
error= send_check_errmsg(thd, table_list, &msg_repair,
|
2012-05-17 01:47:28 +03:00
|
|
|
"Failed to open partially repaired table");
|
|
|
|
goto end;
|
|
|
|
}
|
2010-08-16 14:53:30 +02:00
|
|
|
}
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
/*
|
|
|
|
We have now fixed the table. However the frm file is still of old format.
|
|
|
|
We cannot update the frm_file to FRM_VER_TRUE_VARCHAR as the new format
|
|
|
|
are not compatible with the data.
|
|
|
|
*/
|
2010-08-16 14:53:30 +02:00
|
|
|
|
|
|
|
end:
|
|
|
|
thd->locked_tables_list.unlink_all_closed_tables(thd, NULL, 0);
|
|
|
|
if (table == &tmp_table)
|
2016-06-10 17:37:12 +04:00
|
|
|
{
|
|
|
|
closefrm(table);
|
2020-10-30 15:33:18 +02:00
|
|
|
if (share)
|
|
|
|
tdc_release_share(share);
|
2016-06-10 17:37:12 +04:00
|
|
|
}
|
2010-08-16 14:53:30 +02:00
|
|
|
/* In case of a temporary table there will be no metadata lock. */
|
2018-04-04 12:16:12 +03:00
|
|
|
if (unlikely(error) && has_mdl_lock)
|
2020-11-30 15:29:32 +02:00
|
|
|
thd->release_transactional_locks();
|
2010-08-16 14:53:30 +02:00
|
|
|
|
|
|
|
DBUG_RETURN(error);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
Bug #56494 Segfault in upgrade_shared_lock_to_exclusive() for
REPAIR of merge table
Bug #56422 CHECK TABLE run when the table is locked reports
corruption along with timeout
The crash happened if a table maintenance statement (ANALYZE TABLE,
REPAIR TABLE, etc.) was executed on a MERGE table and opening and
locking a child table failed. This could for example happen if a child
table did not exist or if a lock timeout happened while waiting for
a conflicting metadata lock to disappear.
Since opening and locking the MERGE table and its children failed,
the tables would be closed and the metadata locks released.
However, TABLE_LIST::table for the MERGE table would still be set,
with its value invalid since the tables had been closed.
This caused the table maintenance statement to try to continue
and upgrade the metadata lock on the MERGE table. But since the lock
already had been released, this caused a segfault.
This patch fixes the problem by setting TABLE_LIST::table to NULL
if open_and_lock_tables() fails. This prevents maintenance
statements from continuing and trying to upgrade the metadata lock.
The patch includes a 5.5 version of the fix for
Bug #46339 crash on REPAIR TABLE merge table USE_FRM.
This bug caused REPAIR TABLE ... USE_FRM to give an assert
when used on merge tables.
The patch also enables the CHECK TABLE statement for log tables.
Before, CHECK TABLE for log tables gave ER_CANT_LOCK_LOG_TABLE,
yet still counted the statement as successfully executed.
With the changes to table maintenance statement error handling
in this patch, CHECK TABLE would no longer be considered as
successful in this case. This would have caused upgrade scripts
to mistakenly think that the general and slow logs are corrupted
and have to be repaired. Enabling CHECK TABLES for log tables
prevents this from happening.
Finally, the patch changes the error message from "Corrupt" to
"Operation failed" for a number of issues not related to table
corruption. For example "Lock wait timeout exceeded" and
"Deadlock found trying to get lock".
Test cases added to merge.test and check.test.
2010-09-22 10:15:41 +02:00
|
|
|
/**
|
|
|
|
Check if a given error is something that could occur during
|
|
|
|
open_and_lock_tables() that does not indicate table corruption.
|
|
|
|
|
|
|
|
@param sql_errno Error number to check.
|
|
|
|
|
|
|
|
@retval TRUE Error does not indicate table corruption.
|
|
|
|
@retval FALSE Error could indicate table corruption.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static inline bool table_not_corrupt_error(uint sql_errno)
|
|
|
|
{
|
|
|
|
return (sql_errno == ER_NO_SUCH_TABLE ||
|
2012-08-28 19:39:49 +03:00
|
|
|
sql_errno == ER_NO_SUCH_TABLE_IN_ENGINE ||
|
Bug #56494 Segfault in upgrade_shared_lock_to_exclusive() for
REPAIR of merge table
Bug #56422 CHECK TABLE run when the table is locked reports
corruption along with timeout
The crash happened if a table maintenance statement (ANALYZE TABLE,
REPAIR TABLE, etc.) was executed on a MERGE table and opening and
locking a child table failed. This could for example happen if a child
table did not exist or if a lock timeout happened while waiting for
a conflicting metadata lock to disappear.
Since opening and locking the MERGE table and its children failed,
the tables would be closed and the metadata locks released.
However, TABLE_LIST::table for the MERGE table would still be set,
with its value invalid since the tables had been closed.
This caused the table maintenance statement to try to continue
and upgrade the metadata lock on the MERGE table. But since the lock
already had been released, this caused a segfault.
This patch fixes the problem by setting TABLE_LIST::table to NULL
if open_and_lock_tables() fails. This prevents maintenance
statements from continuing and trying to upgrade the metadata lock.
The patch includes a 5.5 version of the fix for
Bug #46339 crash on REPAIR TABLE merge table USE_FRM.
This bug caused REPAIR TABLE ... USE_FRM to give an assert
when used on merge tables.
The patch also enables the CHECK TABLE statement for log tables.
Before, CHECK TABLE for log tables gave ER_CANT_LOCK_LOG_TABLE,
yet still counted the statement as successfully executed.
With the changes to table maintenance statement error handling
in this patch, CHECK TABLE would no longer be considered as
successful in this case. This would have caused upgrade scripts
to mistakenly think that the general and slow logs are corrupted
and have to be repaired. Enabling CHECK TABLES for log tables
prevents this from happening.
Finally, the patch changes the error message from "Corrupt" to
"Operation failed" for a number of issues not related to table
corruption. For example "Lock wait timeout exceeded" and
"Deadlock found trying to get lock".
Test cases added to merge.test and check.test.
2010-09-22 10:15:41 +02:00
|
|
|
sql_errno == ER_FILE_NOT_FOUND ||
|
|
|
|
sql_errno == ER_LOCK_WAIT_TIMEOUT ||
|
|
|
|
sql_errno == ER_LOCK_DEADLOCK ||
|
|
|
|
sql_errno == ER_CANT_LOCK_LOG_TABLE ||
|
2015-11-13 17:51:18 +05:30
|
|
|
sql_errno == ER_OPEN_AS_READONLY ||
|
|
|
|
sql_errno == ER_WRONG_OBJECT);
|
Bug #56494 Segfault in upgrade_shared_lock_to_exclusive() for
REPAIR of merge table
Bug #56422 CHECK TABLE run when the table is locked reports
corruption along with timeout
The crash happened if a table maintenance statement (ANALYZE TABLE,
REPAIR TABLE, etc.) was executed on a MERGE table and opening and
locking a child table failed. This could for example happen if a child
table did not exist or if a lock timeout happened while waiting for
a conflicting metadata lock to disappear.
Since opening and locking the MERGE table and its children failed,
the tables would be closed and the metadata locks released.
However, TABLE_LIST::table for the MERGE table would still be set,
with its value invalid since the tables had been closed.
This caused the table maintenance statement to try to continue
and upgrade the metadata lock on the MERGE table. But since the lock
already had been released, this caused a segfault.
This patch fixes the problem by setting TABLE_LIST::table to NULL
if open_and_lock_tables() fails. This prevents maintenance
statements from continuing and trying to upgrade the metadata lock.
The patch includes a 5.5 version of the fix for
Bug #46339 crash on REPAIR TABLE merge table USE_FRM.
This bug caused REPAIR TABLE ... USE_FRM to give an assert
when used on merge tables.
The patch also enables the CHECK TABLE statement for log tables.
Before, CHECK TABLE for log tables gave ER_CANT_LOCK_LOG_TABLE,
yet still counted the statement as successfully executed.
With the changes to table maintenance statement error handling
in this patch, CHECK TABLE would no longer be considered as
successful in this case. This would have caused upgrade scripts
to mistakenly think that the general and slow logs are corrupted
and have to be repaired. Enabling CHECK TABLES for log tables
prevents this from happening.
Finally, the patch changes the error message from "Corrupt" to
"Operation failed" for a number of issues not related to table
corruption. For example "Lock wait timeout exceeded" and
"Deadlock found trying to get lock".
Test cases added to merge.test and check.test.
2010-09-22 10:15:41 +02:00
|
|
|
}
|
|
|
|
|
2017-03-08 19:05:44 +01:00
|
|
|
#ifndef DBUG_OFF
|
|
|
|
// It is counter for debugging fail on second call of open_only_one_table
|
|
|
|
static int debug_fail_counter= 0;
|
|
|
|
#endif
|
2010-08-16 14:53:30 +02:00
|
|
|
|
2016-08-01 19:24:55 +02:00
|
|
|
static bool open_only_one_table(THD* thd, TABLE_LIST* table,
|
|
|
|
bool repair_table_use_frm,
|
|
|
|
bool is_view_operator_func)
|
|
|
|
{
|
|
|
|
LEX *lex= thd->lex;
|
2018-05-22 19:08:39 +02:00
|
|
|
SELECT_LEX *select= lex->first_select_lex();
|
2016-08-01 19:24:55 +02:00
|
|
|
TABLE_LIST *save_next_global, *save_next_local;
|
|
|
|
bool open_error;
|
|
|
|
save_next_global= table->next_global;
|
|
|
|
table->next_global= 0;
|
|
|
|
save_next_local= table->next_local;
|
|
|
|
table->next_local= 0;
|
|
|
|
select->table_list.first= table;
|
|
|
|
/*
|
|
|
|
Time zone tables and SP tables can be add to lex->query_tables list,
|
|
|
|
so it have to be prepared.
|
|
|
|
TODO: Investigate if we can put extra tables into argument instead of
|
|
|
|
using lex->query_tables
|
|
|
|
*/
|
|
|
|
lex->query_tables= table;
|
|
|
|
lex->query_tables_last= &table->next_global;
|
|
|
|
lex->query_tables_own_last= 0;
|
|
|
|
|
2017-03-08 19:05:44 +01:00
|
|
|
DBUG_EXECUTE_IF("fail_2call_open_only_one_table", {
|
|
|
|
if (debug_fail_counter)
|
|
|
|
{
|
|
|
|
open_error= TRUE;
|
|
|
|
goto dbug_err;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
debug_fail_counter++;
|
|
|
|
});
|
|
|
|
|
2016-08-01 19:24:55 +02:00
|
|
|
/*
|
|
|
|
CHECK TABLE command is allowed for views as well. Check on alter flags
|
|
|
|
to differentiate from ALTER TABLE...CHECK PARTITION on which view is not
|
|
|
|
allowed.
|
|
|
|
*/
|
2018-02-19 11:23:20 +02:00
|
|
|
if (lex->alter_info.partition_flags & ALTER_PARTITION_ADMIN ||
|
2016-08-01 19:24:55 +02:00
|
|
|
!is_view_operator_func)
|
|
|
|
{
|
MDEV-10139 Support for SEQUENCE objects
Working features:
CREATE OR REPLACE [TEMPORARY] SEQUENCE [IF NOT EXISTS] name
[ INCREMENT [ BY | = ] increment ]
[ MINVALUE [=] minvalue | NO MINVALUE ]
[ MAXVALUE [=] maxvalue | NO MAXVALUE ]
[ START [ WITH | = ] start ] [ CACHE [=] cache ] [ [ NO ] CYCLE ]
ENGINE=xxx COMMENT=".."
SELECT NEXT VALUE FOR sequence_name;
SELECT NEXTVAL(sequence_name);
SELECT PREVIOUS VALUE FOR sequence_name;
SELECT LASTVAL(sequence_name);
SHOW CREATE SEQUENCE sequence_name;
SHOW CREATE TABLE sequence_name;
CREATE TABLE sequence-structure ... SEQUENCE=1
ALTER TABLE sequence RENAME TO sequence2;
RENAME TABLE sequence TO sequence2;
DROP [TEMPORARY] SEQUENCE [IF EXISTS] sequence_names
Missing features
- SETVAL(value,sequence_name), to be used with replication.
- Check replication, including checking that sequence tables are marked
not transactional.
- Check that a commit happens for NEXT VALUE that changes table data (may
already work)
- ALTER SEQUENCE. ANSI SQL version of setval.
- Share identical sequence entries to not add things twice to table list.
- testing insert/delete/update/truncate/load data
- Run and fix Alibaba sequence tests (part of mysql-test/suite/sql_sequence)
- Write documentation for NEXT VALUE / PREVIOUS_VALUE
- NEXTVAL in DEFAULT
- Ensure that NEXTVAL in DEFAULT uses database from base table
- Two NEXTVAL for same row should give same answer.
- Oracle syntax sequence_table.nextval, without any FOR or FROM.
- Sequence tables are treated as 'not read constant tables' by SELECT; Would
be better if we would have a separate list for sequence tables so that
select doesn't know about them, except if refereed to with FROM.
Other things done:
- Improved output for safemalloc backtrack
- frm_type_enum changed to Table_type
- Removed lex->is_view and replaced with lex->table_type. This allows
use to more easy check if item is view, sequence or table.
- Added table flag HA_CAN_TABLES_WITHOUT_ROLLBACK, needed for handlers
that want's to support sequences
- Added handler calls:
- engine_name(), to simplify getting engine name for partition and sequences
- update_first_row(), to be able to do efficient sequence implementations.
- Made binlog_log_row() global to be able to call it from ha_sequence.cc
- Added handler variable: row_already_logged, to be able to flag that the
changed row is already logging to replication log.
- Added CF_DB_CHANGE and CF_SCHEMA_CHANGE flags to simplify
deny_updates_if_read_only_option()
- Added sp_add_cfetch() to avoid new conflicts in sql_yacc.yy
- Moved code for add_table_options() out from sql_show.cc::show_create_table()
- Added String::append_longlong() and used it in sql_show.cc to simplify code.
- Added extra option to dd_frm_type() and ha_table_exists to indicate if
the table is a sequence. Needed by DROP SQUENCE to not drop a table.
2017-03-25 23:36:56 +02:00
|
|
|
table->required_type= TABLE_TYPE_NORMAL;
|
|
|
|
DBUG_ASSERT(lex->table_type != TABLE_TYPE_VIEW);
|
2016-08-01 19:24:55 +02:00
|
|
|
}
|
MDEV-10139 Support for SEQUENCE objects
Working features:
CREATE OR REPLACE [TEMPORARY] SEQUENCE [IF NOT EXISTS] name
[ INCREMENT [ BY | = ] increment ]
[ MINVALUE [=] minvalue | NO MINVALUE ]
[ MAXVALUE [=] maxvalue | NO MAXVALUE ]
[ START [ WITH | = ] start ] [ CACHE [=] cache ] [ [ NO ] CYCLE ]
ENGINE=xxx COMMENT=".."
SELECT NEXT VALUE FOR sequence_name;
SELECT NEXTVAL(sequence_name);
SELECT PREVIOUS VALUE FOR sequence_name;
SELECT LASTVAL(sequence_name);
SHOW CREATE SEQUENCE sequence_name;
SHOW CREATE TABLE sequence_name;
CREATE TABLE sequence-structure ... SEQUENCE=1
ALTER TABLE sequence RENAME TO sequence2;
RENAME TABLE sequence TO sequence2;
DROP [TEMPORARY] SEQUENCE [IF EXISTS] sequence_names
Missing features
- SETVAL(value,sequence_name), to be used with replication.
- Check replication, including checking that sequence tables are marked
not transactional.
- Check that a commit happens for NEXT VALUE that changes table data (may
already work)
- ALTER SEQUENCE. ANSI SQL version of setval.
- Share identical sequence entries to not add things twice to table list.
- testing insert/delete/update/truncate/load data
- Run and fix Alibaba sequence tests (part of mysql-test/suite/sql_sequence)
- Write documentation for NEXT VALUE / PREVIOUS_VALUE
- NEXTVAL in DEFAULT
- Ensure that NEXTVAL in DEFAULT uses database from base table
- Two NEXTVAL for same row should give same answer.
- Oracle syntax sequence_table.nextval, without any FOR or FROM.
- Sequence tables are treated as 'not read constant tables' by SELECT; Would
be better if we would have a separate list for sequence tables so that
select doesn't know about them, except if refereed to with FROM.
Other things done:
- Improved output for safemalloc backtrack
- frm_type_enum changed to Table_type
- Removed lex->is_view and replaced with lex->table_type. This allows
use to more easy check if item is view, sequence or table.
- Added table flag HA_CAN_TABLES_WITHOUT_ROLLBACK, needed for handlers
that want's to support sequences
- Added handler calls:
- engine_name(), to simplify getting engine name for partition and sequences
- update_first_row(), to be able to do efficient sequence implementations.
- Made binlog_log_row() global to be able to call it from ha_sequence.cc
- Added handler variable: row_already_logged, to be able to flag that the
changed row is already logging to replication log.
- Added CF_DB_CHANGE and CF_SCHEMA_CHANGE flags to simplify
deny_updates_if_read_only_option()
- Added sp_add_cfetch() to avoid new conflicts in sql_yacc.yy
- Moved code for add_table_options() out from sql_show.cc::show_create_table()
- Added String::append_longlong() and used it in sql_show.cc to simplify code.
- Added extra option to dd_frm_type() and ha_table_exists to indicate if
the table is a sequence. Needed by DROP SQUENCE to not drop a table.
2017-03-25 23:36:56 +02:00
|
|
|
else if (lex->table_type == TABLE_TYPE_VIEW)
|
2016-08-01 19:24:55 +02:00
|
|
|
{
|
MDEV-10139 Support for SEQUENCE objects
Working features:
CREATE OR REPLACE [TEMPORARY] SEQUENCE [IF NOT EXISTS] name
[ INCREMENT [ BY | = ] increment ]
[ MINVALUE [=] minvalue | NO MINVALUE ]
[ MAXVALUE [=] maxvalue | NO MAXVALUE ]
[ START [ WITH | = ] start ] [ CACHE [=] cache ] [ [ NO ] CYCLE ]
ENGINE=xxx COMMENT=".."
SELECT NEXT VALUE FOR sequence_name;
SELECT NEXTVAL(sequence_name);
SELECT PREVIOUS VALUE FOR sequence_name;
SELECT LASTVAL(sequence_name);
SHOW CREATE SEQUENCE sequence_name;
SHOW CREATE TABLE sequence_name;
CREATE TABLE sequence-structure ... SEQUENCE=1
ALTER TABLE sequence RENAME TO sequence2;
RENAME TABLE sequence TO sequence2;
DROP [TEMPORARY] SEQUENCE [IF EXISTS] sequence_names
Missing features
- SETVAL(value,sequence_name), to be used with replication.
- Check replication, including checking that sequence tables are marked
not transactional.
- Check that a commit happens for NEXT VALUE that changes table data (may
already work)
- ALTER SEQUENCE. ANSI SQL version of setval.
- Share identical sequence entries to not add things twice to table list.
- testing insert/delete/update/truncate/load data
- Run and fix Alibaba sequence tests (part of mysql-test/suite/sql_sequence)
- Write documentation for NEXT VALUE / PREVIOUS_VALUE
- NEXTVAL in DEFAULT
- Ensure that NEXTVAL in DEFAULT uses database from base table
- Two NEXTVAL for same row should give same answer.
- Oracle syntax sequence_table.nextval, without any FOR or FROM.
- Sequence tables are treated as 'not read constant tables' by SELECT; Would
be better if we would have a separate list for sequence tables so that
select doesn't know about them, except if refereed to with FROM.
Other things done:
- Improved output for safemalloc backtrack
- frm_type_enum changed to Table_type
- Removed lex->is_view and replaced with lex->table_type. This allows
use to more easy check if item is view, sequence or table.
- Added table flag HA_CAN_TABLES_WITHOUT_ROLLBACK, needed for handlers
that want's to support sequences
- Added handler calls:
- engine_name(), to simplify getting engine name for partition and sequences
- update_first_row(), to be able to do efficient sequence implementations.
- Made binlog_log_row() global to be able to call it from ha_sequence.cc
- Added handler variable: row_already_logged, to be able to flag that the
changed row is already logging to replication log.
- Added CF_DB_CHANGE and CF_SCHEMA_CHANGE flags to simplify
deny_updates_if_read_only_option()
- Added sp_add_cfetch() to avoid new conflicts in sql_yacc.yy
- Moved code for add_table_options() out from sql_show.cc::show_create_table()
- Added String::append_longlong() and used it in sql_show.cc to simplify code.
- Added extra option to dd_frm_type() and ha_table_exists to indicate if
the table is a sequence. Needed by DROP SQUENCE to not drop a table.
2017-03-25 23:36:56 +02:00
|
|
|
table->required_type= lex->table_type;
|
2016-08-01 19:24:55 +02:00
|
|
|
}
|
MDEV-10139 Support for SEQUENCE objects
Working features:
CREATE OR REPLACE [TEMPORARY] SEQUENCE [IF NOT EXISTS] name
[ INCREMENT [ BY | = ] increment ]
[ MINVALUE [=] minvalue | NO MINVALUE ]
[ MAXVALUE [=] maxvalue | NO MAXVALUE ]
[ START [ WITH | = ] start ] [ CACHE [=] cache ] [ [ NO ] CYCLE ]
ENGINE=xxx COMMENT=".."
SELECT NEXT VALUE FOR sequence_name;
SELECT NEXTVAL(sequence_name);
SELECT PREVIOUS VALUE FOR sequence_name;
SELECT LASTVAL(sequence_name);
SHOW CREATE SEQUENCE sequence_name;
SHOW CREATE TABLE sequence_name;
CREATE TABLE sequence-structure ... SEQUENCE=1
ALTER TABLE sequence RENAME TO sequence2;
RENAME TABLE sequence TO sequence2;
DROP [TEMPORARY] SEQUENCE [IF EXISTS] sequence_names
Missing features
- SETVAL(value,sequence_name), to be used with replication.
- Check replication, including checking that sequence tables are marked
not transactional.
- Check that a commit happens for NEXT VALUE that changes table data (may
already work)
- ALTER SEQUENCE. ANSI SQL version of setval.
- Share identical sequence entries to not add things twice to table list.
- testing insert/delete/update/truncate/load data
- Run and fix Alibaba sequence tests (part of mysql-test/suite/sql_sequence)
- Write documentation for NEXT VALUE / PREVIOUS_VALUE
- NEXTVAL in DEFAULT
- Ensure that NEXTVAL in DEFAULT uses database from base table
- Two NEXTVAL for same row should give same answer.
- Oracle syntax sequence_table.nextval, without any FOR or FROM.
- Sequence tables are treated as 'not read constant tables' by SELECT; Would
be better if we would have a separate list for sequence tables so that
select doesn't know about them, except if refereed to with FROM.
Other things done:
- Improved output for safemalloc backtrack
- frm_type_enum changed to Table_type
- Removed lex->is_view and replaced with lex->table_type. This allows
use to more easy check if item is view, sequence or table.
- Added table flag HA_CAN_TABLES_WITHOUT_ROLLBACK, needed for handlers
that want's to support sequences
- Added handler calls:
- engine_name(), to simplify getting engine name for partition and sequences
- update_first_row(), to be able to do efficient sequence implementations.
- Made binlog_log_row() global to be able to call it from ha_sequence.cc
- Added handler variable: row_already_logged, to be able to flag that the
changed row is already logging to replication log.
- Added CF_DB_CHANGE and CF_SCHEMA_CHANGE flags to simplify
deny_updates_if_read_only_option()
- Added sp_add_cfetch() to avoid new conflicts in sql_yacc.yy
- Moved code for add_table_options() out from sql_show.cc::show_create_table()
- Added String::append_longlong() and used it in sql_show.cc to simplify code.
- Added extra option to dd_frm_type() and ha_table_exists to indicate if
the table is a sequence. Needed by DROP SQUENCE to not drop a table.
2017-03-25 23:36:56 +02:00
|
|
|
else if ((lex->table_type != TABLE_TYPE_VIEW) &&
|
|
|
|
lex->sql_command == SQLCOM_REPAIR)
|
2016-08-01 19:24:55 +02:00
|
|
|
{
|
MDEV-10139 Support for SEQUENCE objects
Working features:
CREATE OR REPLACE [TEMPORARY] SEQUENCE [IF NOT EXISTS] name
[ INCREMENT [ BY | = ] increment ]
[ MINVALUE [=] minvalue | NO MINVALUE ]
[ MAXVALUE [=] maxvalue | NO MAXVALUE ]
[ START [ WITH | = ] start ] [ CACHE [=] cache ] [ [ NO ] CYCLE ]
ENGINE=xxx COMMENT=".."
SELECT NEXT VALUE FOR sequence_name;
SELECT NEXTVAL(sequence_name);
SELECT PREVIOUS VALUE FOR sequence_name;
SELECT LASTVAL(sequence_name);
SHOW CREATE SEQUENCE sequence_name;
SHOW CREATE TABLE sequence_name;
CREATE TABLE sequence-structure ... SEQUENCE=1
ALTER TABLE sequence RENAME TO sequence2;
RENAME TABLE sequence TO sequence2;
DROP [TEMPORARY] SEQUENCE [IF EXISTS] sequence_names
Missing features
- SETVAL(value,sequence_name), to be used with replication.
- Check replication, including checking that sequence tables are marked
not transactional.
- Check that a commit happens for NEXT VALUE that changes table data (may
already work)
- ALTER SEQUENCE. ANSI SQL version of setval.
- Share identical sequence entries to not add things twice to table list.
- testing insert/delete/update/truncate/load data
- Run and fix Alibaba sequence tests (part of mysql-test/suite/sql_sequence)
- Write documentation for NEXT VALUE / PREVIOUS_VALUE
- NEXTVAL in DEFAULT
- Ensure that NEXTVAL in DEFAULT uses database from base table
- Two NEXTVAL for same row should give same answer.
- Oracle syntax sequence_table.nextval, without any FOR or FROM.
- Sequence tables are treated as 'not read constant tables' by SELECT; Would
be better if we would have a separate list for sequence tables so that
select doesn't know about them, except if refereed to with FROM.
Other things done:
- Improved output for safemalloc backtrack
- frm_type_enum changed to Table_type
- Removed lex->is_view and replaced with lex->table_type. This allows
use to more easy check if item is view, sequence or table.
- Added table flag HA_CAN_TABLES_WITHOUT_ROLLBACK, needed for handlers
that want's to support sequences
- Added handler calls:
- engine_name(), to simplify getting engine name for partition and sequences
- update_first_row(), to be able to do efficient sequence implementations.
- Made binlog_log_row() global to be able to call it from ha_sequence.cc
- Added handler variable: row_already_logged, to be able to flag that the
changed row is already logging to replication log.
- Added CF_DB_CHANGE and CF_SCHEMA_CHANGE flags to simplify
deny_updates_if_read_only_option()
- Added sp_add_cfetch() to avoid new conflicts in sql_yacc.yy
- Moved code for add_table_options() out from sql_show.cc::show_create_table()
- Added String::append_longlong() and used it in sql_show.cc to simplify code.
- Added extra option to dd_frm_type() and ha_table_exists to indicate if
the table is a sequence. Needed by DROP SQUENCE to not drop a table.
2017-03-25 23:36:56 +02:00
|
|
|
table->required_type= TABLE_TYPE_NORMAL;
|
2016-08-01 19:24:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (lex->sql_command == SQLCOM_CHECK ||
|
|
|
|
lex->sql_command == SQLCOM_REPAIR ||
|
|
|
|
lex->sql_command == SQLCOM_ANALYZE ||
|
|
|
|
lex->sql_command == SQLCOM_OPTIMIZE)
|
|
|
|
thd->prepare_derived_at_open= TRUE;
|
|
|
|
if (!thd->locked_tables_mode && repair_table_use_frm)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
If we're not under LOCK TABLES and we're executing REPAIR TABLE
|
|
|
|
USE_FRM, we need to ignore errors from open_and_lock_tables().
|
|
|
|
REPAIR TABLE USE_FRM is a heavy weapon used when a table is
|
|
|
|
critically damaged, so open_and_lock_tables() will most likely
|
|
|
|
report errors. Those errors are not interesting for the user
|
|
|
|
because it's already known that the table is badly damaged.
|
|
|
|
*/
|
|
|
|
|
|
|
|
Diagnostics_area *da= thd->get_stmt_da();
|
|
|
|
Warning_info tmp_wi(thd->query_id, false, true);
|
|
|
|
|
|
|
|
da->push_warning_info(&tmp_wi);
|
|
|
|
|
|
|
|
open_error= (thd->open_temporary_tables(table) ||
|
|
|
|
open_and_lock_tables(thd, table, TRUE, 0));
|
|
|
|
|
|
|
|
da->pop_warning_info();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
It's assumed that even if it is REPAIR TABLE USE_FRM, the table
|
|
|
|
can be opened if we're under LOCK TABLES (otherwise LOCK TABLES
|
|
|
|
would fail). Thus, the only errors we could have from
|
|
|
|
open_and_lock_tables() are logical ones, like incorrect locking
|
|
|
|
mode. It does make sense for the user to see such errors.
|
|
|
|
*/
|
|
|
|
|
|
|
|
open_error= (thd->open_temporary_tables(table) ||
|
|
|
|
open_and_lock_tables(thd, table, TRUE, 0));
|
|
|
|
}
|
2017-03-08 19:05:44 +01:00
|
|
|
|
2017-05-07 18:26:10 +03:00
|
|
|
#ifndef DBUG_OFF
|
2017-03-08 19:05:44 +01:00
|
|
|
dbug_err:
|
2017-05-07 18:26:10 +03:00
|
|
|
#endif
|
2017-03-08 19:05:44 +01:00
|
|
|
|
2016-08-01 19:24:55 +02:00
|
|
|
thd->prepare_derived_at_open= FALSE;
|
|
|
|
|
2016-12-29 13:23:18 +01:00
|
|
|
/*
|
|
|
|
MERGE engine may adjust table->next_global chain, thus we have to
|
|
|
|
append save_next_global after merge children.
|
|
|
|
*/
|
|
|
|
if (save_next_global)
|
|
|
|
{
|
|
|
|
TABLE_LIST *table_list_iterator= table;
|
|
|
|
while (table_list_iterator->next_global)
|
|
|
|
table_list_iterator= table_list_iterator->next_global;
|
|
|
|
table_list_iterator->next_global= save_next_global;
|
|
|
|
save_next_global->prev_global= &table_list_iterator->next_global;
|
|
|
|
}
|
|
|
|
|
2016-08-01 19:24:55 +02:00
|
|
|
table->next_local= save_next_local;
|
|
|
|
|
|
|
|
return open_error;
|
|
|
|
}
|
|
|
|
|
2023-08-08 07:43:37 +03:00
|
|
|
#ifdef WITH_WSREP
|
|
|
|
/** RAII class for temporarily disable wsrep_on in the connection. */
|
|
|
|
class Disable_wsrep_on_guard
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
@param thd - pointer to the context of connection in which
|
|
|
|
wsrep_on mode needs to be disabled.
|
|
|
|
@param disable - true if wsrep_on should be disabled
|
|
|
|
*/
|
|
|
|
explicit Disable_wsrep_on_guard(THD *thd, bool disable)
|
|
|
|
: m_thd(thd), m_orig_wsrep_on(thd->variables.wsrep_on)
|
|
|
|
{
|
|
|
|
if (disable)
|
|
|
|
thd->variables.wsrep_on= false;
|
|
|
|
}
|
|
|
|
|
|
|
|
~Disable_wsrep_on_guard()
|
|
|
|
{
|
|
|
|
m_thd->variables.wsrep_on= m_orig_wsrep_on;
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
THD* m_thd;
|
|
|
|
bool m_orig_wsrep_on;
|
|
|
|
};
|
|
|
|
#endif /* WITH_WSREP */
|
2016-08-01 19:24:55 +02:00
|
|
|
|
MDEV-16708: Unsupported commands for prepared statements
Withing this task the following changes were made:
- Added sending of metadata info in prepare phase for the admin related
command (check table, checksum table, repair, optimize, analyze).
- Refactored implmentation of HELP command to support its execution in
PS mode
- Added support for execution of LOAD INTO and XA- related statements
in PS mode
- Modified mysqltest.cc to run statements in PS mode unconditionally
in case the option --ps-protocol is set. Formerly, only those statements
were executed using PS protocol that matched the hard-coded regular expression
- Fixed the following issues:
The statement
explain select (select 2)
executed in regular and PS mode produces different results:
MariaDB [test]> prepare stmt from "explain select (select 2)";
Query OK, 0 rows affected (0,000 sec)
Statement prepared
MariaDB [test]> execute stmt;
+------+-------------+-------+------+---------------+------+---------+------+------+----------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+------+-------------+-------+------+---------------+------+---------+------+------+----------------+
| 1 | PRIMARY | NULL | NULL | NULL | NULL | NULL | NULL | NULL | No tables used |
| 2 | SUBQUERY | NULL | NULL | NULL | NULL | NULL | NULL | NULL | No tables used |
+------+-------------+-------+------+---------------+------+---------+------+------+----------------+
2 rows in set (0,000 sec)
MariaDB [test]> explain select (select 2);
+------+-------------+-------+------+---------------+------+---------+------+------+----------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+------+-------------+-------+------+---------------+------+---------+------+------+----------------+
| 1 | SIMPLE | NULL | NULL | NULL | NULL | NULL | NULL | NULL | No tables used |
+------+-------------+-------+------+---------------+------+---------+------+------+----------------+
1 row in set, 1 warning (0,000 sec)
In case the statement
CREATE TABLE t1 SELECT * FROM (SELECT 1 AS a, (SELECT a+0)) a
is run in PS mode it fails with the error
ERROR 1054 (42S22): Unknown column 'a' in 'field list'.
- Uniform handling of read-only variables both in case the SET var=val
statement is executed as regular or prepared statememt.
- Fixed assertion firing on handling LOAD DATA statement for temporary tables
- Relaxed assert condition in the function lex_end_stage1() by adding
the commands SQLCOM_ALTER_EVENT, SQLCOM_CREATE_PACKAGE,
SQLCOM_CREATE_PACKAGE_BODY to a list of supported command
- Removed raising of the error ER_UNSUPPORTED_PS in the function
check_prepared_statement() for the ALTER VIEW command
- Added initialization of the data memember st_select_lex_unit::last_procedure
(assign NULL value) in the constructor
Without this change the test case main.ctype_utf8 fails with the following
report in case it is run with the optoin --ps-protocol.
mysqltest: At line 2278: query 'VALUES (_latin1 0xDF) UNION VALUES(_utf8'a' COLLATE utf8_bin)' failed: 2013: Lost connection
- The following bug reports were fixed:
MDEV-24460: Multiple rows result set returned from stored
routine over prepared statement binary protocol is
handled incorrectly
CONC-519: mariadb client library doesn't handle server_status and
warnign_count fields received in the packet
COM_STMT_EXECUTE_RESPONSE.
Reasons for these bug reports have the same nature and caused by
missing loop iteration on results sent by server in response to
COM_STMT_EXECUTE packet.
Enclosing of statements for processing of COM_STMT_EXECUTE response
in the construct like
do
{
...
} while (!mysql_stmt_next_result());
fixes the above mentioned bug reports.
2021-04-22 14:52:19 +07:00
|
|
|
|
2021-08-31 18:02:38 +03:00
|
|
|
static void send_read_only_warning(THD *thd, const LEX_CSTRING *msg_status,
|
|
|
|
const LEX_CSTRING *table_name)
|
|
|
|
{
|
|
|
|
Protocol *protocol= thd->protocol;
|
|
|
|
char buf[MYSQL_ERRMSG_SIZE];
|
|
|
|
size_t length;
|
|
|
|
length= my_snprintf(buf, sizeof(buf),
|
|
|
|
ER_THD(thd, ER_OPEN_AS_READONLY),
|
|
|
|
table_name->str);
|
|
|
|
protocol->store(msg_status, system_charset_info);
|
|
|
|
protocol->store(buf, length, system_charset_info);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
MDEV-16708: Unsupported commands for prepared statements
Withing this task the following changes were made:
- Added sending of metadata info in prepare phase for the admin related
command (check table, checksum table, repair, optimize, analyze).
- Refactored implmentation of HELP command to support its execution in
PS mode
- Added support for execution of LOAD INTO and XA- related statements
in PS mode
- Modified mysqltest.cc to run statements in PS mode unconditionally
in case the option --ps-protocol is set. Formerly, only those statements
were executed using PS protocol that matched the hard-coded regular expression
- Fixed the following issues:
The statement
explain select (select 2)
executed in regular and PS mode produces different results:
MariaDB [test]> prepare stmt from "explain select (select 2)";
Query OK, 0 rows affected (0,000 sec)
Statement prepared
MariaDB [test]> execute stmt;
+------+-------------+-------+------+---------------+------+---------+------+------+----------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+------+-------------+-------+------+---------------+------+---------+------+------+----------------+
| 1 | PRIMARY | NULL | NULL | NULL | NULL | NULL | NULL | NULL | No tables used |
| 2 | SUBQUERY | NULL | NULL | NULL | NULL | NULL | NULL | NULL | No tables used |
+------+-------------+-------+------+---------------+------+---------+------+------+----------------+
2 rows in set (0,000 sec)
MariaDB [test]> explain select (select 2);
+------+-------------+-------+------+---------------+------+---------+------+------+----------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+------+-------------+-------+------+---------------+------+---------+------+------+----------------+
| 1 | SIMPLE | NULL | NULL | NULL | NULL | NULL | NULL | NULL | No tables used |
+------+-------------+-------+------+---------------+------+---------+------+------+----------------+
1 row in set, 1 warning (0,000 sec)
In case the statement
CREATE TABLE t1 SELECT * FROM (SELECT 1 AS a, (SELECT a+0)) a
is run in PS mode it fails with the error
ERROR 1054 (42S22): Unknown column 'a' in 'field list'.
- Uniform handling of read-only variables both in case the SET var=val
statement is executed as regular or prepared statememt.
- Fixed assertion firing on handling LOAD DATA statement for temporary tables
- Relaxed assert condition in the function lex_end_stage1() by adding
the commands SQLCOM_ALTER_EVENT, SQLCOM_CREATE_PACKAGE,
SQLCOM_CREATE_PACKAGE_BODY to a list of supported command
- Removed raising of the error ER_UNSUPPORTED_PS in the function
check_prepared_statement() for the ALTER VIEW command
- Added initialization of the data memember st_select_lex_unit::last_procedure
(assign NULL value) in the constructor
Without this change the test case main.ctype_utf8 fails with the following
report in case it is run with the optoin --ps-protocol.
mysqltest: At line 2278: query 'VALUES (_latin1 0xDF) UNION VALUES(_utf8'a' COLLATE utf8_bin)' failed: 2013: Lost connection
- The following bug reports were fixed:
MDEV-24460: Multiple rows result set returned from stored
routine over prepared statement binary protocol is
handled incorrectly
CONC-519: mariadb client library doesn't handle server_status and
warnign_count fields received in the packet
COM_STMT_EXECUTE_RESPONSE.
Reasons for these bug reports have the same nature and caused by
missing loop iteration on results sent by server in response to
COM_STMT_EXECUTE packet.
Enclosing of statements for processing of COM_STMT_EXECUTE response
in the construct like
do
{
...
} while (!mysql_stmt_next_result());
fixes the above mentioned bug reports.
2021-04-22 14:52:19 +07:00
|
|
|
/**
|
|
|
|
Collect field names of result set that will be sent to a client
|
|
|
|
|
|
|
|
@param thd Thread data object
|
|
|
|
@param[out] fields List of fields whose metadata should be collected for
|
|
|
|
sending to client
|
|
|
|
*/
|
|
|
|
|
|
|
|
void fill_check_table_metadata_fields(THD *thd, List<Item>* fields)
|
|
|
|
{
|
|
|
|
Item *item;
|
|
|
|
|
|
|
|
item= new (thd->mem_root) Item_empty_string(thd, "Table", NAME_CHAR_LEN * 2);
|
|
|
|
item->set_maybe_null();
|
|
|
|
fields->push_back(item, thd->mem_root);
|
|
|
|
|
|
|
|
item= new (thd->mem_root) Item_empty_string(thd, "Op", 10);
|
|
|
|
item->set_maybe_null();
|
|
|
|
fields->push_back(item, thd->mem_root);
|
|
|
|
|
|
|
|
item= new (thd->mem_root) Item_empty_string(thd, "Msg_type", 10);
|
|
|
|
item->set_maybe_null();
|
|
|
|
fields->push_back(item, thd->mem_root);
|
|
|
|
|
|
|
|
item= new (thd->mem_root) Item_empty_string(thd, "Msg_text",
|
|
|
|
SQL_ADMIN_MSG_TEXT_SIZE);
|
|
|
|
item->set_maybe_null();
|
|
|
|
fields->push_back(item, thd->mem_root);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-08-16 14:53:30 +02:00
|
|
|
/*
|
|
|
|
RETURN VALUES
|
|
|
|
FALSE Message sent to net (admin operation went ok)
|
|
|
|
TRUE Message should be sent by caller
|
|
|
|
(admin operation or network communication failed)
|
|
|
|
*/
|
|
|
|
static bool mysql_admin_table(THD* thd, TABLE_LIST* tables,
|
|
|
|
HA_CHECK_OPT* check_opt,
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
const LEX_CSTRING *operator_name,
|
2010-08-16 14:53:30 +02:00
|
|
|
thr_lock_type lock_type,
|
2018-05-20 14:19:14 +03:00
|
|
|
bool org_open_for_modify,
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
bool no_errors_from_open,
|
2010-08-16 14:53:30 +02:00
|
|
|
uint extra_open_options,
|
|
|
|
int (*prepare_func)(THD *, TABLE_LIST *,
|
|
|
|
HA_CHECK_OPT *),
|
|
|
|
int (handler::*operator_func)(THD *,
|
|
|
|
HA_CHECK_OPT *),
|
2015-04-12 20:41:28 +10:00
|
|
|
int (view_operator_func)(THD *, TABLE_LIST*,
|
2021-05-12 18:00:06 +05:30
|
|
|
HA_CHECK_OPT *),
|
|
|
|
bool is_cmd_replicated)
|
2010-08-16 14:53:30 +02:00
|
|
|
{
|
|
|
|
TABLE_LIST *table;
|
|
|
|
List<Item> field_list;
|
|
|
|
Protocol *protocol= thd->protocol;
|
|
|
|
LEX *lex= thd->lex;
|
2010-11-25 18:17:28 +01:00
|
|
|
bool need_repair_or_alter= 0;
|
2015-04-08 11:01:18 +02:00
|
|
|
wait_for_commit* suspended_wfc;
|
2021-05-12 18:03:45 +05:30
|
|
|
bool is_table_modified= false;
|
2021-03-30 17:06:55 +03:00
|
|
|
LEX_CUSTRING tabledef_version;
|
2010-08-16 14:53:30 +02:00
|
|
|
DBUG_ENTER("mysql_admin_table");
|
2011-10-19 21:45:18 +02:00
|
|
|
DBUG_PRINT("enter", ("extra_open_options: %u", extra_open_options));
|
2010-08-16 14:53:30 +02:00
|
|
|
|
2023-08-08 07:43:37 +03:00
|
|
|
#ifdef WITH_WSREP
|
|
|
|
/*
|
|
|
|
CACHE INDEX and LOAD INDEX INTO CACHE statements are
|
|
|
|
local operations. Do not replicate them with Galera
|
|
|
|
*/
|
|
|
|
const bool disable_wsrep_on= (WSREP(thd) &&
|
|
|
|
(lex->sql_command == SQLCOM_ASSIGN_TO_KEYCACHE ||
|
|
|
|
lex->sql_command == SQLCOM_PRELOAD_KEYS));
|
|
|
|
|
|
|
|
Disable_wsrep_on_guard wsrep_on_guard(thd, disable_wsrep_on);
|
|
|
|
#endif /* WITH_WSREP */
|
|
|
|
|
MDEV-16708: Unsupported commands for prepared statements
Withing this task the following changes were made:
- Added sending of metadata info in prepare phase for the admin related
command (check table, checksum table, repair, optimize, analyze).
- Refactored implmentation of HELP command to support its execution in
PS mode
- Added support for execution of LOAD INTO and XA- related statements
in PS mode
- Modified mysqltest.cc to run statements in PS mode unconditionally
in case the option --ps-protocol is set. Formerly, only those statements
were executed using PS protocol that matched the hard-coded regular expression
- Fixed the following issues:
The statement
explain select (select 2)
executed in regular and PS mode produces different results:
MariaDB [test]> prepare stmt from "explain select (select 2)";
Query OK, 0 rows affected (0,000 sec)
Statement prepared
MariaDB [test]> execute stmt;
+------+-------------+-------+------+---------------+------+---------+------+------+----------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+------+-------------+-------+------+---------------+------+---------+------+------+----------------+
| 1 | PRIMARY | NULL | NULL | NULL | NULL | NULL | NULL | NULL | No tables used |
| 2 | SUBQUERY | NULL | NULL | NULL | NULL | NULL | NULL | NULL | No tables used |
+------+-------------+-------+------+---------------+------+---------+------+------+----------------+
2 rows in set (0,000 sec)
MariaDB [test]> explain select (select 2);
+------+-------------+-------+------+---------------+------+---------+------+------+----------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+------+-------------+-------+------+---------------+------+---------+------+------+----------------+
| 1 | SIMPLE | NULL | NULL | NULL | NULL | NULL | NULL | NULL | No tables used |
+------+-------------+-------+------+---------------+------+---------+------+------+----------------+
1 row in set, 1 warning (0,000 sec)
In case the statement
CREATE TABLE t1 SELECT * FROM (SELECT 1 AS a, (SELECT a+0)) a
is run in PS mode it fails with the error
ERROR 1054 (42S22): Unknown column 'a' in 'field list'.
- Uniform handling of read-only variables both in case the SET var=val
statement is executed as regular or prepared statememt.
- Fixed assertion firing on handling LOAD DATA statement for temporary tables
- Relaxed assert condition in the function lex_end_stage1() by adding
the commands SQLCOM_ALTER_EVENT, SQLCOM_CREATE_PACKAGE,
SQLCOM_CREATE_PACKAGE_BODY to a list of supported command
- Removed raising of the error ER_UNSUPPORTED_PS in the function
check_prepared_statement() for the ALTER VIEW command
- Added initialization of the data memember st_select_lex_unit::last_procedure
(assign NULL value) in the constructor
Without this change the test case main.ctype_utf8 fails with the following
report in case it is run with the optoin --ps-protocol.
mysqltest: At line 2278: query 'VALUES (_latin1 0xDF) UNION VALUES(_utf8'a' COLLATE utf8_bin)' failed: 2013: Lost connection
- The following bug reports were fixed:
MDEV-24460: Multiple rows result set returned from stored
routine over prepared statement binary protocol is
handled incorrectly
CONC-519: mariadb client library doesn't handle server_status and
warnign_count fields received in the packet
COM_STMT_EXECUTE_RESPONSE.
Reasons for these bug reports have the same nature and caused by
missing loop iteration on results sent by server in response to
COM_STMT_EXECUTE packet.
Enclosing of statements for processing of COM_STMT_EXECUTE response
in the construct like
do
{
...
} while (!mysql_stmt_next_result());
fixes the above mentioned bug reports.
2021-04-22 14:52:19 +07:00
|
|
|
fill_check_table_metadata_fields(thd, &field_list);
|
|
|
|
|
2010-08-16 14:53:30 +02:00
|
|
|
if (protocol->send_result_set_metadata(&field_list,
|
|
|
|
Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
|
|
|
|
DBUG_RETURN(TRUE);
|
|
|
|
|
2015-04-08 11:01:18 +02:00
|
|
|
/*
|
|
|
|
This function calls trans_commit() during its operation, but that does not
|
|
|
|
imply that the operation is complete or binlogged. So we have to suspend
|
|
|
|
temporarily the wakeup_subsequent_commits() calls (if used).
|
|
|
|
*/
|
|
|
|
suspended_wfc= thd->suspend_subsequent_commits();
|
|
|
|
|
2010-08-16 14:53:30 +02:00
|
|
|
mysql_ha_rm_tables(thd, tables);
|
|
|
|
|
2013-07-09 15:42:36 +04:00
|
|
|
/*
|
|
|
|
Close all temporary tables which were pre-open to simplify
|
|
|
|
privilege checking. Clear all references to closed tables.
|
|
|
|
*/
|
|
|
|
close_thread_tables(thd);
|
|
|
|
for (table= tables; table; table= table->next_local)
|
|
|
|
table->table= NULL;
|
|
|
|
|
2010-08-16 14:53:30 +02:00
|
|
|
for (table= tables; table; table= table->next_local)
|
|
|
|
{
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
char table_name_buff[SAFE_NAME_LEN*2+2];
|
|
|
|
LEX_CSTRING table_name= { table_name_buff, 0};
|
2021-03-30 17:06:55 +03:00
|
|
|
char storage_engine_name[NAME_LEN];
|
|
|
|
bool storage_engine_partitioned= 0;
|
|
|
|
uchar tabledef_version_buff[MY_UUID_SIZE];
|
2018-01-07 18:03:44 +02:00
|
|
|
const char *db= table->db.str;
|
2010-08-16 14:53:30 +02:00
|
|
|
bool fatal_error=0;
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
bool open_error= 0, recreate_used= 0;
|
|
|
|
bool require_data_conversion= 0, require_alter_table= 0;
|
2016-03-17 15:12:57 +01:00
|
|
|
bool collect_eis= FALSE;
|
2018-05-20 14:19:14 +03:00
|
|
|
bool open_for_modify= org_open_for_modify;
|
2022-10-28 13:43:51 +04:00
|
|
|
Recreate_info recreate_info;
|
2023-08-18 18:35:02 +03:00
|
|
|
int compl_result_code, result_code;
|
2010-08-16 14:53:30 +02:00
|
|
|
|
2023-08-18 18:35:02 +03:00
|
|
|
compl_result_code= result_code= HA_ADMIN_FAILED;
|
2021-03-30 17:06:55 +03:00
|
|
|
storage_engine_name[0]= 0; // Marker that's not used
|
|
|
|
|
2018-01-07 18:03:44 +02:00
|
|
|
DBUG_PRINT("admin", ("table: '%s'.'%s'", db, table->table_name.str));
|
2021-05-12 18:03:45 +05:30
|
|
|
DEBUG_SYNC(thd, "admin_command_kill_before_modify");
|
|
|
|
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
table_name.length= strxmov(table_name_buff, db, ".", table->table_name.str,
|
|
|
|
NullS) - table_name_buff;
|
2012-01-13 15:50:02 +01:00
|
|
|
thd->open_options|= extra_open_options;
|
2010-08-16 14:53:30 +02:00
|
|
|
table->lock_type= lock_type;
|
|
|
|
/*
|
|
|
|
To make code safe for re-execution we need to reset type of MDL
|
|
|
|
request as code below may change it.
|
|
|
|
To allow concurrent execution of read-only operations we acquire
|
|
|
|
weak metadata lock for them.
|
|
|
|
*/
|
2016-05-03 20:31:02 +02:00
|
|
|
table->mdl_request.set_type(lex->sql_command == SQLCOM_REPAIR
|
|
|
|
? MDL_SHARED_NO_READ_WRITE
|
2021-03-24 15:41:10 +11:00
|
|
|
: lock_type >= TL_FIRST_WRITE
|
2016-05-03 20:31:02 +02:00
|
|
|
? MDL_SHARED_WRITE : MDL_SHARED_READ);
|
2021-05-19 22:26:02 +02:00
|
|
|
if (thd->check_killed())
|
|
|
|
{
|
2021-06-02 08:25:12 +03:00
|
|
|
open_error= false;
|
2021-05-19 22:26:02 +02:00
|
|
|
fatal_error= true;
|
|
|
|
result_code= HA_ADMIN_FAILED;
|
|
|
|
goto send_result;
|
|
|
|
}
|
|
|
|
|
2010-08-16 14:53:30 +02:00
|
|
|
/* open only one table from local list of command */
|
2016-05-03 20:31:02 +02:00
|
|
|
while (1)
|
2010-08-16 14:53:30 +02:00
|
|
|
{
|
2016-08-01 19:24:55 +02:00
|
|
|
open_error= open_only_one_table(thd, table,
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
no_errors_from_open,
|
2016-08-01 19:24:55 +02:00
|
|
|
(view_operator_func != NULL));
|
2012-01-13 15:50:02 +01:00
|
|
|
thd->open_options&= ~extra_open_options;
|
Bug #56494 Segfault in upgrade_shared_lock_to_exclusive() for
REPAIR of merge table
Bug #56422 CHECK TABLE run when the table is locked reports
corruption along with timeout
The crash happened if a table maintenance statement (ANALYZE TABLE,
REPAIR TABLE, etc.) was executed on a MERGE table and opening and
locking a child table failed. This could for example happen if a child
table did not exist or if a lock timeout happened while waiting for
a conflicting metadata lock to disappear.
Since opening and locking the MERGE table and its children failed,
the tables would be closed and the metadata locks released.
However, TABLE_LIST::table for the MERGE table would still be set,
with its value invalid since the tables had been closed.
This caused the table maintenance statement to try to continue
and upgrade the metadata lock on the MERGE table. But since the lock
already had been released, this caused a segfault.
This patch fixes the problem by setting TABLE_LIST::table to NULL
if open_and_lock_tables() fails. This prevents maintenance
statements from continuing and trying to upgrade the metadata lock.
The patch includes a 5.5 version of the fix for
Bug #46339 crash on REPAIR TABLE merge table USE_FRM.
This bug caused REPAIR TABLE ... USE_FRM to give an assert
when used on merge tables.
The patch also enables the CHECK TABLE statement for log tables.
Before, CHECK TABLE for log tables gave ER_CANT_LOCK_LOG_TABLE,
yet still counted the statement as successfully executed.
With the changes to table maintenance statement error handling
in this patch, CHECK TABLE would no longer be considered as
successful in this case. This would have caused upgrade scripts
to mistakenly think that the general and slow logs are corrupted
and have to be repaired. Enabling CHECK TABLES for log tables
prevents this from happening.
Finally, the patch changes the error message from "Corrupt" to
"Operation failed" for a number of issues not related to table
corruption. For example "Lock wait timeout exceeded" and
"Deadlock found trying to get lock".
Test cases added to merge.test and check.test.
2010-09-22 10:15:41 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
If open_and_lock_tables() failed, close_thread_tables() will close
|
|
|
|
the table and table->table can therefore be invalid.
|
|
|
|
*/
|
2018-04-04 12:16:12 +03:00
|
|
|
if (unlikely(open_error))
|
Bug #56494 Segfault in upgrade_shared_lock_to_exclusive() for
REPAIR of merge table
Bug #56422 CHECK TABLE run when the table is locked reports
corruption along with timeout
The crash happened if a table maintenance statement (ANALYZE TABLE,
REPAIR TABLE, etc.) was executed on a MERGE table and opening and
locking a child table failed. This could for example happen if a child
table did not exist or if a lock timeout happened while waiting for
a conflicting metadata lock to disappear.
Since opening and locking the MERGE table and its children failed,
the tables would be closed and the metadata locks released.
However, TABLE_LIST::table for the MERGE table would still be set,
with its value invalid since the tables had been closed.
This caused the table maintenance statement to try to continue
and upgrade the metadata lock on the MERGE table. But since the lock
already had been released, this caused a segfault.
This patch fixes the problem by setting TABLE_LIST::table to NULL
if open_and_lock_tables() fails. This prevents maintenance
statements from continuing and trying to upgrade the metadata lock.
The patch includes a 5.5 version of the fix for
Bug #46339 crash on REPAIR TABLE merge table USE_FRM.
This bug caused REPAIR TABLE ... USE_FRM to give an assert
when used on merge tables.
The patch also enables the CHECK TABLE statement for log tables.
Before, CHECK TABLE for log tables gave ER_CANT_LOCK_LOG_TABLE,
yet still counted the statement as successfully executed.
With the changes to table maintenance statement error handling
in this patch, CHECK TABLE would no longer be considered as
successful in this case. This would have caused upgrade scripts
to mistakenly think that the general and slow logs are corrupted
and have to be repaired. Enabling CHECK TABLES for log tables
prevents this from happening.
Finally, the patch changes the error message from "Corrupt" to
"Operation failed" for a number of issues not related to table
corruption. For example "Lock wait timeout exceeded" and
"Deadlock found trying to get lock".
Test cases added to merge.test and check.test.
2010-09-22 10:15:41 +02:00
|
|
|
table->table= NULL;
|
|
|
|
|
2010-08-16 14:53:30 +02:00
|
|
|
/*
|
|
|
|
Under locked tables, we know that the table can be opened,
|
|
|
|
so any errors opening the table are logical errors.
|
|
|
|
In these cases it does not make sense to try to repair.
|
|
|
|
*/
|
2018-04-04 12:16:12 +03:00
|
|
|
if (unlikely(open_error) && thd->locked_tables_mode)
|
2010-08-16 14:53:30 +02:00
|
|
|
{
|
|
|
|
result_code= HA_ADMIN_FAILED;
|
|
|
|
goto send_result;
|
|
|
|
}
|
2016-05-03 20:31:02 +02:00
|
|
|
|
|
|
|
if (!table->table || table->mdl_request.type != MDL_SHARED_WRITE ||
|
|
|
|
table->table->file->ha_table_flags() & HA_CONCURRENT_OPTIMIZE)
|
|
|
|
break;
|
|
|
|
|
|
|
|
trans_rollback_stmt(thd);
|
|
|
|
trans_rollback(thd);
|
|
|
|
close_thread_tables(thd);
|
|
|
|
table->table= NULL;
|
2020-11-30 15:29:32 +02:00
|
|
|
thd->release_transactional_locks();
|
2020-02-14 16:28:05 +01:00
|
|
|
MDL_REQUEST_INIT(&table->mdl_request, MDL_key::TABLE, table->db.str,
|
|
|
|
table->table_name.str, MDL_SHARED_NO_READ_WRITE,
|
|
|
|
MDL_TRANSACTION);
|
2016-05-03 20:31:02 +02:00
|
|
|
}
|
|
|
|
|
2010-08-16 14:53:30 +02:00
|
|
|
#ifdef WITH_PARTITION_STORAGE_ENGINE
|
|
|
|
if (table->table)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
Set up which partitions that should be processed
|
|
|
|
if ALTER TABLE t ANALYZE/CHECK/OPTIMIZE/REPAIR PARTITION ..
|
|
|
|
CACHE INDEX/LOAD INDEX for specified partitions
|
|
|
|
*/
|
|
|
|
Alter_info *alter_info= &lex->alter_info;
|
|
|
|
|
2018-02-19 11:23:20 +02:00
|
|
|
if (alter_info->partition_flags & ALTER_PARTITION_ADMIN)
|
2010-08-16 14:53:30 +02:00
|
|
|
{
|
|
|
|
if (!table->table->part_info)
|
|
|
|
{
|
|
|
|
my_error(ER_PARTITION_MGMT_ON_NONPARTITIONED, MYF(0));
|
2019-03-16 19:24:49 +01:00
|
|
|
thd->resume_subsequent_commits(suspended_wfc);
|
|
|
|
DBUG_RETURN(TRUE);
|
2010-08-16 14:53:30 +02:00
|
|
|
}
|
2012-02-02 12:47:17 +01:00
|
|
|
if (set_part_state(alter_info, table->table->part_info, PART_ADMIN))
|
2010-08-16 14:53:30 +02:00
|
|
|
{
|
|
|
|
char buff[FN_REFLEN + MYSQL_ERRMSG_SIZE];
|
|
|
|
size_t length;
|
|
|
|
DBUG_PRINT("admin", ("sending non existent partition error"));
|
|
|
|
protocol->prepare_for_resend();
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
protocol->store(&table_name, system_charset_info);
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->store(operator_name, system_charset_info);
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
protocol->store(&error_clex_str, system_charset_info);
|
2010-08-16 14:53:30 +02:00
|
|
|
length= my_snprintf(buff, sizeof(buff),
|
2021-09-09 11:58:45 +03:00
|
|
|
ER_THD(thd, ER_PARTITION_DOES_NOT_EXIST));
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->store(buff, length, system_charset_info);
|
|
|
|
if(protocol->write())
|
|
|
|
goto err;
|
|
|
|
my_eof(thd);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2017-09-19 17:45:17 +00:00
|
|
|
DBUG_PRINT("admin", ("table: %p", table->table));
|
2010-08-16 14:53:30 +02:00
|
|
|
|
2020-10-30 15:33:18 +02:00
|
|
|
if (table->schema_table)
|
|
|
|
{
|
|
|
|
result_code= HA_ADMIN_NOT_IMPLEMENTED;
|
|
|
|
goto send_result;
|
|
|
|
}
|
|
|
|
|
2010-08-16 14:53:30 +02:00
|
|
|
if (prepare_func)
|
|
|
|
{
|
|
|
|
DBUG_PRINT("admin", ("calling prepare_func"));
|
|
|
|
switch ((*prepare_func)(thd, table, check_opt)) {
|
|
|
|
case 1: // error, message written to net
|
|
|
|
trans_rollback_stmt(thd);
|
|
|
|
trans_rollback(thd);
|
|
|
|
close_thread_tables(thd);
|
2020-11-30 15:29:32 +02:00
|
|
|
thd->release_transactional_locks();
|
2010-08-16 14:53:30 +02:00
|
|
|
DBUG_PRINT("admin", ("simple error, admin next table"));
|
|
|
|
continue;
|
|
|
|
case -1: // error, message could be written to net
|
|
|
|
/* purecov: begin inspected */
|
|
|
|
DBUG_PRINT("admin", ("severe error, stop"));
|
|
|
|
goto err;
|
|
|
|
/* purecov: end */
|
|
|
|
default: // should be 0 otherwise
|
|
|
|
DBUG_PRINT("admin", ("prepare_func succeeded"));
|
|
|
|
;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2015-04-12 20:41:28 +10:00
|
|
|
CHECK/REPAIR TABLE command is only command where VIEW allowed here and
|
|
|
|
this command use only temporary table method for VIEWs resolving =>
|
|
|
|
there can't be VIEW tree substitition of join view => if opening table
|
2010-08-16 14:53:30 +02:00
|
|
|
succeed then table->table will have real TABLE pointer as value (in
|
|
|
|
case of join view substitution table->table can be 0, but here it is
|
|
|
|
impossible)
|
|
|
|
*/
|
|
|
|
if (!table->table)
|
|
|
|
{
|
|
|
|
DBUG_PRINT("admin", ("open table failed"));
|
2013-06-15 18:32:08 +03:00
|
|
|
if (thd->get_stmt_da()->is_warning_info_empty())
|
|
|
|
push_warning(thd, Sql_condition::WARN_LEVEL_WARN,
|
2015-07-06 20:24:14 +03:00
|
|
|
ER_CHECK_NO_SUCH_TABLE,
|
|
|
|
ER_THD(thd, ER_CHECK_NO_SUCH_TABLE));
|
2010-08-16 14:53:30 +02:00
|
|
|
/* if it was a view will check md5 sum */
|
|
|
|
if (table->view &&
|
2015-04-12 20:41:28 +10:00
|
|
|
view_check(thd, table, check_opt) == HA_ADMIN_WRONG_CHECKSUM)
|
2013-06-15 18:32:08 +03:00
|
|
|
push_warning(thd, Sql_condition::WARN_LEVEL_WARN,
|
2015-07-06 20:24:14 +03:00
|
|
|
ER_VIEW_CHECKSUM, ER_THD(thd, ER_VIEW_CHECKSUM));
|
2013-06-15 18:32:08 +03:00
|
|
|
if (thd->get_stmt_da()->is_error() &&
|
|
|
|
table_not_corrupt_error(thd->get_stmt_da()->sql_errno()))
|
2010-08-16 14:53:30 +02:00
|
|
|
result_code= HA_ADMIN_FAILED;
|
|
|
|
else
|
|
|
|
/* Default failure code is corrupt table */
|
|
|
|
result_code= HA_ADMIN_CORRUPT;
|
|
|
|
goto send_result;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (table->view)
|
|
|
|
{
|
|
|
|
DBUG_PRINT("admin", ("calling view_operator_func"));
|
2015-04-12 20:41:28 +10:00
|
|
|
result_code= (*view_operator_func)(thd, table, check_opt);
|
2010-08-16 14:53:30 +02:00
|
|
|
goto send_result;
|
|
|
|
}
|
|
|
|
|
2021-08-31 18:02:38 +03:00
|
|
|
if ((table->table->db_stat & HA_READ_ONLY) && open_for_modify &&
|
|
|
|
operator_func != &handler::ha_analyze)
|
2010-08-16 14:53:30 +02:00
|
|
|
{
|
|
|
|
/* purecov: begin inspected */
|
|
|
|
enum_sql_command save_sql_command= lex->sql_command;
|
|
|
|
DBUG_PRINT("admin", ("sending error message"));
|
|
|
|
protocol->prepare_for_resend();
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
protocol->store(&table_name, system_charset_info);
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->store(operator_name, system_charset_info);
|
2021-08-31 18:02:38 +03:00
|
|
|
send_read_only_warning(thd, &error_clex_str, &table_name);
|
2010-08-16 14:53:30 +02:00
|
|
|
trans_commit_stmt(thd);
|
|
|
|
trans_commit(thd);
|
|
|
|
close_thread_tables(thd);
|
2020-11-30 15:29:32 +02:00
|
|
|
thd->release_transactional_locks();
|
2010-08-16 14:53:30 +02:00
|
|
|
lex->reset_query_tables_list(FALSE);
|
|
|
|
/*
|
|
|
|
Restore Query_tables_list::sql_command value to make statement
|
|
|
|
safe for re-execution.
|
|
|
|
*/
|
|
|
|
lex->sql_command= save_sql_command;
|
|
|
|
table->table=0; // For query cache
|
|
|
|
if (protocol->write())
|
|
|
|
goto err;
|
2013-06-15 18:32:08 +03:00
|
|
|
thd->get_stmt_da()->reset_diagnostics_area();
|
2010-08-16 14:53:30 +02:00
|
|
|
continue;
|
|
|
|
/* purecov: end */
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Close all instances of the table to allow MyISAM "repair"
|
2016-05-03 13:07:05 +02:00
|
|
|
(which is internally also used from "optimize") to rename files.
|
2010-08-16 14:53:30 +02:00
|
|
|
@todo: This code does not close all instances of the table.
|
|
|
|
It only closes instances in other connections, but if this
|
|
|
|
connection has LOCK TABLE t1 a READ, t1 b WRITE,
|
|
|
|
both t1 instances will be kept open.
|
2016-05-03 20:31:02 +02:00
|
|
|
|
|
|
|
Note that this code is only executed for engines that request
|
|
|
|
MDL_SHARED_NO_READ_WRITE lock (MDL_SHARED_WRITE cannot be upgraded)
|
|
|
|
by *not* having HA_CONCURRENT_OPTIMIZE table_flag.
|
2010-08-16 14:53:30 +02:00
|
|
|
*/
|
2019-06-17 17:50:08 +03:00
|
|
|
if (lock_type == TL_WRITE && table->mdl_request.type > MDL_SHARED_WRITE)
|
2010-08-16 14:53:30 +02:00
|
|
|
{
|
2019-06-17 17:50:08 +03:00
|
|
|
if (table->table->s->tmp_table)
|
2024-01-11 11:21:32 +01:00
|
|
|
thd->close_unused_temporary_table_instances(table);
|
2019-06-17 17:50:08 +03:00
|
|
|
else
|
|
|
|
{
|
2021-03-30 17:06:55 +03:00
|
|
|
/* Store information about table for ddl log */
|
|
|
|
storage_engine_partitioned= table->table->file->partition_engine();
|
|
|
|
strmake(storage_engine_name, table->table->file->real_table_type(),
|
|
|
|
sizeof(storage_engine_name)-1);
|
|
|
|
tabledef_version.str= tabledef_version_buff;
|
|
|
|
if ((tabledef_version.length= table->table->s->tabledef_version.length))
|
|
|
|
memcpy((char*) tabledef_version.str,
|
|
|
|
table->table->s->tabledef_version.str,
|
|
|
|
MY_UUID_SIZE);
|
|
|
|
|
2019-06-17 17:50:08 +03:00
|
|
|
if (wait_while_table_is_used(thd, table->table, HA_EXTRA_NOT_USED))
|
|
|
|
goto err;
|
|
|
|
DEBUG_SYNC(thd, "after_admin_flush");
|
|
|
|
/* Flush entries in the query cache involving this table. */
|
|
|
|
query_cache_invalidate3(thd, table->table, 0);
|
|
|
|
/*
|
|
|
|
XXX: hack: switch off open_for_modify to skip the
|
|
|
|
flush that is made later in the execution flow.
|
|
|
|
*/
|
|
|
|
open_for_modify= 0;
|
|
|
|
}
|
2010-08-16 14:53:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (table->table->s->crashed && operator_func == &handler::ha_check)
|
|
|
|
{
|
|
|
|
/* purecov: begin inspected */
|
|
|
|
DBUG_PRINT("admin", ("sending crashed warning"));
|
|
|
|
protocol->prepare_for_resend();
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
protocol->store(&table_name, system_charset_info);
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->store(operator_name, system_charset_info);
|
|
|
|
protocol->store(STRING_WITH_LEN("warning"), system_charset_info);
|
|
|
|
protocol->store(STRING_WITH_LEN("Table is marked as crashed"),
|
|
|
|
system_charset_info);
|
|
|
|
if (protocol->write())
|
|
|
|
goto err;
|
|
|
|
/* purecov: end */
|
|
|
|
}
|
|
|
|
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
if (operator_func == &handler::ha_repair)
|
2010-08-16 14:53:30 +02:00
|
|
|
{
|
2010-11-25 18:17:28 +01:00
|
|
|
handler *file= table->table->file;
|
|
|
|
int check_for_upgrade= file->ha_check_for_upgrade(check_opt);
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
require_data_conversion=
|
|
|
|
check_for_upgrade == HA_ADMIN_NEEDS_DATA_CONVERSION;
|
|
|
|
require_alter_table= check_for_upgrade == HA_ADMIN_NEEDS_ALTER;
|
2010-11-25 18:17:28 +01:00
|
|
|
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
if (!(check_opt->sql_flags & (TT_USEFRM | TT_FORCE)))
|
2012-01-13 15:50:02 +01:00
|
|
|
{
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
if (require_data_conversion || require_alter_table)
|
|
|
|
{
|
|
|
|
/* We use extra_open_options to be able to open crashed tables */
|
|
|
|
thd->open_options|= extra_open_options;
|
|
|
|
result_code= (admin_recreate_table(thd, table, &recreate_info, 1) ?
|
|
|
|
HA_ADMIN_FAILED : HA_ADMIN_OK);
|
|
|
|
recreate_used= 1;
|
|
|
|
thd->open_options&= ~extra_open_options;
|
|
|
|
goto send_result;
|
|
|
|
}
|
|
|
|
if (check_for_upgrade ||
|
|
|
|
!(table->table->file->ha_table_flags() & HA_CAN_REPAIR))
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
If data upgrade is needed or repair is not implemented for the
|
|
|
|
engine, run ALTER TABLE FORCE
|
|
|
|
*/
|
|
|
|
need_repair_or_alter= 1;
|
|
|
|
}
|
2012-01-13 15:50:02 +01:00
|
|
|
}
|
2010-08-16 14:53:30 +02:00
|
|
|
}
|
2012-05-22 20:55:07 -07:00
|
|
|
result_code= compl_result_code= HA_ADMIN_OK;
|
|
|
|
|
|
|
|
if (operator_func == &handler::ha_analyze)
|
|
|
|
{
|
|
|
|
TABLE *tab= table->table;
|
|
|
|
|
2012-12-05 22:51:11 -08:00
|
|
|
if (lex->with_persistent_for_clause &&
|
|
|
|
tab->s->table_category != TABLE_CATEGORY_USER)
|
|
|
|
{
|
|
|
|
compl_result_code= result_code= HA_ADMIN_INVALID;
|
|
|
|
}
|
2020-07-29 23:26:09 +03:00
|
|
|
|
|
|
|
/*
|
2020-08-03 13:41:29 +02:00
|
|
|
The check for ALTER_PARTITION_ADMIN implements this logic:
|
2020-07-29 23:26:09 +03:00
|
|
|
do not collect EITS STATS for this syntax:
|
|
|
|
ALTER TABLE ... ANALYZE PARTITION p
|
|
|
|
EITS statistics is global (not per-partition). Collecting global stats
|
|
|
|
is much more expensive processing just one partition, so the most
|
|
|
|
appropriate action is to just not collect EITS stats for this command.
|
|
|
|
*/
|
2016-03-17 15:12:57 +01:00
|
|
|
collect_eis=
|
2024-04-18 16:29:19 +03:00
|
|
|
(tab->s->table_category == TABLE_CATEGORY_USER && !tab->s->sequence &&
|
2024-01-29 15:51:29 +02:00
|
|
|
!(lex->alter_info.partition_flags & ALTER_PARTITION_ADMIN) &&
|
2018-12-09 13:25:27 +05:30
|
|
|
(check_eits_collection_allowed(thd) ||
|
2016-03-17 15:12:57 +01:00
|
|
|
lex->with_persistent_for_clause));
|
2012-05-22 20:55:07 -07:00
|
|
|
}
|
|
|
|
|
2012-06-02 17:19:01 -07:00
|
|
|
if (result_code == HA_ADMIN_OK)
|
2012-03-19 01:35:32 -07:00
|
|
|
{
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
DBUG_PRINT("admin", ("calling operator_func '%s'", operator_name->str));
|
2014-05-09 12:35:11 +02:00
|
|
|
THD_STAGE_INFO(thd, stage_executing);
|
2012-03-19 01:35:32 -07:00
|
|
|
result_code = (table->table->file->*operator_func)(thd, check_opt);
|
2014-05-09 12:35:11 +02:00
|
|
|
THD_STAGE_INFO(thd, stage_sending_data);
|
2012-03-19 01:35:32 -07:00
|
|
|
DBUG_PRINT("admin", ("operator_func returned: %d", result_code));
|
2024-06-16 18:04:27 +02:00
|
|
|
#ifdef WITH_PARTITION_STORAGE_ENGINE
|
|
|
|
if (lex->alter_info.partition_flags & ALTER_PARTITION_ADMIN)
|
|
|
|
set_part_state(&lex->alter_info, table->table->part_info, PART_NORMAL);
|
|
|
|
#endif
|
2012-03-19 01:35:32 -07:00
|
|
|
}
|
|
|
|
|
2023-08-18 18:35:02 +03:00
|
|
|
/* Note: compl_result_code can be different from result_code here */
|
2016-03-17 15:12:57 +01:00
|
|
|
if (compl_result_code == HA_ADMIN_OK && collect_eis)
|
2012-03-19 01:35:32 -07:00
|
|
|
{
|
2021-08-31 18:02:38 +03:00
|
|
|
if (result_code == HA_ERR_TABLE_READONLY)
|
|
|
|
{
|
|
|
|
protocol->prepare_for_resend();
|
|
|
|
protocol->store(&table_name, system_charset_info);
|
|
|
|
protocol->store(operator_name, system_charset_info);
|
|
|
|
send_read_only_warning(thd, &msg_status, &table_name);
|
|
|
|
(void) protocol->write();
|
|
|
|
result_code= HA_ADMIN_OK;
|
|
|
|
}
|
2016-08-01 19:24:55 +02:00
|
|
|
/*
|
|
|
|
Here we close and reopen table in read mode because operation of
|
|
|
|
collecting statistics is long and it will be better do not block
|
|
|
|
the table completely.
|
2017-06-21 13:44:16 +03:00
|
|
|
InnoDB will allow read/write and MyISAM read/insert.
|
2016-08-01 19:24:55 +02:00
|
|
|
*/
|
|
|
|
trans_commit_stmt(thd);
|
|
|
|
trans_commit(thd);
|
|
|
|
thd->open_options|= extra_open_options;
|
|
|
|
close_thread_tables(thd);
|
|
|
|
table->table= NULL;
|
2020-11-30 15:29:32 +02:00
|
|
|
thd->release_transactional_locks();
|
2020-02-14 16:28:05 +01:00
|
|
|
MDL_REQUEST_INIT(&table->mdl_request, MDL_key::TABLE, table->db.str,
|
|
|
|
table->table_name.str, MDL_SHARED_NO_READ_WRITE,
|
|
|
|
MDL_TRANSACTION);
|
2016-08-01 19:24:55 +02:00
|
|
|
table->mdl_request.set_type(MDL_SHARED_READ);
|
|
|
|
|
|
|
|
table->lock_type= TL_READ;
|
|
|
|
DBUG_ASSERT(view_operator_func == NULL);
|
|
|
|
open_error= open_only_one_table(thd, table,
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
no_errors_from_open, FALSE);
|
2016-08-01 19:24:55 +02:00
|
|
|
thd->open_options&= ~extra_open_options;
|
|
|
|
|
2018-04-04 12:16:12 +03:00
|
|
|
if (unlikely(!open_error))
|
2016-08-01 19:24:55 +02:00
|
|
|
{
|
2017-03-08 19:05:44 +01:00
|
|
|
TABLE *tab= table->table;
|
|
|
|
Field **field_ptr= tab->field;
|
2024-09-26 11:52:05 +02:00
|
|
|
MEM_ROOT_SAVEPOINT memroot_sv;
|
2023-10-13 15:14:37 +03:00
|
|
|
|
2017-03-08 19:05:44 +01:00
|
|
|
if (!lex->column_list)
|
2016-08-01 19:24:55 +02:00
|
|
|
{
|
2023-08-18 18:35:02 +03:00
|
|
|
/* Fields we have to read from the engine */
|
2017-03-08 19:05:44 +01:00
|
|
|
bitmap_clear_all(tab->read_set);
|
2023-08-18 18:35:02 +03:00
|
|
|
/* Fields we want to have statistics for */
|
|
|
|
bitmap_clear_all(&tab->has_value_set);
|
|
|
|
|
2017-03-08 19:05:44 +01:00
|
|
|
for (uint fields= 0; *field_ptr; field_ptr++, fields++)
|
|
|
|
{
|
2023-08-18 18:35:02 +03:00
|
|
|
Field *field= *field_ptr;
|
|
|
|
if (field->flags & LONG_UNIQUE_HASH_FIELD)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
No point in doing statistic for hash fields that should be
|
|
|
|
unique
|
|
|
|
*/
|
|
|
|
continue;
|
|
|
|
}
|
2023-08-05 01:08:05 +03:00
|
|
|
/*
|
|
|
|
Note that type() always return MYSQL_TYPE_BLOB for
|
|
|
|
all blob types. Another function needs to be added
|
|
|
|
if we in the future want to distingush between blob
|
|
|
|
types here.
|
|
|
|
*/
|
2023-08-18 18:35:02 +03:00
|
|
|
enum enum_field_types type= field->type();
|
2023-08-05 01:08:05 +03:00
|
|
|
if (type < MYSQL_TYPE_TINY_BLOB ||
|
2017-03-08 19:05:44 +01:00
|
|
|
type > MYSQL_TYPE_BLOB)
|
2023-08-18 18:35:02 +03:00
|
|
|
{
|
|
|
|
field->register_field_in_read_map();
|
|
|
|
bitmap_set_bit(&tab->has_value_set, field->field_index);
|
|
|
|
}
|
2017-03-08 19:05:44 +01:00
|
|
|
else
|
|
|
|
push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
|
|
|
|
ER_NO_EIS_FOR_FIELD,
|
|
|
|
ER_THD(thd, ER_NO_EIS_FOR_FIELD),
|
2017-04-23 19:39:57 +03:00
|
|
|
(*field_ptr)->field_name.str);
|
2017-03-08 19:05:44 +01:00
|
|
|
}
|
2016-08-01 19:24:55 +02:00
|
|
|
}
|
2017-03-08 19:05:44 +01:00
|
|
|
else
|
2016-08-01 19:24:55 +02:00
|
|
|
{
|
2017-03-08 19:05:44 +01:00
|
|
|
int pos;
|
|
|
|
LEX_STRING *column_name;
|
|
|
|
List_iterator_fast<LEX_STRING> it(*lex->column_list);
|
|
|
|
|
2023-08-18 18:35:02 +03:00
|
|
|
/* Fields we have to read from the engine */
|
2017-03-08 19:05:44 +01:00
|
|
|
bitmap_clear_all(tab->read_set);
|
2023-08-18 18:35:02 +03:00
|
|
|
/* Fields we want to have statistics for */
|
|
|
|
bitmap_clear_all(&tab->has_value_set);
|
|
|
|
|
2017-03-08 19:05:44 +01:00
|
|
|
while ((column_name= it++))
|
2016-08-01 19:24:55 +02:00
|
|
|
{
|
2023-08-18 18:35:02 +03:00
|
|
|
Field *field;
|
|
|
|
enum enum_field_types type;
|
2017-03-08 19:05:44 +01:00
|
|
|
if (tab->s->fieldnames.type_names == 0 ||
|
|
|
|
(pos= find_type(&tab->s->fieldnames, column_name->str,
|
|
|
|
column_name->length, 1)) <= 0)
|
|
|
|
{
|
|
|
|
compl_result_code= result_code= HA_ADMIN_INVALID;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
pos--;
|
2023-08-18 18:35:02 +03:00
|
|
|
field= tab->field[pos];
|
|
|
|
type= field->type();
|
|
|
|
if (!(field->flags & LONG_UNIQUE_HASH_FIELD) &&
|
|
|
|
(type < MYSQL_TYPE_TINY_BLOB ||
|
|
|
|
type > MYSQL_TYPE_BLOB))
|
|
|
|
{
|
|
|
|
field->register_field_in_read_map();
|
|
|
|
bitmap_set_bit(&tab->has_value_set, field->field_index);
|
|
|
|
}
|
2017-03-08 19:05:44 +01:00
|
|
|
else
|
|
|
|
push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
|
|
|
|
ER_NO_EIS_FOR_FIELD,
|
|
|
|
ER_THD(thd, ER_NO_EIS_FOR_FIELD),
|
|
|
|
column_name->str);
|
2016-08-01 19:24:55 +02:00
|
|
|
}
|
2017-03-08 19:05:44 +01:00
|
|
|
tab->file->column_bitmaps_signal();
|
2016-08-01 19:24:55 +02:00
|
|
|
}
|
2020-05-05 15:35:58 +05:30
|
|
|
if (!lex->index_list)
|
|
|
|
tab->keys_in_use_for_query.init(tab->s->keys);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int pos;
|
|
|
|
LEX_STRING *index_name;
|
|
|
|
List_iterator_fast<LEX_STRING> it(*lex->index_list);
|
|
|
|
tab->keys_in_use_for_query.clear_all();
|
|
|
|
while ((index_name= it++))
|
|
|
|
{
|
|
|
|
if (tab->s->keynames.type_names == 0 ||
|
|
|
|
(pos= find_type(&tab->s->keynames, index_name->str,
|
|
|
|
index_name->length, 1)) <= 0)
|
|
|
|
{
|
|
|
|
compl_result_code= result_code= HA_ADMIN_INVALID;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
tab->keys_in_use_for_query.set_bit(--pos);
|
|
|
|
}
|
|
|
|
}
|
2023-08-05 01:08:05 +03:00
|
|
|
/* Ensure that number of records are updated */
|
2023-08-18 18:35:02 +03:00
|
|
|
tab->file->info(HA_STATUS_VARIABLE);
|
2024-09-26 11:52:05 +02:00
|
|
|
root_make_savepoint(thd->mem_root, &memroot_sv);
|
2017-03-08 19:05:44 +01:00
|
|
|
if (!(compl_result_code=
|
2023-08-18 18:35:02 +03:00
|
|
|
alloc_statistics_for_table(thd, tab,
|
|
|
|
&tab->has_value_set)) &&
|
2017-03-08 19:05:44 +01:00
|
|
|
!(compl_result_code=
|
2023-08-18 18:35:02 +03:00
|
|
|
collect_statistics_for_table(thd, tab)))
|
|
|
|
compl_result_code= update_statistics_for_table(thd, tab);
|
2023-10-13 15:14:37 +03:00
|
|
|
free_statistics_for_table(tab);
|
2024-09-26 11:52:05 +02:00
|
|
|
root_free_to_savepoint(&memroot_sv);
|
2016-08-01 19:24:55 +02:00
|
|
|
}
|
2017-03-08 19:05:44 +01:00
|
|
|
else
|
|
|
|
compl_result_code= HA_ADMIN_FAILED;
|
|
|
|
|
2012-08-18 11:49:14 -07:00
|
|
|
if (compl_result_code)
|
|
|
|
result_code= HA_ADMIN_FAILED;
|
2014-03-28 00:32:53 +04:00
|
|
|
else
|
|
|
|
{
|
|
|
|
protocol->prepare_for_resend();
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
protocol->store(&table_name, system_charset_info);
|
2014-03-28 00:32:53 +04:00
|
|
|
protocol->store(operator_name, system_charset_info);
|
2021-08-31 18:02:38 +03:00
|
|
|
protocol->store(&msg_status, system_charset_info);
|
2014-03-28 00:32:53 +04:00
|
|
|
protocol->store(STRING_WITH_LEN("Engine-independent statistics collected"),
|
|
|
|
system_charset_info);
|
|
|
|
if (protocol->write())
|
|
|
|
goto err;
|
|
|
|
}
|
2012-03-19 01:35:32 -07:00
|
|
|
}
|
2010-08-16 14:53:30 +02:00
|
|
|
|
2010-11-25 18:17:28 +01:00
|
|
|
if (result_code == HA_ADMIN_NOT_IMPLEMENTED && need_repair_or_alter)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
repair was not implemented and we need to upgrade the table
|
|
|
|
to a new version so we recreate the table with ALTER TABLE
|
|
|
|
*/
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
result_code= admin_recreate_table(thd, table, &recreate_info, 1);
|
|
|
|
recreate_used= 1;
|
2010-11-25 18:17:28 +01:00
|
|
|
}
|
2010-08-16 14:53:30 +02:00
|
|
|
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
send_result:
|
2010-08-16 14:53:30 +02:00
|
|
|
lex->cleanup_after_one_table_open();
|
|
|
|
thd->clear_error(); // these errors shouldn't get client
|
2022-10-28 13:43:51 +04:00
|
|
|
|
|
|
|
if (recreate_info.records_duplicate())
|
|
|
|
{
|
|
|
|
protocol->prepare_for_resend();
|
2023-01-27 13:54:14 +01:00
|
|
|
protocol->store(&table_name, system_charset_info);
|
2023-01-31 09:31:42 +01:00
|
|
|
protocol->store(operator_name, system_charset_info);
|
2022-10-28 13:43:51 +04:00
|
|
|
protocol->store(warning_level_names[Sql_condition::WARN_LEVEL_WARN].str,
|
|
|
|
warning_level_names[Sql_condition::WARN_LEVEL_WARN].length,
|
|
|
|
system_charset_info);
|
|
|
|
char buf[80];
|
|
|
|
size_t length= my_snprintf(buf, sizeof(buf),
|
|
|
|
"Number of rows changed from %u to %u",
|
|
|
|
(uint) recreate_info.records_processed(),
|
|
|
|
(uint) recreate_info.records_copied());
|
|
|
|
protocol->store(buf, length, system_charset_info);
|
|
|
|
if (protocol->write())
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
2010-08-16 14:53:30 +02:00
|
|
|
{
|
2013-06-15 18:32:08 +03:00
|
|
|
Diagnostics_area::Sql_condition_iterator it=
|
|
|
|
thd->get_stmt_da()->sql_conditions();
|
|
|
|
const Sql_condition *err;
|
2010-08-16 14:53:30 +02:00
|
|
|
while ((err= it++))
|
|
|
|
{
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
const char *err_msg= err->get_message_text();
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->prepare_for_resend();
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
protocol->store(&table_name, system_charset_info);
|
|
|
|
protocol->store(operator_name, system_charset_info);
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->store(warning_level_names[err->get_level()].str,
|
|
|
|
warning_level_names[err->get_level()].length,
|
|
|
|
system_charset_info);
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
protocol->store(err_msg, strlen(err_msg), system_charset_info);
|
2010-08-16 14:53:30 +02:00
|
|
|
if (protocol->write())
|
|
|
|
goto err;
|
|
|
|
}
|
2013-06-15 18:32:08 +03:00
|
|
|
thd->get_stmt_da()->clear_warning_info(thd->query_id);
|
2010-08-16 14:53:30 +02:00
|
|
|
}
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
Give a warning if REPAIR TABLE was used but table still needs an
|
|
|
|
ALTER TABLE. This can only happen for old type tables where REPAIR
|
|
|
|
was using FORCE to recover old data.
|
|
|
|
*/
|
|
|
|
if (operator_func == &handler::ha_repair && ! recreate_used &&
|
|
|
|
(require_data_conversion || require_alter_table))
|
|
|
|
{
|
|
|
|
char buf[MYSQL_ERRMSG_SIZE];
|
|
|
|
if (result_code == HA_ADMIN_OK)
|
|
|
|
{
|
|
|
|
protocol->prepare_for_resend();
|
|
|
|
protocol->store(&table_name, system_charset_info);
|
|
|
|
protocol->store(operator_name, system_charset_info);
|
|
|
|
protocol->store(STRING_WITH_LEN("note"), system_charset_info);
|
|
|
|
protocol->store(STRING_WITH_LEN("Table data recovered"),system_charset_info);
|
|
|
|
if (protocol->write())
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
my_snprintf(buf, sizeof(buf),
|
|
|
|
ER_THD(thd, ER_TABLE_NEEDS_REBUILD),
|
|
|
|
table_name.str);
|
|
|
|
if (send_check_errmsg(thd, table, operator_name, buf) < 0)
|
|
|
|
goto err;
|
|
|
|
result_code= HA_ADMIN_FAILED;
|
|
|
|
}
|
|
|
|
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->prepare_for_resend();
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
protocol->store(&table_name, system_charset_info);
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->store(operator_name, system_charset_info);
|
|
|
|
|
|
|
|
send_result_message:
|
|
|
|
|
|
|
|
DBUG_PRINT("info", ("result_code: %d", result_code));
|
|
|
|
switch (result_code) {
|
|
|
|
case HA_ADMIN_NOT_IMPLEMENTED:
|
|
|
|
{
|
|
|
|
char buf[MYSQL_ERRMSG_SIZE];
|
|
|
|
size_t length=my_snprintf(buf, sizeof(buf),
|
2015-07-06 20:24:14 +03:00
|
|
|
ER_THD(thd, ER_CHECK_NOT_IMPLEMENTED),
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
operator_name->str);
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->store(STRING_WITH_LEN("note"), system_charset_info);
|
|
|
|
protocol->store(buf, length, system_charset_info);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case HA_ADMIN_NOT_BASE_TABLE:
|
|
|
|
{
|
|
|
|
char buf[MYSQL_ERRMSG_SIZE];
|
|
|
|
size_t length= my_snprintf(buf, sizeof(buf),
|
2015-07-06 20:24:14 +03:00
|
|
|
ER_THD(thd, ER_BAD_TABLE_ERROR),
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
table_name.str);
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->store(STRING_WITH_LEN("note"), system_charset_info);
|
|
|
|
protocol->store(buf, length, system_charset_info);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case HA_ADMIN_OK:
|
2021-08-31 18:02:38 +03:00
|
|
|
protocol->store(&msg_status, system_charset_info);
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->store(STRING_WITH_LEN("OK"), system_charset_info);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case HA_ADMIN_FAILED:
|
2021-08-31 18:02:38 +03:00
|
|
|
protocol->store(&msg_status, system_charset_info);
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->store(STRING_WITH_LEN("Operation failed"),
|
|
|
|
system_charset_info);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case HA_ADMIN_REJECT:
|
2021-08-31 18:02:38 +03:00
|
|
|
protocol->store(&msg_status, system_charset_info);
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->store(STRING_WITH_LEN("Operation need committed state"),
|
|
|
|
system_charset_info);
|
|
|
|
open_for_modify= FALSE;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case HA_ADMIN_ALREADY_DONE:
|
2021-08-31 18:02:38 +03:00
|
|
|
protocol->store(&msg_status, system_charset_info);
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->store(STRING_WITH_LEN("Table is already up to date"),
|
|
|
|
system_charset_info);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case HA_ADMIN_CORRUPT:
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
protocol->store(&error_clex_str, system_charset_info);
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->store(STRING_WITH_LEN("Corrupt"), system_charset_info);
|
|
|
|
fatal_error=1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case HA_ADMIN_INVALID:
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
protocol->store(&error_clex_str, system_charset_info);
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->store(STRING_WITH_LEN("Invalid argument"),
|
|
|
|
system_charset_info);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case HA_ADMIN_TRY_ALTER:
|
|
|
|
{
|
2012-11-06 18:44:22 +05:30
|
|
|
Alter_info *alter_info= &lex->alter_info;
|
|
|
|
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->store(STRING_WITH_LEN("note"), system_charset_info);
|
2018-02-19 11:23:20 +02:00
|
|
|
if (alter_info->partition_flags & ALTER_PARTITION_ADMIN)
|
2012-11-06 18:44:22 +05:30
|
|
|
{
|
|
|
|
protocol->store(STRING_WITH_LEN(
|
|
|
|
"Table does not support optimize on partitions. All partitions "
|
|
|
|
"will be rebuilt and analyzed."),system_charset_info);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
protocol->store(STRING_WITH_LEN(
|
|
|
|
"Table does not support optimize, doing recreate + analyze instead"),
|
|
|
|
system_charset_info);
|
|
|
|
}
|
2011-04-25 17:22:25 +02:00
|
|
|
if (protocol->write())
|
|
|
|
goto err;
|
2014-05-09 12:35:11 +02:00
|
|
|
THD_STAGE_INFO(thd, stage_recreating_table);
|
2011-04-25 17:22:25 +02:00
|
|
|
DBUG_PRINT("info", ("HA_ADMIN_TRY_ALTER, trying analyze..."));
|
2010-08-16 14:53:30 +02:00
|
|
|
TABLE_LIST *save_next_local= table->next_local,
|
|
|
|
*save_next_global= table->next_global;
|
|
|
|
table->next_local= table->next_global= 0;
|
2010-11-25 18:17:28 +01:00
|
|
|
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
result_code= admin_recreate_table(thd, table, &recreate_info, 0);
|
|
|
|
recreate_used= 1;
|
2010-08-16 14:53:30 +02:00
|
|
|
trans_commit_stmt(thd);
|
|
|
|
trans_commit(thd);
|
|
|
|
close_thread_tables(thd);
|
2020-11-30 15:29:32 +02:00
|
|
|
thd->release_transactional_locks();
|
2013-06-28 01:53:41 +03:00
|
|
|
/* Clear references to TABLE and MDL_ticket after releasing them. */
|
|
|
|
table->mdl_request.ticket= NULL;
|
2010-11-25 18:17:28 +01:00
|
|
|
|
2010-08-16 14:53:30 +02:00
|
|
|
if (!result_code) // recreation went ok
|
|
|
|
{
|
|
|
|
/* Clear the ticket released above. */
|
|
|
|
table->mdl_request.ticket= NULL;
|
|
|
|
DEBUG_SYNC(thd, "ha_admin_open_ltable");
|
|
|
|
table->mdl_request.set_type(MDL_SHARED_WRITE);
|
2016-06-10 16:19:59 -04:00
|
|
|
if (!thd->open_temporary_tables(table) &&
|
2013-06-18 02:01:34 +03:00
|
|
|
(table->table= open_ltable(thd, table, lock_type, 0)))
|
2010-08-16 14:53:30 +02:00
|
|
|
{
|
2018-02-15 10:22:03 +02:00
|
|
|
ulonglong save_flags;
|
2013-06-28 01:53:41 +03:00
|
|
|
/* Store the original value of alter_info->flags */
|
|
|
|
save_flags= alter_info->flags;
|
|
|
|
|
|
|
|
/*
|
2018-02-19 11:23:20 +02:00
|
|
|
Reset the ALTER_PARTITION_ADMIN bit in alter_info->flags
|
2013-06-28 01:53:41 +03:00
|
|
|
to force analyze on all partitions.
|
|
|
|
*/
|
2018-02-19 11:23:20 +02:00
|
|
|
alter_info->partition_flags &= ~(ALTER_PARTITION_ADMIN);
|
2010-08-16 14:53:30 +02:00
|
|
|
result_code= table->table->file->ha_analyze(thd, check_opt);
|
|
|
|
if (result_code == HA_ADMIN_ALREADY_DONE)
|
|
|
|
result_code= HA_ADMIN_OK;
|
|
|
|
else if (result_code) // analyze failed
|
|
|
|
table->table->file->print_error(result_code, MYF(0));
|
2013-06-28 01:53:41 +03:00
|
|
|
alter_info->flags= save_flags;
|
2010-08-16 14:53:30 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
result_code= -1; // open failed
|
|
|
|
}
|
|
|
|
/* Start a new row for the final status row */
|
|
|
|
protocol->prepare_for_resend();
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
protocol->store(&table_name, system_charset_info);
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->store(operator_name, system_charset_info);
|
|
|
|
if (result_code) // either mysql_recreate_table or analyze failed
|
|
|
|
{
|
MDEV-5262, MDEV-5914, MDEV-5941, MDEV-6020: Deadlocks during parallel
replication causing replication to fail.
In parallel replication, we run transactions from the master in parallel, but
force them to commit in the same order they did on the master. If we force T1
to commit before T2, but T2 holds eg. a row lock that is needed by T1, we get
a deadlock when T2 waits until T1 has committed.
Usually, we do not run T1 and T2 in parallel if there is a chance that they
can have conflicting locks like this, but there are certain edge cases where
it can occasionally happen (eg. MDEV-5914, MDEV-5941, MDEV-6020). The bug was
that this would cause replication to hang, eventually getting a lock timeout
and causing the slave to stop with error.
With this patch, InnoDB will report back to the upper layer whenever a
transactions T1 is about to do a lock wait on T2. If T1 and T2 are parallel
replication transactions, and T2 needs to commit later than T1, we can thus
detect the deadlock; we then kill T2, setting a flag that causes it to catch
the kill and convert it to a deadlock error; this error will then cause T2 to
roll back and release its locks (so that T1 can commit), and later T2 will be
re-tried and eventually also committed.
The kill happens asynchroneously in a slave background thread; this is
necessary, as the reporting from InnoDB about lock waits happen deep inside
the locking code, at a point where it is not possible to directly call
THD::awake() due to mutexes held.
Deadlock is assumed to be (very) rarely occuring, so this patch tries to
minimise the performance impact on the normal case where no deadlocks occur,
rather than optimise the handling of the occasional deadlock.
Also fix transaction retry due to deadlock when it happens after a transaction
already signalled to later transactions that it started to commit. In this
case we need to undo this signalling (and later redo it when we commit again
during retry), so following transactions will not start too early.
Also add a missing thd->send_kill_message() that got triggered during testing
(this corrects an incorrect fix for MySQL Bug#58933).
2014-06-03 10:31:11 +02:00
|
|
|
DBUG_ASSERT(thd->is_error());
|
2010-08-16 14:53:30 +02:00
|
|
|
if (thd->is_error())
|
|
|
|
{
|
2013-06-15 18:32:08 +03:00
|
|
|
const char *err_msg= thd->get_stmt_da()->message();
|
2010-08-16 14:53:30 +02:00
|
|
|
if (!thd->vio_ok())
|
|
|
|
{
|
|
|
|
sql_print_error("%s", err_msg);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Hijack the row already in-progress. */
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
protocol->store(&error_clex_str, system_charset_info);
|
|
|
|
protocol->store(err_msg, strlen(err_msg), system_charset_info);
|
2010-08-16 14:53:30 +02:00
|
|
|
if (protocol->write())
|
|
|
|
goto err;
|
|
|
|
/* Start off another row for HA_ADMIN_FAILED */
|
|
|
|
protocol->prepare_for_resend();
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
protocol->store(&table_name, system_charset_info);
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->store(operator_name, system_charset_info);
|
|
|
|
}
|
|
|
|
thd->clear_error();
|
|
|
|
}
|
2013-06-28 01:53:41 +03:00
|
|
|
/* Make sure this table instance is not reused after the operation. */
|
|
|
|
if (table->table)
|
2020-05-22 18:02:24 +03:00
|
|
|
table->table->mark_table_for_reopen();
|
2010-08-16 14:53:30 +02:00
|
|
|
}
|
|
|
|
result_code= result_code ? HA_ADMIN_FAILED : HA_ADMIN_OK;
|
|
|
|
table->next_local= save_next_local;
|
|
|
|
table->next_global= save_next_global;
|
|
|
|
goto send_result_message;
|
|
|
|
}
|
|
|
|
case HA_ADMIN_WRONG_CHECKSUM:
|
|
|
|
{
|
|
|
|
protocol->store(STRING_WITH_LEN("note"), system_charset_info);
|
2015-07-06 20:24:14 +03:00
|
|
|
protocol->store(ER_THD(thd, ER_VIEW_CHECKSUM),
|
|
|
|
strlen(ER_THD(thd, ER_VIEW_CHECKSUM)),
|
2010-08-16 14:53:30 +02:00
|
|
|
system_charset_info);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case HA_ADMIN_NEEDS_UPGRADE:
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
case HA_ADMIN_NEEDS_DATA_CONVERSION:
|
2010-08-16 14:53:30 +02:00
|
|
|
case HA_ADMIN_NEEDS_ALTER:
|
|
|
|
{
|
|
|
|
char buf[MYSQL_ERRMSG_SIZE];
|
|
|
|
size_t length;
|
2015-06-01 16:01:23 +02:00
|
|
|
const char *what_to_upgrade= table->view ? "VIEW" :
|
|
|
|
table->table->file->ha_table_flags() & HA_CAN_REPAIR ? "TABLE" : 0;
|
2010-08-16 14:53:30 +02:00
|
|
|
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
protocol->store(&error_clex_str, system_charset_info);
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
if (what_to_upgrade && result_code == HA_ADMIN_NEEDS_UPGRADE)
|
2015-07-06 20:24:14 +03:00
|
|
|
length= my_snprintf(buf, sizeof(buf),
|
|
|
|
ER_THD(thd, ER_TABLE_NEEDS_UPGRADE),
|
2018-01-07 18:03:44 +02:00
|
|
|
what_to_upgrade, table->table_name.str);
|
2011-03-08 09:41:57 +01:00
|
|
|
else
|
2015-07-06 20:24:14 +03:00
|
|
|
length= my_snprintf(buf, sizeof(buf),
|
|
|
|
ER_THD(thd, ER_TABLE_NEEDS_REBUILD),
|
2018-01-07 18:03:44 +02:00
|
|
|
table->table_name.str);
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->store(buf, length, system_charset_info);
|
|
|
|
fatal_error=1;
|
|
|
|
break;
|
|
|
|
}
|
2021-08-31 18:02:38 +03:00
|
|
|
case HA_ERR_TABLE_READONLY:
|
|
|
|
{
|
|
|
|
send_read_only_warning(thd, &msg_status, &table_name);
|
|
|
|
break;
|
|
|
|
}
|
2010-08-16 14:53:30 +02:00
|
|
|
default: // Probably HA_ADMIN_INTERNAL_ERROR
|
|
|
|
{
|
|
|
|
char buf[MYSQL_ERRMSG_SIZE];
|
|
|
|
size_t length=my_snprintf(buf, sizeof(buf),
|
|
|
|
"Unknown - internal error %d during operation",
|
|
|
|
result_code);
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
protocol->store(&error_clex_str, system_charset_info);
|
2010-08-16 14:53:30 +02:00
|
|
|
protocol->store(buf, length, system_charset_info);
|
|
|
|
fatal_error=1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2021-05-12 18:00:06 +05:30
|
|
|
/*
|
|
|
|
Admin commands acquire table locks and these locks are not detected by
|
|
|
|
parallel replication deadlock detection-and-handling mechanism. Hence
|
|
|
|
they must be marked as DDL so that they are not scheduled in parallel
|
|
|
|
with conflicting DMLs resulting in deadlock.
|
|
|
|
*/
|
2021-05-18 09:21:59 +03:00
|
|
|
thd->transaction->stmt.mark_executed_table_admin_cmd();
|
2021-03-30 17:06:55 +03:00
|
|
|
|
2015-05-07 22:18:34 +02:00
|
|
|
if (table->table && !table->view)
|
2010-08-16 14:53:30 +02:00
|
|
|
{
|
2023-08-05 01:08:05 +03:00
|
|
|
/* Skip FLUSH TABLES if we are doing analyze */
|
|
|
|
const bool skip_flush= (operator_func == &handler::ha_analyze);
|
2010-08-16 14:53:30 +02:00
|
|
|
if (table->table->s->tmp_table)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
If the table was not opened successfully, do not try to get
|
|
|
|
status information. (Bug#47633)
|
|
|
|
*/
|
|
|
|
if (open_for_modify && !open_error)
|
|
|
|
table->table->file->info(HA_STATUS_CONST);
|
|
|
|
}
|
MDEV-15101: Stop ANALYZE TABLE from flushing table definition cache
Apply this patch from Percona Server (amended for 10.5):
commit cd7201514fee78aaf7d3eb2b28d2573c76f53b84
Author: Laurynas Biveinis <laurynas.biveinis@gmail.com>
Date: Tue Nov 14 06:34:19 2017 +0200
Fix bug 1704195 / 87065 / TDB-83 (Stop ANALYZE TABLE from flushing table definition cache)
Make ANALYZE TABLE stop flushing affected tables from the table
definition cache, which has the effect of not blocking any subsequent
new queries involving the table if there's a parallel long-running
query:
- new table flag HA_ONLINE_ANALYZE, return it for InnoDB and TokuDB
tables;
- in mysql_admin_table, if we are performing ANALYZE TABLE, and the
table flag is set, do not remove the table from the table
definition cache, do not invalidate query cache;
- in partitioning handler, refresh the query optimizer statistics
after ANALYZE if the underlying handler supports HA_ONLINE_ANALYZE;
- new testcases main.percona_nonflushing_analyze_debug,
parts.percona_nonflushing_abalyze_debug and a supporting debug sync
point.
For TokuDB, this change exposes bug TDB-83 (Index cardinality stats
updated for handler::info(HA_STATUS_CONST), not often enough for
tokudb_cardinality_scale_percent). TokuDB may return different
rec_per_key values depending on dynamic variable
tokudb_cardinality_scale_percent value. The server does not have a way
of knowing that changing this variable invalidates the previous
rec_per_key values in any opened table shares, and so does not call
info(HA_STATUS_CONST) again. Fix by updating rec_per_key for both
HA_STATUS_CONST and HA_STATUS_VARIABLE. This also forces a re-record
of tokudb.bugs.db756_card_part_hash_1_pick, with the new output
seeming to be more correct.
2020-06-12 13:24:23 +03:00
|
|
|
else if ((!skip_flush && open_for_modify) || fatal_error)
|
2010-08-16 14:53:30 +02:00
|
|
|
{
|
2019-12-17 16:25:15 +04:00
|
|
|
table->table->s->tdc->flush_unused(true);
|
2010-08-16 14:53:30 +02:00
|
|
|
/*
|
|
|
|
May be something modified. Consequently, we have to
|
|
|
|
invalidate the query cache.
|
|
|
|
*/
|
|
|
|
table->table= 0; // For query cache
|
|
|
|
query_cache_invalidate3(thd, table, 0);
|
|
|
|
}
|
2023-08-05 01:08:05 +03:00
|
|
|
else if (collect_eis && skip_flush && compl_result_code == HA_ADMIN_OK)
|
|
|
|
{
|
|
|
|
TABLE_LIST *save_next_global= table->next_global;
|
|
|
|
table->next_global= 0;
|
|
|
|
read_statistics_for_tables(thd, table, true /* force_reload */);
|
|
|
|
table->next_global= save_next_global;
|
|
|
|
}
|
2010-08-16 14:53:30 +02:00
|
|
|
}
|
|
|
|
/* Error path, a admin command failed. */
|
2018-05-20 14:19:14 +03:00
|
|
|
if (thd->transaction_rollback_request || fatal_error)
|
2013-08-20 13:12:34 +04:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
Unlikely, but transaction rollback was requested by one of storage
|
|
|
|
engines (e.g. due to deadlock). Perform it.
|
|
|
|
*/
|
|
|
|
if (trans_rollback_stmt(thd) || trans_rollback_implicit(thd))
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2021-05-12 18:00:06 +05:30
|
|
|
if (trans_commit_stmt(thd))
|
2013-08-20 13:12:34 +04:00
|
|
|
goto err;
|
2021-05-18 08:40:19 +03:00
|
|
|
is_table_modified= true;
|
2013-08-20 13:12:34 +04:00
|
|
|
}
|
2010-08-16 14:53:30 +02:00
|
|
|
close_thread_tables(thd);
|
2021-03-30 17:06:55 +03:00
|
|
|
|
|
|
|
if (storage_engine_name[0])
|
|
|
|
{
|
|
|
|
/* Table was changed (repair, optimize or something similar) */
|
|
|
|
backup_log_info ddl_log;
|
|
|
|
bzero(&ddl_log, sizeof(ddl_log));
|
|
|
|
lex_string_set(&ddl_log.org_storage_engine_name,
|
|
|
|
storage_engine_name);
|
|
|
|
ddl_log.query= *operator_name;
|
|
|
|
ddl_log.org_partitioned= storage_engine_partitioned;
|
|
|
|
ddl_log.org_database= table->db;
|
|
|
|
ddl_log.org_table= table->table_name;
|
|
|
|
ddl_log.org_table_id= tabledef_version;
|
|
|
|
backup_log_ddl(&ddl_log);
|
|
|
|
}
|
|
|
|
|
2020-11-30 15:29:32 +02:00
|
|
|
thd->release_transactional_locks();
|
2010-08-16 14:53:30 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
If it is CHECK TABLE v1, v2, v3, and v1, v2, v3 are views, we will run
|
|
|
|
separate open_tables() for each CHECK TABLE argument.
|
|
|
|
Right now we do not have a separate method to reset the prelocking
|
|
|
|
state in the lex to the state after parsing, so each open will pollute
|
|
|
|
this state: add elements to lex->srotuines_list, TABLE_LISTs to
|
|
|
|
lex->query_tables. Below is a lame attempt to recover from this
|
|
|
|
pollution.
|
|
|
|
@todo: have a method to reset a prelocking context, or use separate
|
|
|
|
contexts for each open.
|
|
|
|
*/
|
|
|
|
for (Sroutine_hash_entry *rt=
|
|
|
|
(Sroutine_hash_entry*)thd->lex->sroutines_list.first;
|
|
|
|
rt; rt= rt->next)
|
|
|
|
rt->mdl_request.ticket= NULL;
|
|
|
|
|
|
|
|
if (protocol->write())
|
|
|
|
goto err;
|
2021-05-12 18:03:45 +05:30
|
|
|
DEBUG_SYNC(thd, "admin_command_kill_after_modify");
|
2010-08-16 14:53:30 +02:00
|
|
|
}
|
2023-01-05 20:08:01 +02:00
|
|
|
thd->resume_subsequent_commits(suspended_wfc);
|
|
|
|
DBUG_EXECUTE_IF("inject_analyze_table_sleep", my_sleep(500000););
|
2021-05-18 08:40:19 +03:00
|
|
|
if (is_table_modified && is_cmd_replicated &&
|
|
|
|
(!opt_readonly || thd->slave_thread) && !thd->lex->no_write_to_binlog)
|
2021-05-12 18:00:06 +05:30
|
|
|
{
|
2021-05-18 08:59:12 +03:00
|
|
|
thd->get_stmt_da()->set_overwrite_status(true);
|
|
|
|
auto res= write_bin_log(thd, true, thd->query(), thd->query_length());
|
|
|
|
thd->get_stmt_da()->set_overwrite_status(false);
|
|
|
|
if (res)
|
2021-05-12 18:00:06 +05:30
|
|
|
goto err;
|
2010-08-16 14:53:30 +02:00
|
|
|
}
|
|
|
|
my_eof(thd);
|
2023-01-05 20:08:01 +02:00
|
|
|
|
2010-08-16 14:53:30 +02:00
|
|
|
DBUG_RETURN(FALSE);
|
|
|
|
|
|
|
|
err:
|
2012-02-02 12:47:17 +01:00
|
|
|
/* Make sure this table instance is not reused after the failure. */
|
2010-08-16 14:53:30 +02:00
|
|
|
trans_rollback_stmt(thd);
|
2018-05-06 22:46:56 +02:00
|
|
|
if (stmt_causes_implicit_commit(thd, CF_IMPLICIT_COMMIT_END))
|
|
|
|
trans_rollback(thd);
|
2013-06-28 01:53:41 +03:00
|
|
|
if (table && table->table)
|
|
|
|
{
|
2020-05-22 18:02:24 +03:00
|
|
|
table->table->mark_table_for_reopen();
|
2013-06-28 01:53:41 +03:00
|
|
|
table->table= 0;
|
|
|
|
}
|
2010-08-16 14:53:30 +02:00
|
|
|
close_thread_tables(thd); // Shouldn't be needed
|
2020-11-30 15:29:32 +02:00
|
|
|
thd->release_transactional_locks();
|
2015-04-08 11:01:18 +02:00
|
|
|
thd->resume_subsequent_commits(suspended_wfc);
|
2010-08-16 14:53:30 +02:00
|
|
|
DBUG_RETURN(TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
Assigned specified indexes for a table into key cache
|
|
|
|
|
|
|
|
SYNOPSIS
|
|
|
|
mysql_assign_to_keycache()
|
|
|
|
thd Thread object
|
|
|
|
tables Table list (one table only)
|
|
|
|
|
|
|
|
RETURN VALUES
|
|
|
|
FALSE ok
|
|
|
|
TRUE error
|
|
|
|
*/
|
|
|
|
|
|
|
|
bool mysql_assign_to_keycache(THD* thd, TABLE_LIST* tables,
|
2017-04-23 19:39:57 +03:00
|
|
|
const LEX_CSTRING *key_cache_name)
|
2010-08-16 14:53:30 +02:00
|
|
|
{
|
|
|
|
HA_CHECK_OPT check_opt;
|
|
|
|
KEY_CACHE *key_cache;
|
|
|
|
DBUG_ENTER("mysql_assign_to_keycache");
|
|
|
|
|
2014-05-09 12:35:11 +02:00
|
|
|
THD_STAGE_INFO(thd, stage_finding_key_cache);
|
2010-08-16 14:53:30 +02:00
|
|
|
check_opt.init();
|
|
|
|
mysql_mutex_lock(&LOCK_global_system_variables);
|
|
|
|
if (!(key_cache= get_key_cache(key_cache_name)))
|
|
|
|
{
|
|
|
|
mysql_mutex_unlock(&LOCK_global_system_variables);
|
|
|
|
my_error(ER_UNKNOWN_KEY_CACHE, MYF(0), key_cache_name->str);
|
|
|
|
DBUG_RETURN(TRUE);
|
|
|
|
}
|
|
|
|
mysql_mutex_unlock(&LOCK_global_system_variables);
|
2011-12-14 15:33:01 +01:00
|
|
|
if (!key_cache->key_cache_inited)
|
|
|
|
{
|
|
|
|
my_error(ER_UNKNOWN_KEY_CACHE, MYF(0), key_cache_name->str);
|
|
|
|
DBUG_RETURN(true);
|
|
|
|
}
|
2010-08-16 14:53:30 +02:00
|
|
|
check_opt.key_cache= key_cache;
|
|
|
|
DBUG_RETURN(mysql_admin_table(thd, tables, &check_opt,
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
&msg_assign_to_keycache, TL_READ_NO_INSERT, 0,
|
|
|
|
0, 0, 0,
|
|
|
|
&handler::assign_to_keycache, 0, false));
|
2010-08-16 14:53:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
Preload specified indexes for a table into key cache
|
|
|
|
|
|
|
|
SYNOPSIS
|
|
|
|
mysql_preload_keys()
|
|
|
|
thd Thread object
|
|
|
|
tables Table list (one table only)
|
|
|
|
|
|
|
|
RETURN VALUES
|
|
|
|
FALSE ok
|
|
|
|
TRUE error
|
|
|
|
*/
|
|
|
|
|
|
|
|
bool mysql_preload_keys(THD* thd, TABLE_LIST* tables)
|
|
|
|
{
|
|
|
|
DBUG_ENTER("mysql_preload_keys");
|
|
|
|
/*
|
|
|
|
We cannot allow concurrent inserts. The storage engine reads
|
|
|
|
directly from the index file, bypassing the cache. It could read
|
|
|
|
outdated information if parallel inserts into cache blocks happen.
|
|
|
|
*/
|
|
|
|
DBUG_RETURN(mysql_admin_table(thd, tables, 0,
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
&msg_preload_keys, TL_READ_NO_INSERT,
|
|
|
|
0, 0, 0, 0,
|
|
|
|
&handler::preload_keys, 0, false));
|
2010-08-16 14:53:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-06-15 18:32:08 +03:00
|
|
|
bool Sql_cmd_analyze_table::execute(THD *thd)
|
2010-08-16 14:53:30 +02:00
|
|
|
{
|
2013-06-15 18:32:08 +03:00
|
|
|
LEX *m_lex= thd->lex;
|
2018-05-22 19:08:39 +02:00
|
|
|
TABLE_LIST *first_table= m_lex->first_select_lex()->table_list.first;
|
2010-08-16 14:53:30 +02:00
|
|
|
bool res= TRUE;
|
|
|
|
thr_lock_type lock_type = TL_READ_NO_INSERT;
|
2013-06-15 18:32:08 +03:00
|
|
|
DBUG_ENTER("Sql_cmd_analyze_table::execute");
|
2010-08-16 14:53:30 +02:00
|
|
|
|
|
|
|
if (check_table_access(thd, SELECT_ACL | INSERT_ACL, first_table,
|
|
|
|
FALSE, UINT_MAX, FALSE))
|
|
|
|
goto error;
|
2019-05-02 16:11:32 +03:00
|
|
|
if (thd->has_read_only_protection())
|
|
|
|
goto error;
|
|
|
|
|
2015-07-16 05:24:13 -07:00
|
|
|
WSREP_TO_ISOLATION_BEGIN_WRTCHK(NULL, NULL, first_table);
|
2010-08-16 14:53:30 +02:00
|
|
|
res= mysql_admin_table(thd, first_table, &m_lex->check_opt,
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
&msg_analyze, lock_type, 1, 0, 0, 0,
|
2021-05-12 18:00:06 +05:30
|
|
|
&handler::ha_analyze, 0, true);
|
2018-05-22 19:08:39 +02:00
|
|
|
m_lex->first_select_lex()->table_list.first= first_table;
|
2010-08-16 14:53:30 +02:00
|
|
|
m_lex->query_tables= first_table;
|
|
|
|
|
2018-11-06 16:24:16 +02:00
|
|
|
#ifdef WITH_WSREP
|
2020-10-27 12:45:42 +02:00
|
|
|
wsrep_error_label:
|
|
|
|
#endif /* WITH_WSREP */
|
|
|
|
error:
|
2010-08-16 14:53:30 +02:00
|
|
|
DBUG_RETURN(res);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-06-15 18:32:08 +03:00
|
|
|
bool Sql_cmd_check_table::execute(THD *thd)
|
2010-08-16 14:53:30 +02:00
|
|
|
{
|
2013-06-15 18:32:08 +03:00
|
|
|
LEX *m_lex= thd->lex;
|
2018-05-22 19:08:39 +02:00
|
|
|
TABLE_LIST *first_table= m_lex->first_select_lex()->table_list.first;
|
2010-08-16 14:53:30 +02:00
|
|
|
thr_lock_type lock_type = TL_READ_NO_INSERT;
|
|
|
|
bool res= TRUE;
|
2013-06-15 18:32:08 +03:00
|
|
|
DBUG_ENTER("Sql_cmd_check_table::execute");
|
2010-08-16 14:53:30 +02:00
|
|
|
|
|
|
|
if (check_table_access(thd, SELECT_ACL, first_table,
|
|
|
|
TRUE, UINT_MAX, FALSE))
|
|
|
|
goto error; /* purecov: inspected */
|
|
|
|
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
res= mysql_admin_table(thd, first_table, &m_lex->check_opt, &msg_check,
|
2010-08-16 14:53:30 +02:00
|
|
|
lock_type, 0, 0, HA_OPEN_FOR_REPAIR, 0,
|
2021-05-12 18:00:06 +05:30
|
|
|
&handler::ha_check, &view_check, false);
|
2010-08-16 14:53:30 +02:00
|
|
|
|
2018-05-22 19:08:39 +02:00
|
|
|
m_lex->first_select_lex()->table_list.first= first_table;
|
2010-08-16 14:53:30 +02:00
|
|
|
m_lex->query_tables= first_table;
|
|
|
|
|
|
|
|
error:
|
|
|
|
DBUG_RETURN(res);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-06-15 18:32:08 +03:00
|
|
|
bool Sql_cmd_optimize_table::execute(THD *thd)
|
2010-08-16 14:53:30 +02:00
|
|
|
{
|
2013-06-15 18:32:08 +03:00
|
|
|
LEX *m_lex= thd->lex;
|
2018-05-22 19:08:39 +02:00
|
|
|
TABLE_LIST *first_table= m_lex->first_select_lex()->table_list.first;
|
2010-08-16 14:53:30 +02:00
|
|
|
bool res= TRUE;
|
2022-10-28 13:43:51 +04:00
|
|
|
Recreate_info recreate_info;
|
2013-06-15 18:32:08 +03:00
|
|
|
DBUG_ENTER("Sql_cmd_optimize_table::execute");
|
2010-08-16 14:53:30 +02:00
|
|
|
|
|
|
|
if (check_table_access(thd, SELECT_ACL | INSERT_ACL, first_table,
|
|
|
|
FALSE, UINT_MAX, FALSE))
|
|
|
|
goto error; /* purecov: inspected */
|
2017-07-21 19:56:41 +03:00
|
|
|
|
2022-01-13 12:51:54 +01:00
|
|
|
WSREP_TO_ISOLATION_BEGIN_WRTCHK(NULL, NULL, first_table);
|
2013-06-15 18:32:08 +03:00
|
|
|
res= (specialflag & SPECIAL_NO_NEW_FUNC) ?
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
mysql_recreate_table(thd, first_table, &recreate_info,
|
|
|
|
false) :
|
2010-08-16 14:53:30 +02:00
|
|
|
mysql_admin_table(thd, first_table, &m_lex->check_opt,
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
&msg_optimize, TL_WRITE, 1, 0, 0, 0,
|
2021-05-12 18:00:06 +05:30
|
|
|
&handler::ha_optimize, 0, true);
|
2018-05-22 19:08:39 +02:00
|
|
|
m_lex->first_select_lex()->table_list.first= first_table;
|
2010-08-16 14:53:30 +02:00
|
|
|
m_lex->query_tables= first_table;
|
|
|
|
|
2022-01-13 12:51:54 +01:00
|
|
|
#ifdef WITH_WSREP
|
|
|
|
wsrep_error_label:
|
|
|
|
#endif /* WITH_WSREP */
|
2010-08-16 14:53:30 +02:00
|
|
|
error:
|
|
|
|
DBUG_RETURN(res);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-06-15 18:32:08 +03:00
|
|
|
bool Sql_cmd_repair_table::execute(THD *thd)
|
2010-08-16 14:53:30 +02:00
|
|
|
{
|
2013-06-15 18:32:08 +03:00
|
|
|
LEX *m_lex= thd->lex;
|
2018-05-22 19:08:39 +02:00
|
|
|
TABLE_LIST *first_table= m_lex->first_select_lex()->table_list.first;
|
2010-08-16 14:53:30 +02:00
|
|
|
bool res= TRUE;
|
2013-06-15 18:32:08 +03:00
|
|
|
DBUG_ENTER("Sql_cmd_repair_table::execute");
|
2010-08-16 14:53:30 +02:00
|
|
|
|
|
|
|
if (check_table_access(thd, SELECT_ACL | INSERT_ACL, first_table,
|
|
|
|
FALSE, UINT_MAX, FALSE))
|
|
|
|
goto error; /* purecov: inspected */
|
2022-01-13 12:51:54 +01:00
|
|
|
WSREP_TO_ISOLATION_BEGIN_WRTCHK(NULL, NULL, first_table);
|
Reduce usage of strlen()
Changes:
- To detect automatic strlen() I removed the methods in String that
uses 'const char *' without a length:
- String::append(const char*)
- Binary_string(const char *str)
- String(const char *str, CHARSET_INFO *cs)
- append_for_single_quote(const char *)
All usage of append(const char*) is changed to either use
String::append(char), String::append(const char*, size_t length) or
String::append(LEX_CSTRING)
- Added STRING_WITH_LEN() around constant string arguments to
String::append()
- Added overflow argument to escape_string_for_mysql() and
escape_quotes_for_mysql() instead of returning (size_t) -1 on overflow.
This was needed as most usage of the above functions never tested the
result for -1 and would have given wrong results or crashes in case
of overflows.
- Added Item_func_or_sum::func_name_cstring(), which returns LEX_CSTRING.
Changed all Item_func::func_name()'s to func_name_cstring()'s.
The old Item_func_or_sum::func_name() is now an inline function that
returns func_name_cstring().str.
- Changed Item::mode_name() and Item::func_name_ext() to return
LEX_CSTRING.
- Changed for some functions the name argument from const char * to
to const LEX_CSTRING &:
- Item::Item_func_fix_attributes()
- Item::check_type_...()
- Type_std_attributes::agg_item_collations()
- Type_std_attributes::agg_item_set_converter()
- Type_std_attributes::agg_arg_charsets...()
- Type_handler_hybrid_field_type::aggregate_for_result()
- Type_handler_geometry::check_type_geom_or_binary()
- Type_handler::Item_func_or_sum_illegal_param()
- Predicant_to_list_comparator::add_value_skip_null()
- Predicant_to_list_comparator::add_value()
- cmp_item_row::prepare_comparators()
- cmp_item_row::aggregate_row_elements_for_comparison()
- Cursor_ref::print_func()
- Removes String_space() as it was only used in one cases and that
could be simplified to not use String_space(), thanks to the fixed
my_vsnprintf().
- Added some const LEX_CSTRING's for common strings:
- NULL_clex_str, DATA_clex_str, INDEX_clex_str.
- Changed primary_key_name to a LEX_CSTRING
- Renamed String::set_quick() to String::set_buffer_if_not_allocated() to
clarify what the function really does.
- Rename of protocol function:
bool store(const char *from, CHARSET_INFO *cs) to
bool store_string_or_null(const char *from, CHARSET_INFO *cs).
This was done to both clarify the difference between this 'store' function
and also to make it easier to find unoptimal usage of store() calls.
- Added Protocol::store(const LEX_CSTRING*, CHARSET_INFO*)
- Changed some 'const char*' arrays to instead be of type LEX_CSTRING.
- class Item_func_units now used LEX_CSTRING for name.
Other things:
- Fixed a bug in mysql.cc:construct_prompt() where a wrong escape character
in the prompt would cause some part of the prompt to be duplicated.
- Fixed a lot of instances where the length of the argument to
append is known or easily obtain but was not used.
- Removed some not needed 'virtual' definition for functions that was
inherited from the parent. I added override to these.
- Fixed Ordered_key::print() to preallocate needed buffer. Old code could
case memory overruns.
- Simplified some loops when adding char * to a String with delimiters.
2020-08-12 20:29:55 +03:00
|
|
|
res= mysql_admin_table(thd, first_table, &m_lex->check_opt, &msg_repair,
|
2010-08-16 14:53:30 +02:00
|
|
|
TL_WRITE, 1,
|
MDEV-33449 improving repair of tables
This task is to ensure we have a clear definition and rules of how to
repair or optimize a table.
The rules are:
- REPAIR should be used with tables that are crashed and are
unreadable (hardware issues with not readable blocks, blocks with
'unexpected data' etc)
- OPTIMIZE table should be used to optimize the storage layout for the
table (recover space for delete rows and optimize the index
structure.
- ALTER TABLE table_name FORCE should be used to rebuild the .frm file
(the table definition) and the table (with the original table row
format). If the table is from and older MariaDB/MySQL release with a
different storage format, it will convert the data to the new
format. ALTER TABLE ... FORCE is used as part of mariadb-upgrade
Here follows some more background:
The 3 ways to repair a table are:
1) ALTER TABLE table_name FORCE" (not other options).
As an alias we allow: "ALTER TABLE table_name ENGINE=original_engine"
2) "REPAIR TABLE" (without FORCE)
3) "OPTIMIZE TABLE"
All of the above commands will optimize row space usage (which means that
space will be needed to hold a temporary copy of the table) and
re-generate all indexes. They will also try to replicate the original
table definition as exact as possible.
For ALTER TABLE and "REPAIR TABLE without FORCE", the following will hold:
If the table is from an older MariaDB version and data conversion is
needed (for example for old type HASH columns, MySQL JSON type or new
TIMESTAMP format) "ALTER TABLE table_name FORCE, algorithm=COPY" will be
used.
The differences between the algorithms are
1) Will use the fastest algorithm the engine supports to do a full repair
of the table (except if data conversions are is needed).
2) Will use the storage engine internal REPAIR facility (MyISAM, Aria).
If the engine does not support REPAIR then
"ALTER TABLE FORCE, ALGORITHM=COPY" will be used.
If there was data incompatibilities (which means that FORCE was used)
then there will be a warning after REPAIR that ALTER TABLE FORCE is
still needed.
The reason for this is that REPAIR may be able to go around data
errors (wrong incompatible data, crashed or unreadable sectors) that
ALTER TABLE cannot do.
3) Will use the storage engine internal OPTIMIZE. If engine does not
support optimize, then "ALTER TABLE FORCE" is used.
The above will ensure that ALTER TABLE FORCE is able to
correct almost any errors in the row or index data. In case of
corrupted blocks then REPAIR possible followed by ALTER TABLE is needed.
This is important as mariadb-upgrade executes ALTER TABLE table_name
FORCE for any table that must be re-created.
Bugs fixed with InnoDB tables when using ALTER TABLE FORCE:
- No error for INNODB_DEFAULT_ROW_FORMAT=COMPACT even if row length
would be too wide. (Independent of innodb_strict_mode).
- Tables using symlinks will be symlinked after any of the above commands
(Independent of the setting of --symbolic-links)
If one specifies an algorithm together with ALTER TABLE FORCE, things
will work as before (except if data conversion is required as then
the COPY algorithm is enforced).
ALTER TABLE .. OPTIMIZE ALL PARTITIONS will work as before.
Other things:
- FORCE argument added to REPAIR to allow one to first run internal
repair to fix damaged blocks and then follow it with ALTER TABLE.
- REPAIR will not update frm_version if ha_check_for_upgrade() finds
that table is still incompatible with current version. In this case the
REPAIR will end with an error.
- REPAIR for storage engines that does not have native repair, like InnoDB,
is now using ALTER TABLE FORCE.
- REPAIR csv-table USE_FRM now works.
- It did not work before as CSV tables had extension list in wrong
order.
- Default error messages length for %M increased from 128 to 256 to not
cut information from REPAIR.
- Documented HA_ADMIN_XX variables related to repair.
- Added HA_ADMIN_NEEDS_DATA_CONVERSION to signal that we have to
do data conversions when converting the table (and thus ALTER TABLE
copy algorithm is needed).
- Fixed typo in error message (caused test changes).
2024-01-29 11:52:44 +02:00
|
|
|
MY_TEST(m_lex->check_opt.sql_flags &
|
|
|
|
(TT_USEFRM | TT_FORCE)),
|
2010-08-16 14:53:30 +02:00
|
|
|
HA_OPEN_FOR_REPAIR, &prepare_for_repair,
|
2021-05-12 18:00:06 +05:30
|
|
|
&handler::ha_repair, &view_repair, true);
|
2010-08-16 14:53:30 +02:00
|
|
|
|
2018-05-22 19:08:39 +02:00
|
|
|
m_lex->first_select_lex()->table_list.first= first_table;
|
2010-08-16 14:53:30 +02:00
|
|
|
m_lex->query_tables= first_table;
|
|
|
|
|
2022-01-13 12:51:54 +01:00
|
|
|
#ifdef WITH_WSREP
|
|
|
|
wsrep_error_label:
|
|
|
|
#endif /* WITH_WSREP */
|
2010-08-16 14:53:30 +02:00
|
|
|
error:
|
|
|
|
DBUG_RETURN(res);
|
|
|
|
}
|