From 75bbf645a66db797be2abd3a348dce32eb753acc Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Tue, 24 Jan 2023 21:40:43 -0800 Subject: Add missing include This is needed with GCC 13 and newer [1] [1] https://www.gnu.org/software/gcc/gcc-13/porting_to.html Signed-off-by: Khem Raj --- tpool/aio_linux.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/tpool/aio_linux.cc b/tpool/aio_linux.cc index 8a6688e6775..6997cbcccab 100644 --- a/tpool/aio_linux.cc +++ b/tpool/aio_linux.cc @@ -19,6 +19,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111 - 1301 USA*/ #ifdef LINUX_NATIVE_AIO # include # include +# include # include # include -- cgit v1.2.1 From 015fb54d45a27dc33191f513f896ab1ead5d2377 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Lindstr=C3=B6m?= Date: Thu, 26 Jan 2023 10:27:31 +0200 Subject: MDEV-25037 : SIGSEGV in MDL_lock::hog_lock_types_bitmap We should not call mdl_context.release_explicit_locks() in Wsrep_client_service::bf_rollback() if client is quiting because it will be done again in THD::cleanup(). Note that problem with GET_LOCK() / RELEASE_LOCK() will be fixed on MDEV-30473. --- .../suite/galera/r/galera_backup_start.result | 6 ++++ mysql-test/suite/galera/t/galera_backup_start.test | 6 ++++ sql/wsrep_client_service.cc | 40 +++++++++++++++------- sql/wsrep_high_priority_service.cc | 10 ++++++ 4 files changed, 49 insertions(+), 13 deletions(-) create mode 100644 mysql-test/suite/galera/r/galera_backup_start.result create mode 100644 mysql-test/suite/galera/t/galera_backup_start.test diff --git a/mysql-test/suite/galera/r/galera_backup_start.result b/mysql-test/suite/galera/r/galera_backup_start.result new file mode 100644 index 00000000000..253a0ce7416 --- /dev/null +++ b/mysql-test/suite/galera/r/galera_backup_start.result @@ -0,0 +1,6 @@ +connection node_2; +connection node_1; +BACKUP STAGE START; +START TRANSACTION; +COMMIT; +BACKUP STAGE END; diff --git a/mysql-test/suite/galera/t/galera_backup_start.test b/mysql-test/suite/galera/t/galera_backup_start.test new file mode 100644 index 00000000000..4489e9ff582 --- /dev/null +++ b/mysql-test/suite/galera/t/galera_backup_start.test @@ -0,0 +1,6 @@ +--source include/galera_cluster.inc + +BACKUP STAGE START; +START TRANSACTION; +COMMIT; +BACKUP STAGE END; diff --git a/sql/wsrep_client_service.cc b/sql/wsrep_client_service.cc index 5162f13458b..e77f307f028 100644 --- a/sql/wsrep_client_service.cc +++ b/sql/wsrep_client_service.cc @@ -1,4 +1,4 @@ -/* Copyright 2018-2022 Codership Oy +/* Copyright 2018-2023 Codership Oy 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 @@ -349,22 +349,36 @@ void Wsrep_client_service::debug_crash(const char* crash_point) int Wsrep_client_service::bf_rollback() { DBUG_ASSERT(m_thd == current_thd); - DBUG_ENTER("Wsrep_client_service::rollback"); + DBUG_ENTER("Wsrep_client_service::bf_rollback"); int ret= (trans_rollback_stmt(m_thd) || trans_rollback(m_thd)); - if (m_thd->locked_tables_mode && m_thd->lock) - { - if (m_thd->locked_tables_list.unlock_locked_tables(m_thd)) - ret= 1; - m_thd->variables.option_bits&= ~OPTION_TABLE_LOCK; - } - if (m_thd->global_read_lock.is_acquired()) + + WSREP_DEBUG("::bf_rollback() thread: %lu, client_state %s " + "client_mode %s trans_state %s killed %d", + thd_get_thread_id(m_thd), + wsrep_thd_client_state_str(m_thd), + wsrep_thd_client_mode_str(m_thd), + wsrep_thd_transaction_state_str(m_thd), + m_thd->killed); + + /* If client is quiting all below will be done in THD::cleanup() + TODO: why we need this any other case? */ + if (m_thd->wsrep_cs().state() != wsrep::client_state::s_quitting) { - m_thd->global_read_lock.unlock_global_read_lock(m_thd); + if (m_thd->locked_tables_mode && m_thd->lock) + { + if (m_thd->locked_tables_list.unlock_locked_tables(m_thd)) + ret= 1; + m_thd->variables.option_bits&= ~OPTION_TABLE_LOCK; + } + if (m_thd->global_read_lock.is_acquired()) + { + m_thd->global_read_lock.unlock_global_read_lock(m_thd); + } + m_thd->release_transactional_locks(); + mysql_ull_cleanup(m_thd); + m_thd->mdl_context.release_explicit_locks(); } - m_thd->release_transactional_locks(); - mysql_ull_cleanup(m_thd); - m_thd->mdl_context.release_explicit_locks(); DBUG_RETURN(ret); } diff --git a/sql/wsrep_high_priority_service.cc b/sql/wsrep_high_priority_service.cc index 93d4738212d..7d8296a75a1 100644 --- a/sql/wsrep_high_priority_service.cc +++ b/sql/wsrep_high_priority_service.cc @@ -292,6 +292,7 @@ int Wsrep_high_priority_service::append_fragment_and_commit( ret= ret || trans_commit(m_thd); ret= ret || (m_thd->wsrep_cs().after_applying(), 0); + m_thd->release_transactional_locks(); free_root(m_thd->mem_root, MYF(MY_KEEP_PREALLOC)); @@ -380,6 +381,15 @@ int Wsrep_high_priority_service::rollback(const wsrep::ws_handle& ws_handle, assert(ws_handle == wsrep::ws_handle()); } int ret= (trans_rollback_stmt(m_thd) || trans_rollback(m_thd)); + + WSREP_DEBUG("::rollback() thread: %lu, client_state %s " + "client_mode %s trans_state %s killed %d", + thd_get_thread_id(m_thd), + wsrep_thd_client_state_str(m_thd), + wsrep_thd_client_mode_str(m_thd), + wsrep_thd_transaction_state_str(m_thd), + m_thd->killed); + m_thd->release_transactional_locks(); mysql_ull_cleanup(m_thd); m_thd->mdl_context.release_explicit_locks(); -- cgit v1.2.1 From 844ddb1109410e0ab1d4444549932f1dddb7b845 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Lindstr=C3=B6m?= Date: Thu, 26 Jan 2023 14:34:12 +0200 Subject: MDEV-30473 : Do not allow GET_LOCK() / RELEASE_LOCK() in cluster If WSREP_ON=ON do not allow GET_LOCK and RELEASE_LOCK functions. Instead print clear error message. --- mysql-test/suite/galera/r/galera_locks_funcs.result | 19 +++++++++++++++++++ mysql-test/suite/galera/t/galera_locks_funcs.test | 14 ++++++++++++++ sql/item_create.cc | 14 ++++++++++++++ 3 files changed, 47 insertions(+) create mode 100644 mysql-test/suite/galera/r/galera_locks_funcs.result create mode 100644 mysql-test/suite/galera/t/galera_locks_funcs.test diff --git a/mysql-test/suite/galera/r/galera_locks_funcs.result b/mysql-test/suite/galera/r/galera_locks_funcs.result new file mode 100644 index 00000000000..378067aa461 --- /dev/null +++ b/mysql-test/suite/galera/r/galera_locks_funcs.result @@ -0,0 +1,19 @@ +connection node_2; +connection node_1; +CREATE TABLE t (c DOUBLE,c2 INT,PRIMARY KEY(c)) ENGINE=InnoDB; +INSERT INTO t values (1,1); +SELECT GET_LOCK('a',1); +ERROR 42000: This version of MariaDB doesn't yet support 'GET_LOCK in cluster (WSREP_ON=ON)' +SHOW WARNINGS; +Level Code Message +Error 1235 This version of MariaDB doesn't yet support 'GET_LOCK in cluster (WSREP_ON=ON)' +SELECT * FROM t; +c c2 +1 1 +SELECT RELEASE_LOCK('a'); +ERROR 42000: This version of MariaDB doesn't yet support 'RELEASE_LOCK in cluster (WSREP_ON=ON)' +SHOW WARNINGS; +Level Code Message +Error 1235 This version of MariaDB doesn't yet support 'RELEASE_LOCK in cluster (WSREP_ON=ON)' +COMMIT; +DROP TABLE t; diff --git a/mysql-test/suite/galera/t/galera_locks_funcs.test b/mysql-test/suite/galera/t/galera_locks_funcs.test new file mode 100644 index 00000000000..68737f2daab --- /dev/null +++ b/mysql-test/suite/galera/t/galera_locks_funcs.test @@ -0,0 +1,14 @@ +--source include/galera_cluster.inc + +CREATE TABLE t (c DOUBLE,c2 INT,PRIMARY KEY(c)) ENGINE=InnoDB; +INSERT INTO t values (1,1); +--error ER_NOT_SUPPORTED_YET +SELECT GET_LOCK('a',1); +SHOW WARNINGS; +SELECT * FROM t; +--error ER_NOT_SUPPORTED_YET +SELECT RELEASE_LOCK('a'); +SHOW WARNINGS; +COMMIT; +DROP TABLE t; + diff --git a/sql/item_create.cc b/sql/item_create.cc index 2dfbc1d2021..9fc43df2aea 100644 --- a/sql/item_create.cc +++ b/sql/item_create.cc @@ -4933,6 +4933,13 @@ Create_func_get_lock Create_func_get_lock::s_singleton; Item* Create_func_get_lock::create_2_arg(THD *thd, Item *arg1, Item *arg2) { +#ifdef WITH_WSREP + if (WSREP_ON && WSREP(thd)) + { + my_error(ER_NOT_SUPPORTED_YET, MYF(0), "GET_LOCK in cluster (WSREP_ON=ON)"); + return NULL; + } +#endif /* WITH_WSREP */ thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION); thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); return new (thd->mem_root) Item_func_get_lock(thd, arg1, arg2); @@ -6535,6 +6542,13 @@ Create_func_release_lock Create_func_release_lock::s_singleton; Item* Create_func_release_lock::create_1_arg(THD *thd, Item *arg1) { +#ifdef WITH_WSREP + if (WSREP_ON && WSREP(thd)) + { + my_error(ER_NOT_SUPPORTED_YET, MYF(0), "RELEASE_LOCK in cluster (WSREP_ON=ON)"); + return NULL; + } +#endif /* WITH_WSREP */ thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION); thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); return new (thd->mem_root) Item_func_release_lock(thd, arg1); -- cgit v1.2.1 From 696562ce5528faa60653aa31058bf42f26d71dc4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Lindstr=C3=B6m?= Date: Thu, 26 Jan 2023 14:34:12 +0200 Subject: MDEV-30473 : Do not allow GET_LOCK() / RELEASE_LOCK() in cluster If WSREP_ON=ON do not allow GET_LOCK and RELEASE_LOCK functions. Instead print clear error message. --- mysql-test/suite/galera/r/galera_locks_funcs.result | 19 +++++++++++++++++++ mysql-test/suite/galera/t/galera_locks_funcs.test | 14 ++++++++++++++ sql/item_create.cc | 14 ++++++++++++++ 3 files changed, 47 insertions(+) create mode 100644 mysql-test/suite/galera/r/galera_locks_funcs.result create mode 100644 mysql-test/suite/galera/t/galera_locks_funcs.test diff --git a/mysql-test/suite/galera/r/galera_locks_funcs.result b/mysql-test/suite/galera/r/galera_locks_funcs.result new file mode 100644 index 00000000000..378067aa461 --- /dev/null +++ b/mysql-test/suite/galera/r/galera_locks_funcs.result @@ -0,0 +1,19 @@ +connection node_2; +connection node_1; +CREATE TABLE t (c DOUBLE,c2 INT,PRIMARY KEY(c)) ENGINE=InnoDB; +INSERT INTO t values (1,1); +SELECT GET_LOCK('a',1); +ERROR 42000: This version of MariaDB doesn't yet support 'GET_LOCK in cluster (WSREP_ON=ON)' +SHOW WARNINGS; +Level Code Message +Error 1235 This version of MariaDB doesn't yet support 'GET_LOCK in cluster (WSREP_ON=ON)' +SELECT * FROM t; +c c2 +1 1 +SELECT RELEASE_LOCK('a'); +ERROR 42000: This version of MariaDB doesn't yet support 'RELEASE_LOCK in cluster (WSREP_ON=ON)' +SHOW WARNINGS; +Level Code Message +Error 1235 This version of MariaDB doesn't yet support 'RELEASE_LOCK in cluster (WSREP_ON=ON)' +COMMIT; +DROP TABLE t; diff --git a/mysql-test/suite/galera/t/galera_locks_funcs.test b/mysql-test/suite/galera/t/galera_locks_funcs.test new file mode 100644 index 00000000000..68737f2daab --- /dev/null +++ b/mysql-test/suite/galera/t/galera_locks_funcs.test @@ -0,0 +1,14 @@ +--source include/galera_cluster.inc + +CREATE TABLE t (c DOUBLE,c2 INT,PRIMARY KEY(c)) ENGINE=InnoDB; +INSERT INTO t values (1,1); +--error ER_NOT_SUPPORTED_YET +SELECT GET_LOCK('a',1); +SHOW WARNINGS; +SELECT * FROM t; +--error ER_NOT_SUPPORTED_YET +SELECT RELEASE_LOCK('a'); +SHOW WARNINGS; +COMMIT; +DROP TABLE t; + diff --git a/sql/item_create.cc b/sql/item_create.cc index feae487ff0c..81621253cd5 100644 --- a/sql/item_create.cc +++ b/sql/item_create.cc @@ -3547,6 +3547,13 @@ Create_func_get_lock Create_func_get_lock::s_singleton; Item* Create_func_get_lock::create_2_arg(THD *thd, Item *arg1, Item *arg2) { +#ifdef WITH_WSREP + if (WSREP_ON && WSREP(thd)) + { + my_error(ER_NOT_SUPPORTED_YET, MYF(0), "GET_LOCK in cluster (WSREP_ON=ON)"); + return NULL; + } +#endif /* WITH_WSREP */ thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION); thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); return new (thd->mem_root) Item_func_get_lock(thd, arg1, arg2); @@ -4847,6 +4854,13 @@ Create_func_release_lock Create_func_release_lock::s_singleton; Item* Create_func_release_lock::create_1_arg(THD *thd, Item *arg1) { +#ifdef WITH_WSREP + if (WSREP_ON && WSREP(thd)) + { + my_error(ER_NOT_SUPPORTED_YET, MYF(0), "RELEASE_LOCK in cluster (WSREP_ON=ON)"); + return NULL; + } +#endif /* WITH_WSREP */ thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION); thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); return new (thd->mem_root) Item_func_release_lock(thd, arg1); -- cgit v1.2.1 From 49ee18eb422d7c2bc3b349eef4be9134816b066a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Lindstr=C3=B6m?= Date: Fri, 27 Jan 2023 10:40:07 +0200 Subject: MDEV-30473 : Do not allow GET_LOCK() / RELEASE_LOCK() in cluster In 10.5 If WSREP_ON=ON do not allow RELEASE_ALL_LOCKS function. Instead print clear error message. --- mysql-test/suite/galera/r/galera_locks_funcs.result | 5 +++++ mysql-test/suite/galera/t/galera_locks_funcs.test | 4 ++++ sql/item_create.cc | 7 +++++++ 3 files changed, 16 insertions(+) diff --git a/mysql-test/suite/galera/r/galera_locks_funcs.result b/mysql-test/suite/galera/r/galera_locks_funcs.result index 378067aa461..25d3bbe28f5 100644 --- a/mysql-test/suite/galera/r/galera_locks_funcs.result +++ b/mysql-test/suite/galera/r/galera_locks_funcs.result @@ -15,5 +15,10 @@ ERROR 42000: This version of MariaDB doesn't yet support 'RELEASE_LOCK in cluste SHOW WARNINGS; Level Code Message Error 1235 This version of MariaDB doesn't yet support 'RELEASE_LOCK in cluster (WSREP_ON=ON)' +SELECT RELEASE_ALL_LOCKS(); +ERROR 42000: This version of MariaDB doesn't yet support 'RELEASE_ALL_LOCKS in cluster (WSREP_ON=ON)' +SHOW WARNINGS; +Level Code Message +Error 1235 This version of MariaDB doesn't yet support 'RELEASE_ALL_LOCKS in cluster (WSREP_ON=ON)' COMMIT; DROP TABLE t; diff --git a/mysql-test/suite/galera/t/galera_locks_funcs.test b/mysql-test/suite/galera/t/galera_locks_funcs.test index 68737f2daab..42838e9585c 100644 --- a/mysql-test/suite/galera/t/galera_locks_funcs.test +++ b/mysql-test/suite/galera/t/galera_locks_funcs.test @@ -9,6 +9,10 @@ SELECT * FROM t; --error ER_NOT_SUPPORTED_YET SELECT RELEASE_LOCK('a'); SHOW WARNINGS; +# New in 10.5 +--error ER_NOT_SUPPORTED_YET +SELECT RELEASE_ALL_LOCKS(); +SHOW WARNINGS; COMMIT; DROP TABLE t; diff --git a/sql/item_create.cc b/sql/item_create.cc index 81621253cd5..5363a3407ab 100644 --- a/sql/item_create.cc +++ b/sql/item_create.cc @@ -4843,6 +4843,13 @@ Create_func_release_all_locks Create_func_release_all_locks::s_singleton; Item* Create_func_release_all_locks::create_builder(THD *thd) { +#ifdef WITH_WSREP + if (WSREP_ON && WSREP(thd)) + { + my_error(ER_NOT_SUPPORTED_YET, MYF(0), "RELEASE_ALL_LOCKS in cluster (WSREP_ON=ON)"); + return NULL; + } +#endif /* WITH_WSREP */ thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION); thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); return new (thd->mem_root) Item_func_release_all_locks(thd); -- cgit v1.2.1 From b05218e08f45a17f46d1b73cbb9dcb2969dc04cd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Lindstr=C3=B6m?= Date: Mon, 30 Jan 2023 08:55:35 +0200 Subject: MDEV-30473 : Do not allow GET_LOCK() / RELEASE_LOCK() in cluster Following tests do not test anymore what they intended to test deleted: suite/galera/t/MDEV-24143.test deleted: suite/galera/t/galera_bf_abort_get_lock.test --- mysql-test/suite/galera/r/MDEV-24143.result | 23 -------------- .../suite/galera/r/galera_bf_abort_get_lock.result | 18 ----------- mysql-test/suite/galera/t/MDEV-24143.test | 20 ------------ .../suite/galera/t/galera_bf_abort_get_lock.test | 36 ---------------------- 4 files changed, 97 deletions(-) delete mode 100644 mysql-test/suite/galera/r/MDEV-24143.result delete mode 100644 mysql-test/suite/galera/r/galera_bf_abort_get_lock.result delete mode 100644 mysql-test/suite/galera/t/MDEV-24143.test delete mode 100644 mysql-test/suite/galera/t/galera_bf_abort_get_lock.test diff --git a/mysql-test/suite/galera/r/MDEV-24143.result b/mysql-test/suite/galera/r/MDEV-24143.result deleted file mode 100644 index 860d8a35834..00000000000 --- a/mysql-test/suite/galera/r/MDEV-24143.result +++ /dev/null @@ -1,23 +0,0 @@ -connection node_2; -connection node_1; -CREATE TABLE t1 (c1 BIGINT NOT NULL PRIMARY KEY, c2 BINARY (10), c3 DATETIME); -SELECT get_lock ('test2', 0); -get_lock ('test2', 0) -1 -DROP TABLE t1; -CREATE TABLE t1 (c1 SMALLINT NOT NULL AUTO_INCREMENT PRIMARY KEY); -INSERT INTO t1 VALUES (1); -SET SESSION wsrep_trx_fragment_size=10; -SET SESSION autocommit=0; -SELECT * FROM t1 WHERE c1 <=0 ORDER BY c1 DESC; -c1 -INSERT INTO t1 VALUES (4),(3),(1),(2); -ERROR 40001: Deadlock found when trying to get lock; try restarting transaction -CREATE TABLE t1 (pk INT PRIMARY KEY, b INT) ENGINE=SEQUENCE; -ERROR 42S01: Table 't1' already exists -ALTER TABLE t1 DROP COLUMN c2; -ERROR 42000: Can't DROP COLUMN `c2`; check that it exists -SELECT get_lock ('test', 1.5); -get_lock ('test', 1.5) -1 -DROP TABLE t1; diff --git a/mysql-test/suite/galera/r/galera_bf_abort_get_lock.result b/mysql-test/suite/galera/r/galera_bf_abort_get_lock.result deleted file mode 100644 index 0ef2a1a72c6..00000000000 --- a/mysql-test/suite/galera/r/galera_bf_abort_get_lock.result +++ /dev/null @@ -1,18 +0,0 @@ -connection node_2; -connection node_1; -CREATE TABLE t1 (f1 INTEGER PRIMARY KEY) ENGINE=InnoDB; -connection node_2a; -SELECT GET_LOCK("foo", 1000); -GET_LOCK("foo", 1000) -1 -connection node_2; -SET AUTOCOMMIT=OFF; -INSERT INTO t1 VALUES (1); -SELECT GET_LOCK("foo", 1000);; -connection node_1; -INSERT INTO t1 VALUES (1); -connection node_2; -ERROR 40001: Deadlock found when trying to get lock; try restarting transaction -wsrep_local_aborts_increment -1 -DROP TABLE t1; diff --git a/mysql-test/suite/galera/t/MDEV-24143.test b/mysql-test/suite/galera/t/MDEV-24143.test deleted file mode 100644 index e58f147cb7c..00000000000 --- a/mysql-test/suite/galera/t/MDEV-24143.test +++ /dev/null @@ -1,20 +0,0 @@ ---source include/galera_cluster.inc ---source include/have_sequence.inc - -CREATE TABLE t1 (c1 BIGINT NOT NULL PRIMARY KEY, c2 BINARY (10), c3 DATETIME); -SELECT get_lock ('test2', 0); -DROP TABLE t1; -CREATE TABLE t1 (c1 SMALLINT NOT NULL AUTO_INCREMENT PRIMARY KEY); -INSERT INTO t1 VALUES (1); -SET SESSION wsrep_trx_fragment_size=10; -SET SESSION autocommit=0; -SELECT * FROM t1 WHERE c1 <=0 ORDER BY c1 DESC; ---error ER_LOCK_DEADLOCK -INSERT INTO t1 VALUES (4),(3),(1),(2); ---error ER_TABLE_EXISTS_ERROR -CREATE TABLE t1 (pk INT PRIMARY KEY, b INT) ENGINE=SEQUENCE; ---error ER_CANT_DROP_FIELD_OR_KEY -ALTER TABLE t1 DROP COLUMN c2; -SELECT get_lock ('test', 1.5); -DROP TABLE t1; - diff --git a/mysql-test/suite/galera/t/galera_bf_abort_get_lock.test b/mysql-test/suite/galera/t/galera_bf_abort_get_lock.test deleted file mode 100644 index 72fc1c5b583..00000000000 --- a/mysql-test/suite/galera/t/galera_bf_abort_get_lock.test +++ /dev/null @@ -1,36 +0,0 @@ ---source include/galera_cluster.inc ---source include/have_innodb.inc - -# -# Test a local transaction being aborted by a slave one while it is running a GET_LOCK() -# - -CREATE TABLE t1 (f1 INTEGER PRIMARY KEY) ENGINE=InnoDB; - ---let $galera_connection_name = node_2a ---let $galera_server_number = 2 ---source include/galera_connect.inc ---connection node_2a -SELECT GET_LOCK("foo", 1000); - ---connection node_2 -SET AUTOCOMMIT=OFF; ---let $wsrep_local_bf_aborts_before = `SELECT VARIABLE_VALUE FROM INFORMATION_SCHEMA.GLOBAL_STATUS WHERE VARIABLE_NAME = 'wsrep_local_bf_aborts'` -INSERT INTO t1 VALUES (1); ---send SELECT GET_LOCK("foo", 1000); - ---connection node_1 -INSERT INTO t1 VALUES (1); - ---connection node_2 ---error ER_LOCK_DEADLOCK ---reap - ---let $wsrep_local_bf_aborts_after = `SELECT VARIABLE_VALUE FROM INFORMATION_SCHEMA.GLOBAL_STATUS WHERE VARIABLE_NAME = 'wsrep_local_bf_aborts'` - -# Check that wsrep_local_bf_aborts has been incremented by exactly 1 ---disable_query_log ---eval SELECT $wsrep_local_bf_aborts_after - $wsrep_local_bf_aborts_before = 1 AS wsrep_local_aborts_increment; ---enable_query_log - -DROP TABLE t1; -- cgit v1.2.1 From 0e737f78980fcfe83b05c27215eb3f5ede1ea473 Mon Sep 17 00:00:00 2001 From: Anel Husakovic Date: Tue, 20 Dec 2022 14:25:21 +0100 Subject: MDEV-30186 Use of uninitialized value in substitution Reviewer: <> --- mysql-test/mariadb-test-run.pl | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/mysql-test/mariadb-test-run.pl b/mysql-test/mariadb-test-run.pl index 46a51d2fa58..670f63a990f 100755 --- a/mysql-test/mariadb-test-run.pl +++ b/mysql-test/mariadb-test-run.pl @@ -145,6 +145,7 @@ my $opt_start_exit; my $start_only; my $file_wsrep_provider; my $num_saved_cores= 0; # Number of core files saved in vardir/log/ so far. +my $test_name_for_report; our @global_suppressions; @@ -515,13 +516,13 @@ sub main { } if ( not @$completed ) { - my $test_name= mtr_grab_file($path_testlog); - $test_name =~ s/^CURRENT_TEST:\s//; - chomp($test_name); - my $tinfo = My::Test->new(name => $test_name); - $tinfo->{result}= 'MTR_RES_FAILED'; - $tinfo->{comment}=' '; - mtr_report_test($tinfo); + if ($test_name_for_report) + { + my $tinfo = My::Test->new(name => $test_name_for_report); + $tinfo->{result}= 'MTR_RES_FAILED'; + $tinfo->{comment}=' '; + mtr_report_test($tinfo); + } mtr_error("Test suite aborted"); } @@ -3740,8 +3741,8 @@ sub resfile_report_test ($) { sub run_testcase ($$) { my ($tinfo, $server_socket)= @_; my $print_freq=20; - - mtr_verbose("Running test:", $tinfo->{name}); + $test_name_for_report= $tinfo->{name}; + mtr_verbose("Running test:", $test_name_for_report); $ENV{'MTR_TEST_NAME'} = $tinfo->{name}; resfile_report_test($tinfo) if $opt_resfile; @@ -5130,12 +5131,10 @@ sub mysqld_start ($$) { if (!$rc) { # Report failure about the last test case before exit - my $test_name= mtr_grab_file($path_current_testlog); - $test_name =~ s/^CURRENT_TEST:\s//; - my $tinfo = My::Test->new(name => $test_name); + my $tinfo = My::Test->new(name => $test_name_for_report); $tinfo->{result}= 'MTR_RES_FAILED'; $tinfo->{failures}= 1; - $tinfo->{logfile}=get_log_from_proc($mysqld->{'proc'}, $tinfo->{name}); + $tinfo->{logfile}=get_log_from_proc($mysqld->{'proc'}, $test_name_for_report); report_option('verbose', 1); mtr_report_test($tinfo); } -- cgit v1.2.1 From 50b69641ef8bbcbc573e774f2db83a054ca17ad6 Mon Sep 17 00:00:00 2001 From: Alexander Barkov Date: Mon, 14 Nov 2022 16:17:03 +0400 Subject: MDEV-29244 mariabackup --help output still referst to innobackupex Changing the tool name in the "mariadb-backup --help" output from "innobackupex" to "mariadb-backup". --- extra/mariabackup/xtrabackup.cc | 16 ++++++++-------- extra/mariabackup/xtrabackup.h | 2 ++ 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/extra/mariabackup/xtrabackup.cc b/extra/mariabackup/xtrabackup.cc index 2c8b83d3a67..16d65e7a805 100644 --- a/extra/mariabackup/xtrabackup.cc +++ b/extra/mariabackup/xtrabackup.cc @@ -1242,7 +1242,7 @@ struct my_option xb_client_options[]= { {"rsync", OPT_RSYNC, "Uses the rsync utility to optimize local file " - "transfers. When this option is specified, innobackupex uses rsync " + "transfers. When this option is specified, " XB_TOOL_NAME " uses rsync " "to copy all non-InnoDB files instead of spawning a separate cp for " "each file, which can be much faster for servers with a large number " "of databases or tables. This option cannot be used together with " @@ -1350,7 +1350,7 @@ struct my_option xb_client_options[]= { {"ftwrl-wait-query-type", OPT_LOCK_WAIT_QUERY_TYPE, "This option specifies which types of queries are allowed to complete " - "before innobackupex will issue the global lock. Default is all.", + "before " XB_TOOL_NAME " will issue the global lock. Default is all.", (uchar *) &opt_lock_wait_query_type, (uchar *) &opt_lock_wait_query_type, &query_type_typelib, GET_ENUM, REQUIRED_ARG, QUERY_TYPE_ALL, 0, 0, 0, 0, 0}, @@ -1370,26 +1370,26 @@ struct my_option xb_client_options[]= { NULL, NULL, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0}, {"kill-long-queries-timeout", OPT_KILL_LONG_QUERIES_TIMEOUT, - "This option specifies the number of seconds innobackupex waits " + "This option specifies the number of seconds " XB_TOOL_NAME " waits " "between starting FLUSH TABLES WITH READ LOCK and killing those " "queries that block it. Default is 0 seconds, which means " - "innobackupex will not attempt to kill any queries.", + XB_TOOL_NAME " will not attempt to kill any queries.", (uchar *) &opt_kill_long_queries_timeout, (uchar *) &opt_kill_long_queries_timeout, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0}, {"ftwrl-wait-timeout", OPT_LOCK_WAIT_TIMEOUT, - "This option specifies time in seconds that innobackupex should wait " + "This option specifies time in seconds that " XB_TOOL_NAME " should wait " "for queries that would block FTWRL before running it. If there are " - "still such queries when the timeout expires, innobackupex terminates " - "with an error. Default is 0, in which case innobackupex does not " + "still such queries when the timeout expires, " XB_TOOL_NAME " terminates " + "with an error. Default is 0, in which case " XB_TOOL_NAME " does not " "wait for queries to complete and starts FTWRL immediately.", (uchar *) &opt_lock_wait_timeout, (uchar *) &opt_lock_wait_timeout, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0}, {"ftwrl-wait-threshold", OPT_LOCK_WAIT_THRESHOLD, "This option specifies the query run time threshold which is used by " - "innobackupex to detect long-running queries with a non-zero value " + XB_TOOL_NAME " to detect long-running queries with a non-zero value " "of --ftwrl-wait-timeout. FTWRL is not started until such " "long-running queries exist. This option has no effect if " "--ftwrl-wait-timeout is 0. Default value is 60 seconds.", diff --git a/extra/mariabackup/xtrabackup.h b/extra/mariabackup/xtrabackup.h index 0d1d3eb5a6b..394ea9ed87c 100644 --- a/extra/mariabackup/xtrabackup.h +++ b/extra/mariabackup/xtrabackup.h @@ -27,6 +27,8 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA #include "changed_page_bitmap.h" #include +#define XB_TOOL_NAME "mariadb-backup" + struct xb_delta_info_t { xb_delta_info_t(ulint page_size, ulint zip_size, ulint space_id) -- cgit v1.2.1 From 4a04c18af907229ea609545d6bb0ea76f682a86f Mon Sep 17 00:00:00 2001 From: Alexander Barkov Date: Mon, 14 Nov 2022 16:43:33 +0400 Subject: MDEV-25765 Mariabackup reduced verbosity option for log output --- extra/mariabackup/xtrabackup.cc | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/extra/mariabackup/xtrabackup.cc b/extra/mariabackup/xtrabackup.cc index 16d65e7a805..6d63775ce5b 100644 --- a/extra/mariabackup/xtrabackup.cc +++ b/extra/mariabackup/xtrabackup.cc @@ -2999,7 +2999,9 @@ static bool xtrabackup_copy_logfile(bool last = false) ut_ad(start_lsn == log_sys.log.scanned_lsn); - msg(">> log scanned up to (" LSN_PF ")", start_lsn); + if (verbose) { + msg(">> log scanned up to (" LSN_PF ")", start_lsn); + } /* update global variable*/ pthread_mutex_lock(&backup_mutex); -- cgit v1.2.1 From b482e87f26972506cc4a79317d0f9339586506ed Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vicen=C8=9Biu=20Ciorbaru?= Date: Tue, 28 Sep 2021 22:14:36 +0300 Subject: Silence gcc-11 warnings --- storage/connect/bsonudf.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/storage/connect/bsonudf.cpp b/storage/connect/bsonudf.cpp index 618c0168470..e86ddd7c1b7 100644 --- a/storage/connect/bsonudf.cpp +++ b/storage/connect/bsonudf.cpp @@ -3571,7 +3571,7 @@ char *bson_item_merge(UDF_INIT *initid, UDF_ARGS *args, char *result, } // endif Xchk if (!CheckMemory(g, initid, args, 2, false, false, true)) { - JTYP type; + JTYP type= TYPE_JAR; BJNX bnx(g); PBVAL jvp = NULL, top = NULL; PBVAL jsp[2] = {NULL, NULL}; @@ -5722,7 +5722,7 @@ char *bbin_item_merge(UDF_INIT *initid, UDF_ARGS *args, char *result, } // endif Xchk if (!CheckMemory(g, initid, args, 2, false, false, true)) { - JTYP type; + JTYP type = TYPE_JAR; BJNX bnx(g); PBVAL jvp = NULL, top = NULL; PBVAL jsp[2] = {NULL, NULL}; -- cgit v1.2.1 From cc08872c16004a95f8a705e1d47c500f83e3152c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vicen=C8=9Biu=20Ciorbaru?= Date: Tue, 28 Sep 2021 22:29:23 +0300 Subject: Initialize the Hash_set during creation If the Hash_set is not initialized, one can not call find() on it before at least one element has been inserted into it. --- sql/sql_hset.h | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/sql/sql_hset.h b/sql/sql_hset.h index b3d8165f6f6..065a3181bec 100644 --- a/sql/sql_hset.h +++ b/sql/sql_hset.h @@ -28,17 +28,15 @@ class Hash_set public: enum { START_SIZE= 8 }; /** - Constructs an empty hash. Does not allocate memory, it is done upon - the first insert. Thus does not cause or return errors. + Constructs an empty unique hash. */ Hash_set(PSI_memory_key psi_key, uchar *(*K)(const T *, size_t *, my_bool), CHARSET_INFO *cs= &my_charset_bin) { - my_hash_clear(&m_hash); - m_hash.get_key= (my_hash_get_key)K; - m_hash.charset= cs; - m_hash.array.m_psi_key= psi_key; + my_hash_init(psi_key, &m_hash, cs, START_SIZE, 0, 0, (my_hash_get_key)K, 0, + HASH_UNIQUE); } + Hash_set(PSI_memory_key psi_key, CHARSET_INFO *charset, ulong default_array_elements, size_t key_offset, size_t key_length, my_hash_get_key get_key, void (*free_element)(void*), uint flags) @@ -65,8 +63,6 @@ public: */ bool insert(T *value) { - my_hash_init_opt(m_hash.array.m_psi_key, &m_hash, m_hash.charset, - START_SIZE, 0, 0, m_hash.get_key, 0, HASH_UNIQUE); return my_hash_insert(&m_hash, reinterpret_cast(value)); } bool remove(T *value) -- cgit v1.2.1 From 0845bce0d95fcb7a3b21e17864901d888d276dcb Mon Sep 17 00:00:00 2001 From: Alexander Barkov Date: Fri, 3 Feb 2023 16:57:53 +0400 Subject: MDEV-30556 UPPER() returns an empty string for U+0251 in Unicode-5.2.0+ collations for utf8 --- mysql-test/include/ctype_casefolding.inc | 18 ++++ mysql-test/main/ctype_ldml.result | 45 ++++++++ mysql-test/main/ctype_ldml.test | 21 ++++ mysql-test/main/ctype_uca.result | 8 +- mysql-test/main/ctype_utf8_uca.result | 174 +++++++++++++++++++++++++++++++ mysql-test/main/ctype_utf8_uca.test | 29 ++++++ mysql-test/main/ctype_utf8mb4_uca.result | 174 +++++++++++++++++++++++++++++++ mysql-test/main/ctype_utf8mb4_uca.test | 29 ++++++ mysys/charset.c | 2 + strings/ctype-uca.c | 37 ++++--- 10 files changed, 517 insertions(+), 20 deletions(-) create mode 100644 mysql-test/include/ctype_casefolding.inc diff --git a/mysql-test/include/ctype_casefolding.inc b/mysql-test/include/ctype_casefolding.inc new file mode 100644 index 00000000000..4ee402c95ad --- /dev/null +++ b/mysql-test/include/ctype_casefolding.inc @@ -0,0 +1,18 @@ +CREATE OR REPLACE TABLE case_folding AS SELECT 0 AS code, SPACE(32) AS c LIMIT 0; +SHOW CREATE TABLE case_folding; +# Uncode code points that have a variable length case mapping in utf8 +# (e.g. LOWER('2-byte-character') -> '3-byte-character' +INSERT INTO case_folding (code) VALUES +(0x23A), +(0x23E), +(0x23F), +(0x240), +(0x250), +(0x251), +(0x252), +(0x26B), +(0x271), +(0x27D); +UPDATE case_folding SET c=CHAR(code USING ucs2); +SELECT HEX(code), HEX(LOWER(c)), HEX(UPPER(c)), c FROM case_folding; +DROP TABLE case_folding; diff --git a/mysql-test/main/ctype_ldml.result b/mysql-test/main/ctype_ldml.result index 3ce50331ed0..ac1d66f3c91 100644 --- a/mysql-test/main/ctype_ldml.result +++ b/mysql-test/main/ctype_ldml.result @@ -3034,3 +3034,48 @@ SELECT 'chž'< 'i'; 1 SELECT 'a' COLLATE utf8_czech_test_bad_w2; ERROR HY000: Unknown collation: 'utf8_czech_test_bad_w2' +# +# End of 10.2 tests +# +# +# Start of 10.3 tests +# +# +# MDEV-30556 UPPER() returns an empty string for U+0251 in Unicode-5.2.0+ collations for utf8 +# +SET NAMES utf8mb4 COLLATE utf8mb4_test_520_nopad_ci; +CREATE OR REPLACE TABLE case_folding AS SELECT 0 AS code, SPACE(32) AS c LIMIT 0; +SHOW CREATE TABLE case_folding; +Table Create Table +case_folding CREATE TABLE `case_folding` ( + `code` int(1) NOT NULL, + `c` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_test_520_nopad_ci DEFAULT NULL +) ENGINE=MyISAM DEFAULT CHARSET=latin1 COLLATE=latin1_swedish_ci +INSERT INTO case_folding (code) VALUES +(0x23A), +(0x23E), +(0x23F), +(0x240), +(0x250), +(0x251), +(0x252), +(0x26B), +(0x271), +(0x27D); +UPDATE case_folding SET c=CHAR(code USING ucs2); +SELECT HEX(code), HEX(LOWER(c)), HEX(UPPER(c)), c FROM case_folding; +HEX(code) HEX(LOWER(c)) HEX(UPPER(c)) c +23A E2B1A5 C8BA Ⱥ +23E E2B1A6 C8BE Ⱦ +23F C8BF E2B1BE ȿ +240 C980 E2B1BF ɀ +250 C990 E2B1AF ɐ +251 C991 E2B1AD ɑ +252 C992 E2B1B0 ɒ +26B C9AB E2B1A2 ɫ +271 C9B1 E2B1AE ɱ +27D C9BD E2B1A4 ɽ +DROP TABLE case_folding; +# +# End of 10.3 tests +# diff --git a/mysql-test/main/ctype_ldml.test b/mysql-test/main/ctype_ldml.test index 68891646c0f..368e26dba20 100644 --- a/mysql-test/main/ctype_ldml.test +++ b/mysql-test/main/ctype_ldml.test @@ -605,3 +605,24 @@ SELECT 'chž'< 'i'; --error ER_UNKNOWN_COLLATION SELECT 'a' COLLATE utf8_czech_test_bad_w2; + +--echo # +--echo # End of 10.2 tests +--echo # + + +--echo # +--echo # Start of 10.3 tests +--echo # + +--echo # +--echo # MDEV-30556 UPPER() returns an empty string for U+0251 in Unicode-5.2.0+ collations for utf8 +--echo # + +SET NAMES utf8mb4 COLLATE utf8mb4_test_520_nopad_ci; +--source include/ctype_casefolding.inc + + +--echo # +--echo # End of 10.3 tests +--echo # diff --git a/mysql-test/main/ctype_uca.result b/mysql-test/main/ctype_uca.result index af2798f12f3..2298733851d 100644 --- a/mysql-test/main/ctype_uca.result +++ b/mysql-test/main/ctype_uca.result @@ -8204,7 +8204,7 @@ INSERT INTO t1 VALUES (_utf32 0x2CEE); SELECT hex(c), hex(lower(c)), hex(upper(c)), hex(weight_string(c)), c FROM t1 ORDER BY c, BINARY c; hex(c) hex(lower(c)) hex(upper(c)) hex(weight_string(c)) c -C8BA C8BA 1214 Ⱥ +C8BA E2B1A5 C8BA 1214 Ⱥ E2B1A5 E2B1A5 C8BA 1214 ⱥ C680 C680 C983 122D ƀ C983 C680 C983 122D Ƀ @@ -8229,7 +8229,7 @@ E2B1AA E2B1AA E2B1A9 1328 ⱪ C8BD C69A C8BD 133B Ƚ E2B1A0 E2B1A1 E2B1A0 133F Ⱡ E2B1A1 E2B1A1 E2B1A0 133F ⱡ -C9AB C9AB 1340 ɫ +C9AB C9AB E2B1A2 1340 ɫ E2B1A2 C9AB E2B1A2 1340 Ɫ E1B5BD E1B5BD E2B1A3 13B8 ᵽ E2B1A3 E1B5BD E2B1A3 13B8 Ᵽ @@ -8237,11 +8237,11 @@ C98A C98B C98A 13D2 Ɋ C98B C98B C98A 13D2 ɋ C98C C98D C98C 13E4 Ɍ C98D C98D C98C 13E4 ɍ -C9BD C9BD 13FC ɽ +C9BD C9BD E2B1A4 13FC ɽ E2B1A4 C9BD E2B1A4 13FC Ɽ EA9CA8 EA9CA9 EA9CA8 143314AD Ꜩ EA9CA9 EA9CA9 EA9CA8 143314AD ꜩ -C8BE C8BE 143C Ⱦ +C8BE E2B1A6 C8BE 143C Ⱦ E2B1A6 E2B1A6 C8BE 143C ⱦ C984 CA89 C984 145B Ʉ CA89 CA89 C984 145B ʉ diff --git a/mysql-test/main/ctype_utf8_uca.result b/mysql-test/main/ctype_utf8_uca.result index a6e1616997f..bf4e5ed2fd8 100644 --- a/mysql-test/main/ctype_utf8_uca.result +++ b/mysql-test/main/ctype_utf8_uca.result @@ -587,3 +587,177 @@ DROP TABLE t1; # # End of 10.2 tests # +# +# Start of 10.3 tests +# +# +# MDEV-30556 UPPER() returns an empty string for U+0251 in Unicode-5.2.0+ collations for utf8 +# +SET NAMES utf8mb3 COLLATE utf8mb3_unicode_ci /*Unicode-4.0 folding*/; +CREATE OR REPLACE TABLE case_folding AS SELECT 0 AS code, SPACE(32) AS c LIMIT 0; +SHOW CREATE TABLE case_folding; +Table Create Table +case_folding CREATE TABLE `case_folding` ( + `code` int(1) NOT NULL, + `c` varchar(32) CHARACTER SET utf8 COLLATE utf8_unicode_ci DEFAULT NULL +) ENGINE=MyISAM DEFAULT CHARSET=latin1 COLLATE=latin1_swedish_ci +INSERT INTO case_folding (code) VALUES +(0x23A), +(0x23E), +(0x23F), +(0x240), +(0x250), +(0x251), +(0x252), +(0x26B), +(0x271), +(0x27D); +UPDATE case_folding SET c=CHAR(code USING ucs2); +SELECT HEX(code), HEX(LOWER(c)), HEX(UPPER(c)), c FROM case_folding; +HEX(code) HEX(LOWER(c)) HEX(UPPER(c)) c +23A C8BA C8BA Ⱥ +23E C8BE C8BE Ⱦ +23F C8BF C8BF ȿ +240 C980 C980 ɀ +250 C990 C990 ɐ +251 C991 C991 ɑ +252 C992 C992 ɒ +26B C9AB C9AB ɫ +271 C9B1 C9B1 ɱ +27D C9BD C9BD ɽ +DROP TABLE case_folding; +SET NAMES utf8mb3 COLLATE utf8mb3_unicode_520_ci; +CREATE OR REPLACE TABLE case_folding AS SELECT 0 AS code, SPACE(32) AS c LIMIT 0; +SHOW CREATE TABLE case_folding; +Table Create Table +case_folding CREATE TABLE `case_folding` ( + `code` int(1) NOT NULL, + `c` varchar(32) CHARACTER SET utf8 COLLATE utf8_unicode_520_ci DEFAULT NULL +) ENGINE=MyISAM DEFAULT CHARSET=latin1 COLLATE=latin1_swedish_ci +INSERT INTO case_folding (code) VALUES +(0x23A), +(0x23E), +(0x23F), +(0x240), +(0x250), +(0x251), +(0x252), +(0x26B), +(0x271), +(0x27D); +UPDATE case_folding SET c=CHAR(code USING ucs2); +SELECT HEX(code), HEX(LOWER(c)), HEX(UPPER(c)), c FROM case_folding; +HEX(code) HEX(LOWER(c)) HEX(UPPER(c)) c +23A E2B1A5 C8BA Ⱥ +23E E2B1A6 C8BE Ⱦ +23F C8BF E2B1BE ȿ +240 C980 E2B1BF ɀ +250 C990 E2B1AF ɐ +251 C991 E2B1AD ɑ +252 C992 E2B1B0 ɒ +26B C9AB E2B1A2 ɫ +271 C9B1 E2B1AE ɱ +27D C9BD E2B1A4 ɽ +DROP TABLE case_folding; +SET NAMES utf8mb3 COLLATE utf8mb3_unicode_520_nopad_ci; +CREATE OR REPLACE TABLE case_folding AS SELECT 0 AS code, SPACE(32) AS c LIMIT 0; +SHOW CREATE TABLE case_folding; +Table Create Table +case_folding CREATE TABLE `case_folding` ( + `code` int(1) NOT NULL, + `c` varchar(32) CHARACTER SET utf8 COLLATE utf8_unicode_520_nopad_ci DEFAULT NULL +) ENGINE=MyISAM DEFAULT CHARSET=latin1 COLLATE=latin1_swedish_ci +INSERT INTO case_folding (code) VALUES +(0x23A), +(0x23E), +(0x23F), +(0x240), +(0x250), +(0x251), +(0x252), +(0x26B), +(0x271), +(0x27D); +UPDATE case_folding SET c=CHAR(code USING ucs2); +SELECT HEX(code), HEX(LOWER(c)), HEX(UPPER(c)), c FROM case_folding; +HEX(code) HEX(LOWER(c)) HEX(UPPER(c)) c +23A E2B1A5 C8BA Ⱥ +23E E2B1A6 C8BE Ⱦ +23F C8BF E2B1BE ȿ +240 C980 E2B1BF ɀ +250 C990 E2B1AF ɐ +251 C991 E2B1AD ɑ +252 C992 E2B1B0 ɒ +26B C9AB E2B1A2 ɫ +271 C9B1 E2B1AE ɱ +27D C9BD E2B1A4 ɽ +DROP TABLE case_folding; +SET NAMES utf8mb3 COLLATE utf8mb3_myanmar_ci; +CREATE OR REPLACE TABLE case_folding AS SELECT 0 AS code, SPACE(32) AS c LIMIT 0; +SHOW CREATE TABLE case_folding; +Table Create Table +case_folding CREATE TABLE `case_folding` ( + `code` int(1) NOT NULL, + `c` varchar(32) CHARACTER SET utf8 COLLATE utf8_myanmar_ci DEFAULT NULL +) ENGINE=MyISAM DEFAULT CHARSET=latin1 COLLATE=latin1_swedish_ci +INSERT INTO case_folding (code) VALUES +(0x23A), +(0x23E), +(0x23F), +(0x240), +(0x250), +(0x251), +(0x252), +(0x26B), +(0x271), +(0x27D); +UPDATE case_folding SET c=CHAR(code USING ucs2); +SELECT HEX(code), HEX(LOWER(c)), HEX(UPPER(c)), c FROM case_folding; +HEX(code) HEX(LOWER(c)) HEX(UPPER(c)) c +23A E2B1A5 C8BA Ⱥ +23E E2B1A6 C8BE Ⱦ +23F C8BF E2B1BE ȿ +240 C980 E2B1BF ɀ +250 C990 E2B1AF ɐ +251 C991 E2B1AD ɑ +252 C992 E2B1B0 ɒ +26B C9AB E2B1A2 ɫ +271 C9B1 E2B1AE ɱ +27D C9BD E2B1A4 ɽ +DROP TABLE case_folding; +SET NAMES utf8mb3 COLLATE utf8mb3_thai_520_w2; +CREATE OR REPLACE TABLE case_folding AS SELECT 0 AS code, SPACE(32) AS c LIMIT 0; +SHOW CREATE TABLE case_folding; +Table Create Table +case_folding CREATE TABLE `case_folding` ( + `code` int(1) NOT NULL, + `c` varchar(32) CHARACTER SET utf8 COLLATE utf8_thai_520_w2 DEFAULT NULL +) ENGINE=MyISAM DEFAULT CHARSET=latin1 COLLATE=latin1_swedish_ci +INSERT INTO case_folding (code) VALUES +(0x23A), +(0x23E), +(0x23F), +(0x240), +(0x250), +(0x251), +(0x252), +(0x26B), +(0x271), +(0x27D); +UPDATE case_folding SET c=CHAR(code USING ucs2); +SELECT HEX(code), HEX(LOWER(c)), HEX(UPPER(c)), c FROM case_folding; +HEX(code) HEX(LOWER(c)) HEX(UPPER(c)) c +23A E2B1A5 C8BA Ⱥ +23E E2B1A6 C8BE Ⱦ +23F C8BF E2B1BE ȿ +240 C980 E2B1BF ɀ +250 C990 E2B1AF ɐ +251 C991 E2B1AD ɑ +252 C992 E2B1B0 ɒ +26B C9AB E2B1A2 ɫ +271 C9B1 E2B1AE ɱ +27D C9BD E2B1A4 ɽ +DROP TABLE case_folding; +# +# End of 10.3 tests +# diff --git a/mysql-test/main/ctype_utf8_uca.test b/mysql-test/main/ctype_utf8_uca.test index 0879b4d2810..38bcce8f4ba 100644 --- a/mysql-test/main/ctype_utf8_uca.test +++ b/mysql-test/main/ctype_utf8_uca.test @@ -21,3 +21,32 @@ SET NAMES utf8 COLLATE utf8_unicode_nopad_ci; --echo # --echo # End of 10.2 tests --echo # + + +--echo # +--echo # Start of 10.3 tests +--echo # + +--echo # +--echo # MDEV-30556 UPPER() returns an empty string for U+0251 in Unicode-5.2.0+ collations for utf8 +--echo # + +SET NAMES utf8mb3 COLLATE utf8mb3_unicode_ci /*Unicode-4.0 folding*/; +--source include/ctype_casefolding.inc + +SET NAMES utf8mb3 COLLATE utf8mb3_unicode_520_ci; +--source include/ctype_casefolding.inc + +SET NAMES utf8mb3 COLLATE utf8mb3_unicode_520_nopad_ci; +--source include/ctype_casefolding.inc + +SET NAMES utf8mb3 COLLATE utf8mb3_myanmar_ci; +--source include/ctype_casefolding.inc + +SET NAMES utf8mb3 COLLATE utf8mb3_thai_520_w2; +--source include/ctype_casefolding.inc + + +--echo # +--echo # End of 10.3 tests +--echo # diff --git a/mysql-test/main/ctype_utf8mb4_uca.result b/mysql-test/main/ctype_utf8mb4_uca.result index 8d2e81d8d89..d0a63d0dd36 100644 --- a/mysql-test/main/ctype_utf8mb4_uca.result +++ b/mysql-test/main/ctype_utf8mb4_uca.result @@ -6605,3 +6605,177 @@ SET NAMES utf8mb4; # # End of 10.2 tests # +# +# Start of 10.3 tests +# +# +# MDEV-30556 UPPER() returns an empty string for U+0251 in Unicode-5.2.0+ collations for utf8 +# +SET NAMES utf8mb4 COLLATE utf8mb4_unicode_ci /*Unicode-4.0 folding*/; +CREATE OR REPLACE TABLE case_folding AS SELECT 0 AS code, SPACE(32) AS c LIMIT 0; +SHOW CREATE TABLE case_folding; +Table Create Table +case_folding CREATE TABLE `case_folding` ( + `code` int(1) NOT NULL, + `c` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL +) ENGINE=MyISAM DEFAULT CHARSET=latin1 COLLATE=latin1_swedish_ci +INSERT INTO case_folding (code) VALUES +(0x23A), +(0x23E), +(0x23F), +(0x240), +(0x250), +(0x251), +(0x252), +(0x26B), +(0x271), +(0x27D); +UPDATE case_folding SET c=CHAR(code USING ucs2); +SELECT HEX(code), HEX(LOWER(c)), HEX(UPPER(c)), c FROM case_folding; +HEX(code) HEX(LOWER(c)) HEX(UPPER(c)) c +23A C8BA C8BA Ⱥ +23E C8BE C8BE Ⱦ +23F C8BF C8BF ȿ +240 C980 C980 ɀ +250 C990 C990 ɐ +251 C991 C991 ɑ +252 C992 C992 ɒ +26B C9AB C9AB ɫ +271 C9B1 C9B1 ɱ +27D C9BD C9BD ɽ +DROP TABLE case_folding; +SET NAMES utf8mb4 COLLATE utf8mb4_unicode_520_ci; +CREATE OR REPLACE TABLE case_folding AS SELECT 0 AS code, SPACE(32) AS c LIMIT 0; +SHOW CREATE TABLE case_folding; +Table Create Table +case_folding CREATE TABLE `case_folding` ( + `code` int(1) NOT NULL, + `c` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_520_ci DEFAULT NULL +) ENGINE=MyISAM DEFAULT CHARSET=latin1 COLLATE=latin1_swedish_ci +INSERT INTO case_folding (code) VALUES +(0x23A), +(0x23E), +(0x23F), +(0x240), +(0x250), +(0x251), +(0x252), +(0x26B), +(0x271), +(0x27D); +UPDATE case_folding SET c=CHAR(code USING ucs2); +SELECT HEX(code), HEX(LOWER(c)), HEX(UPPER(c)), c FROM case_folding; +HEX(code) HEX(LOWER(c)) HEX(UPPER(c)) c +23A E2B1A5 C8BA Ⱥ +23E E2B1A6 C8BE Ⱦ +23F C8BF E2B1BE ȿ +240 C980 E2B1BF ɀ +250 C990 E2B1AF ɐ +251 C991 E2B1AD ɑ +252 C992 E2B1B0 ɒ +26B C9AB E2B1A2 ɫ +271 C9B1 E2B1AE ɱ +27D C9BD E2B1A4 ɽ +DROP TABLE case_folding; +SET NAMES utf8mb4 COLLATE utf8mb4_unicode_520_nopad_ci; +CREATE OR REPLACE TABLE case_folding AS SELECT 0 AS code, SPACE(32) AS c LIMIT 0; +SHOW CREATE TABLE case_folding; +Table Create Table +case_folding CREATE TABLE `case_folding` ( + `code` int(1) NOT NULL, + `c` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_520_nopad_ci DEFAULT NULL +) ENGINE=MyISAM DEFAULT CHARSET=latin1 COLLATE=latin1_swedish_ci +INSERT INTO case_folding (code) VALUES +(0x23A), +(0x23E), +(0x23F), +(0x240), +(0x250), +(0x251), +(0x252), +(0x26B), +(0x271), +(0x27D); +UPDATE case_folding SET c=CHAR(code USING ucs2); +SELECT HEX(code), HEX(LOWER(c)), HEX(UPPER(c)), c FROM case_folding; +HEX(code) HEX(LOWER(c)) HEX(UPPER(c)) c +23A E2B1A5 C8BA Ⱥ +23E E2B1A6 C8BE Ⱦ +23F C8BF E2B1BE ȿ +240 C980 E2B1BF ɀ +250 C990 E2B1AF ɐ +251 C991 E2B1AD ɑ +252 C992 E2B1B0 ɒ +26B C9AB E2B1A2 ɫ +271 C9B1 E2B1AE ɱ +27D C9BD E2B1A4 ɽ +DROP TABLE case_folding; +SET NAMES utf8mb4 COLLATE utf8mb4_myanmar_ci; +CREATE OR REPLACE TABLE case_folding AS SELECT 0 AS code, SPACE(32) AS c LIMIT 0; +SHOW CREATE TABLE case_folding; +Table Create Table +case_folding CREATE TABLE `case_folding` ( + `code` int(1) NOT NULL, + `c` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_myanmar_ci DEFAULT NULL +) ENGINE=MyISAM DEFAULT CHARSET=latin1 COLLATE=latin1_swedish_ci +INSERT INTO case_folding (code) VALUES +(0x23A), +(0x23E), +(0x23F), +(0x240), +(0x250), +(0x251), +(0x252), +(0x26B), +(0x271), +(0x27D); +UPDATE case_folding SET c=CHAR(code USING ucs2); +SELECT HEX(code), HEX(LOWER(c)), HEX(UPPER(c)), c FROM case_folding; +HEX(code) HEX(LOWER(c)) HEX(UPPER(c)) c +23A E2B1A5 C8BA Ⱥ +23E E2B1A6 C8BE Ⱦ +23F C8BF E2B1BE ȿ +240 C980 E2B1BF ɀ +250 C990 E2B1AF ɐ +251 C991 E2B1AD ɑ +252 C992 E2B1B0 ɒ +26B C9AB E2B1A2 ɫ +271 C9B1 E2B1AE ɱ +27D C9BD E2B1A4 ɽ +DROP TABLE case_folding; +SET NAMES utf8mb4 COLLATE utf8mb4_thai_520_w2; +CREATE OR REPLACE TABLE case_folding AS SELECT 0 AS code, SPACE(32) AS c LIMIT 0; +SHOW CREATE TABLE case_folding; +Table Create Table +case_folding CREATE TABLE `case_folding` ( + `code` int(1) NOT NULL, + `c` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_thai_520_w2 DEFAULT NULL +) ENGINE=MyISAM DEFAULT CHARSET=latin1 COLLATE=latin1_swedish_ci +INSERT INTO case_folding (code) VALUES +(0x23A), +(0x23E), +(0x23F), +(0x240), +(0x250), +(0x251), +(0x252), +(0x26B), +(0x271), +(0x27D); +UPDATE case_folding SET c=CHAR(code USING ucs2); +SELECT HEX(code), HEX(LOWER(c)), HEX(UPPER(c)), c FROM case_folding; +HEX(code) HEX(LOWER(c)) HEX(UPPER(c)) c +23A E2B1A5 C8BA Ⱥ +23E E2B1A6 C8BE Ⱦ +23F C8BF E2B1BE ȿ +240 C980 E2B1BF ɀ +250 C990 E2B1AF ɐ +251 C991 E2B1AD ɑ +252 C992 E2B1B0 ɒ +26B C9AB E2B1A2 ɫ +271 C9B1 E2B1AE ɱ +27D C9BD E2B1A4 ɽ +DROP TABLE case_folding; +# +# End of 10.3 tests +# diff --git a/mysql-test/main/ctype_utf8mb4_uca.test b/mysql-test/main/ctype_utf8mb4_uca.test index 160cb48bad6..9b532f109d8 100644 --- a/mysql-test/main/ctype_utf8mb4_uca.test +++ b/mysql-test/main/ctype_utf8mb4_uca.test @@ -108,3 +108,32 @@ SET NAMES utf8mb4; --echo # --echo # End of 10.2 tests --echo # + + +--echo # +--echo # Start of 10.3 tests +--echo # + +--echo # +--echo # MDEV-30556 UPPER() returns an empty string for U+0251 in Unicode-5.2.0+ collations for utf8 +--echo # + +SET NAMES utf8mb4 COLLATE utf8mb4_unicode_ci /*Unicode-4.0 folding*/; +--source include/ctype_casefolding.inc + +SET NAMES utf8mb4 COLLATE utf8mb4_unicode_520_ci; +--source include/ctype_casefolding.inc + +SET NAMES utf8mb4 COLLATE utf8mb4_unicode_520_nopad_ci; +--source include/ctype_casefolding.inc + +SET NAMES utf8mb4 COLLATE utf8mb4_myanmar_ci; +--source include/ctype_casefolding.inc + +SET NAMES utf8mb4 COLLATE utf8mb4_thai_520_w2; +--source include/ctype_casefolding.inc + + +--echo # +--echo # End of 10.3 tests +--echo # diff --git a/mysys/charset.c b/mysys/charset.c index f44dc7606c1..c84039b0071 100644 --- a/mysys/charset.c +++ b/mysys/charset.c @@ -368,6 +368,8 @@ static int add_collation(struct charset_info_st *cs) &my_charset_utf8mb4_unicode_ci, cs); newcs->ctype= my_charset_utf8mb4_unicode_ci.ctype; + if (init_state_maps(newcs)) + return MY_XML_ERROR; newcs->state|= MY_CS_AVAILABLE | MY_CS_LOADED; #endif } diff --git a/strings/ctype-uca.c b/strings/ctype-uca.c index fbca4df39e7..969f642b51f 100644 --- a/strings/ctype-uca.c +++ b/strings/ctype-uca.c @@ -33859,6 +33859,11 @@ create_tailoring(struct charset_info_st *cs, { src_uca= &my_uca_v520; cs->caseinfo= &my_unicase_unicode520; + if (cs->mbminlen == 1 && cs->mbmaxlen >=3) + { + cs->caseup_multiply= 2; + cs->casedn_multiply= 2; + } } else if (rules.version == 400) /* Unicode-4.0.0 requested */ { @@ -35692,8 +35697,8 @@ struct charset_info_st my_charset_utf8_myanmar_uca_ci= NULL, /* state_map */ NULL, /* ident_map */ 8, /* strxfrm_multiply */ - 1, /* caseup_multiply */ - 1, /* casedn_multiply */ + 2, /* caseup_multiply */ + 2, /* casedn_multiply */ 1, /* mbminlen */ 3, /* mbmaxlen */ 9, /* min_sort_char */ @@ -35725,8 +35730,8 @@ struct charset_info_st my_charset_utf8_unicode_520_ci= NULL, /* state_map */ NULL, /* ident_map */ 8, /* strxfrm_multiply */ - 1, /* caseup_multiply */ - 1, /* casedn_multiply */ + 2, /* caseup_multiply */ + 2, /* casedn_multiply */ 1, /* mbminlen */ 3, /* mbmaxlen */ 9, /* min_sort_char */ @@ -35757,8 +35762,8 @@ struct charset_info_st my_charset_utf8_thai_520_w2= NULL, /* state_map */ NULL, /* ident_map */ 4, /* strxfrm_multiply */ - 1, /* caseup_multiply */ - 1, /* casedn_multiply */ + 2, /* caseup_multiply */ + 2, /* casedn_multiply */ 1, /* mbminlen */ 3, /* mbmaxlen */ 9, /* min_sort_char */ @@ -35855,8 +35860,8 @@ struct charset_info_st my_charset_utf8_unicode_520_nopad_ci= NULL, /* state_map */ NULL, /* ident_map */ 8, /* strxfrm_multiply */ - 1, /* caseup_multiply */ - 1, /* casedn_multiply */ + 2, /* caseup_multiply */ + 2, /* casedn_multiply */ 1, /* mbminlen */ 3, /* mbmaxlen */ 9, /* min_sort_char */ @@ -36670,8 +36675,8 @@ struct charset_info_st my_charset_utf8mb4_myanmar_uca_ci= NULL, /* state_map */ NULL, /* ident_map */ 8, /* strxfrm_multiply */ - 1, /* caseup_multiply */ - 1, /* casedn_multiply */ + 2, /* caseup_multiply */ + 2, /* casedn_multiply */ 1, /* mbminlen */ 4, /* mbmaxlen */ 9, /* min_sort_char */ @@ -36702,8 +36707,8 @@ struct charset_info_st my_charset_utf8mb4_thai_520_w2= NULL, /* state_map */ NULL, /* ident_map */ 4, /* strxfrm_multiply */ - 1, /* caseup_multiply */ - 1, /* casedn_multiply */ + 2, /* caseup_multiply */ + 2, /* casedn_multiply */ 1, /* mbminlen */ 4, /* mbmaxlen */ 9, /* min_sort_char */ @@ -36734,8 +36739,8 @@ struct charset_info_st my_charset_utf8mb4_unicode_520_ci= NULL, /* state_map */ NULL, /* ident_map */ 8, /* strxfrm_multiply */ - 1, /* caseup_multiply */ - 1, /* casedn_multiply */ + 2, /* caseup_multiply */ + 2, /* casedn_multiply */ 1, /* mbminlen */ 4, /* mbmaxlen */ 9, /* min_sort_char */ @@ -36833,8 +36838,8 @@ struct charset_info_st my_charset_utf8mb4_unicode_520_nopad_ci= NULL, /* state_map */ NULL, /* ident_map */ 8, /* strxfrm_multiply */ - 1, /* caseup_multiply */ - 1, /* casedn_multiply */ + 2, /* caseup_multiply */ + 2, /* casedn_multiply */ 1, /* mbminlen */ 4, /* mbmaxlen */ 9, /* min_sort_char */ -- cgit v1.2.1 From 8885225de66906dc424be8f6ffc4d1b68e54ebca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vicen=C8=9Biu=20Ciorbaru?= Date: Tue, 28 Sep 2021 22:17:59 +0300 Subject: Implement multiple-signal debug_sync The patch is inspired from MySQL. Instead of using a single String to hold the current active debug_sync signal, use a Hash_set to store LEX_STRINGS. This patch ensures that a signal can not be lost, by being overwritten by another thread via set DEBUG_SYNC = '... SIGNAL ...'; All signals are kepts "alive" until they are consumed by a wait event. This requires updating test cases that assume the GLOBAL signal is never consumed. Follow-up work needed: Port the additional syntax that allows one to set multiple signals and also conditionally deactivate signals when waiting. --- mysql-test/main/debug_sync.result | 39 +++--- mysql-test/main/debug_sync.test | 12 +- mysql-test/suite/innodb/r/mdev-14846.result | 3 +- mysql-test/suite/innodb/t/mdev-14846.test | 3 +- .../suite/sys_vars/r/debug_sync_basic.result | 6 +- mysql-test/suite/sys_vars/r/sysvars_debug.result | 2 +- sql/debug_sync.cc | 145 +++++++++++++++++---- 7 files changed, 162 insertions(+), 48 deletions(-) diff --git a/mysql-test/main/debug_sync.result b/mysql-test/main/debug_sync.result index bb9ae1a417d..45cdc40e241 100644 --- a/mysql-test/main/debug_sync.result +++ b/mysql-test/main/debug_sync.result @@ -2,7 +2,7 @@ SET DEBUG_SYNC= 'RESET'; DROP TABLE IF EXISTS t1; SHOW VARIABLES LIKE 'DEBUG_SYNC'; Variable_name Value -debug_sync ON - current signal: '' +debug_sync ON - current signals: '' SET DEBUG_SYNC='p0 SIGNAL s1 WAIT_FOR s2 TIMEOUT 6 EXECUTE 2 HIT_LIMIT 3'; SET DEBUG_SYNC='p0 SIGNAL s1 WAIT_FOR s2 TIMEOUT 6 EXECUTE 2'; SET DEBUG_SYNC='p0 SIGNAL s1 WAIT_FOR s2 TIMEOUT 6 HIT_LIMIT 3'; @@ -150,34 +150,34 @@ SET @myvar= 'now SIGNAL from_myvar'; SET DEBUG_SYNC= @myvar; SHOW VARIABLES LIKE 'DEBUG_SYNC'; Variable_name Value -debug_sync ON - current signal: 'from_myvar' +debug_sync ON - current signals: 'from_myvar' SET DEBUG_SYNC= LEFT('now SIGNAL from_function_cut_here', 24); SHOW VARIABLES LIKE 'DEBUG_SYNC'; Variable_name Value -debug_sync ON - current signal: 'from_function' +debug_sync ON - current signals: 'from_myvar,from_function' SET DEBUG_SYNC= 'now SIGNAL something'; SHOW VARIABLES LIKE 'DEBUG_SYNC'; Variable_name Value -debug_sync ON - current signal: 'something' +debug_sync ON - current signals: 'something,from_function,from_myvar' SET DEBUG_SYNC= 'now WAIT_FOR nothing TIMEOUT 0'; Warnings: Warning #### debug sync point wait timed out SET DEBUG_SYNC= 'now SIGNAL nothing'; SHOW VARIABLES LIKE 'DEBUG_SYNC'; Variable_name Value -debug_sync ON - current signal: 'nothing' +debug_sync ON - current signals: 'something,from_function,nothing,from_myvar' SET DEBUG_SYNC= 'now WAIT_FOR nothing TIMEOUT 0'; SET DEBUG_SYNC= 'now SIGNAL something EXECUTE 0'; SHOW VARIABLES LIKE 'DEBUG_SYNC'; Variable_name Value -debug_sync ON - current signal: 'nothing' +debug_sync ON - current signals: 'something,from_function,from_myvar' SET DEBUG_SYNC= 'now WAIT_FOR anotherthing TIMEOUT 0 EXECUTE 0'; SET DEBUG_SYNC= 'now HIT_LIMIT 1'; ERROR HY000: debug sync point hit limit reached SET DEBUG_SYNC= 'RESET'; SHOW VARIABLES LIKE 'DEBUG_SYNC'; Variable_name Value -debug_sync ON - current signal: '' +debug_sync ON - current signals: '' SET DEBUG_SYNC= 'p1abcd SIGNAL s1 EXECUTE 2'; SET DEBUG_SYNC= 'p2abc SIGNAL s2 EXECUTE 2'; SET DEBUG_SYNC= 'p9abcdef SIGNAL s9 EXECUTE 2'; @@ -190,23 +190,30 @@ SET DEBUG_SYNC= 'p3abcdef SIGNAL s3 EXECUTE 2'; SET DEBUG_SYNC= 'p4a TEST'; SHOW VARIABLES LIKE 'DEBUG_SYNC'; Variable_name Value -debug_sync ON - current signal: 's4' +debug_sync ON - current signals: 's4' SET DEBUG_SYNC= 'p1abcd TEST'; SHOW VARIABLES LIKE 'DEBUG_SYNC'; Variable_name Value -debug_sync ON - current signal: 's1' +debug_sync ON - current signals: 's4,s1' SET DEBUG_SYNC= 'p7 TEST'; SHOW VARIABLES LIKE 'DEBUG_SYNC'; Variable_name Value -debug_sync ON - current signal: 's7' +debug_sync ON - current signals: 's1,s7,s4' SET DEBUG_SYNC= 'p9abcdef TEST'; SHOW VARIABLES LIKE 'DEBUG_SYNC'; Variable_name Value -debug_sync ON - current signal: 's9' +debug_sync ON - current signals: 's1,s7,s4,s9' SET DEBUG_SYNC= 'p3abcdef TEST'; SHOW VARIABLES LIKE 'DEBUG_SYNC'; Variable_name Value -debug_sync ON - current signal: 's3' +debug_sync ON - current signals: 's1,s3,s4,s9,s7' +SET DEBUG_SYNC= 'now WAIT_FOR s9'; +SET DEBUG_SYNC= 'now WAIT_FOR s1'; +SET DEBUG_SYNC= 'now WAIT_FOR s4'; +SET DEBUG_SYNC= 'now WAIT_FOR s7'; +SHOW VARIABLES LIKE 'DEBUG_SYNC'; +Variable_name Value +debug_sync ON - current signals: 's3' SET DEBUG_SYNC= 'p1abcd CLEAR'; SET DEBUG_SYNC= 'p2abc CLEAR'; SET DEBUG_SYNC= 'p5abcde CLEAR'; @@ -219,19 +226,19 @@ SET DEBUG_SYNC= 'p7 CLEAR'; SET DEBUG_SYNC= 'p1abcd TEST'; SHOW VARIABLES LIKE 'DEBUG_SYNC'; Variable_name Value -debug_sync ON - current signal: 's3' +debug_sync ON - current signals: 's3' SET DEBUG_SYNC= 'p7 TEST'; SHOW VARIABLES LIKE 'DEBUG_SYNC'; Variable_name Value -debug_sync ON - current signal: 's3' +debug_sync ON - current signals: 's3' SET DEBUG_SYNC= 'p9abcdef TEST'; SHOW VARIABLES LIKE 'DEBUG_SYNC'; Variable_name Value -debug_sync ON - current signal: 's3' +debug_sync ON - current signals: 's3' SET DEBUG_SYNC= 'RESET'; SHOW VARIABLES LIKE 'DEBUG_SYNC'; Variable_name Value -debug_sync ON - current signal: '' +debug_sync ON - current signals: '' CREATE USER mysqltest_1@localhost; GRANT SUPER ON *.* TO mysqltest_1@localhost; connect con1,localhost,mysqltest_1,,; diff --git a/mysql-test/main/debug_sync.test b/mysql-test/main/debug_sync.test index 89414939f59..0e57071e08a 100644 --- a/mysql-test/main/debug_sync.test +++ b/mysql-test/main/debug_sync.test @@ -298,6 +298,16 @@ SET DEBUG_SYNC= 'p9abcdef TEST'; SHOW VARIABLES LIKE 'DEBUG_SYNC'; SET DEBUG_SYNC= 'p3abcdef TEST'; SHOW VARIABLES LIKE 'DEBUG_SYNC'; + +# +# Wait for all signals currently active except s3. +# +SET DEBUG_SYNC= 'now WAIT_FOR s9'; +SET DEBUG_SYNC= 'now WAIT_FOR s1'; +SET DEBUG_SYNC= 'now WAIT_FOR s4'; +SET DEBUG_SYNC= 'now WAIT_FOR s7'; +SHOW VARIABLES LIKE 'DEBUG_SYNC'; + # # Clear the actions. # @@ -320,7 +330,7 @@ SHOW VARIABLES LIKE 'DEBUG_SYNC'; SET DEBUG_SYNC= 'p9abcdef TEST'; SHOW VARIABLES LIKE 'DEBUG_SYNC'; # -# Now cleanup. Actions are clear already, but signal needs to be cleared. +# Now cleanup. Actions are clear already, but s3 signal needs to be cleared. # SET DEBUG_SYNC= 'RESET'; SHOW VARIABLES LIKE 'DEBUG_SYNC'; diff --git a/mysql-test/suite/innodb/r/mdev-14846.result b/mysql-test/suite/innodb/r/mdev-14846.result index 219bd718feb..a1ccfb6bb4d 100644 --- a/mysql-test/suite/innodb/r/mdev-14846.result +++ b/mysql-test/suite/innodb/r/mdev-14846.result @@ -31,11 +31,12 @@ pk f1 f2 f3 3 t q 1 5 z t NULL SET DEBUG_SYNC='now SIGNAL default_dml'; +SET DEBUG_SYNC='now SIGNAL con2_dml'; connection default; SET DEBUG_SYNC='now WAIT_FOR default_dml'; UPDATE t3 AS alias1 LEFT JOIN t3 AS alias2 ON ( alias1.f1 <> alias1.f2 ) SET alias1.f3 = 59 WHERE ( EXISTS ( SELECT t1.f3 FROM t1 WHERE t1.f1 = alias1.f1 ) ) OR alias2.f1 = 'h'; connect con2,localhost,root,,test; -set debug_sync='now WAIT_FOR default_dml'; +set debug_sync='now WAIT_FOR con2_dml'; SET DEBUG_SYNC='now SIGNAL con1_dml2'; disconnect con2; connection con1; diff --git a/mysql-test/suite/innodb/t/mdev-14846.test b/mysql-test/suite/innodb/t/mdev-14846.test index adcefecd52f..b1f32302591 100644 --- a/mysql-test/suite/innodb/t/mdev-14846.test +++ b/mysql-test/suite/innodb/t/mdev-14846.test @@ -35,6 +35,7 @@ SET DEBUG_SYNC='now WAIT_FOR con1_dml'; begin; SELECT * FROM t1 for update; # Holds x lock of all records in the table t1 SET DEBUG_SYNC='now SIGNAL default_dml'; +SET DEBUG_SYNC='now SIGNAL con2_dml'; --connection default SET DEBUG_SYNC='now WAIT_FOR default_dml'; @@ -42,7 +43,7 @@ SET DEBUG_SYNC='now WAIT_FOR default_dml'; # It holds the lock of all record in t3 and tries to acquire record lock for the table t1. --connect (con2,localhost,root,,test) -set debug_sync='now WAIT_FOR default_dml'; +set debug_sync='now WAIT_FOR con2_dml'; let $wait_condition= select count(*) > 0 from information_schema.innodb_lock_waits; --source include/wait_condition.inc diff --git a/mysql-test/suite/sys_vars/r/debug_sync_basic.result b/mysql-test/suite/sys_vars/r/debug_sync_basic.result index 6ebb46dd662..11506cac2c2 100644 --- a/mysql-test/suite/sys_vars/r/debug_sync_basic.result +++ b/mysql-test/suite/sys_vars/r/debug_sync_basic.result @@ -2,17 +2,17 @@ select @@global.debug_sync; ERROR HY000: Variable 'debug_sync' is a SESSION variable select @@session.debug_sync; @@session.debug_sync -ON - current signal: '' +ON - current signals: '' show global variables like "debug_sync"; Variable_name Value show session variables like "debug_sync"; Variable_name Value -debug_sync ON - current signal: '' +debug_sync ON - current signals: '' select * from information_schema.global_variables where variable_name="debug_sync"; VARIABLE_NAME VARIABLE_VALUE select * from information_schema.session_variables where variable_name="debug_sync"; VARIABLE_NAME VARIABLE_VALUE -DEBUG_SYNC ON - current signal: '' +DEBUG_SYNC ON - current signals: '' set @@session.debug_sync=1; ERROR 42000: Incorrect argument type to variable 'debug_sync' set @@session.debug_sync=1.1; diff --git a/mysql-test/suite/sys_vars/r/sysvars_debug.result b/mysql-test/suite/sys_vars/r/sysvars_debug.result index 0d77b0211a1..fc04ac83210 100644 --- a/mysql-test/suite/sys_vars/r/sysvars_debug.result +++ b/mysql-test/suite/sys_vars/r/sysvars_debug.result @@ -77,7 +77,7 @@ READ_ONLY YES COMMAND_LINE_ARGUMENT OPTIONAL GLOBAL_VALUE_PATH NULL VARIABLE_NAME DEBUG_SYNC -SESSION_VALUE ON - current signal: '' +SESSION_VALUE ON - current signals: '' GLOBAL_VALUE NULL GLOBAL_VALUE_ORIGIN COMPILE-TIME DEFAULT_VALUE diff --git a/sql/debug_sync.cc b/sql/debug_sync.cc index 55523a728f8..6c847dc9927 100644 --- a/sql/debug_sync.cc +++ b/sql/debug_sync.cc @@ -67,21 +67,99 @@ struct st_debug_sync_control }; + + /** Definitions for the debug sync facility. - 1. Global string variable to hold a "signal" ("signal post", "flag mast"). + 1. Global string variable to hold a set of of "signals". 2. Global condition variable for signaling and waiting. 3. Global mutex to synchronize access to the above. */ struct st_debug_sync_globals { - String ds_signal; /* signal variable */ + Hash_set ds_signal_set; /* A set of active signals */ mysql_cond_t ds_cond; /* condition variable */ mysql_mutex_t ds_mutex; /* mutex variable */ ulonglong dsp_hits; /* statistics */ ulonglong dsp_executed; /* statistics */ ulonglong dsp_max_active; /* statistics */ + + st_debug_sync_globals() : ds_signal_set(PSI_NOT_INSTRUMENTED, signal_key) {}; + ~st_debug_sync_globals() + { + clear_set(); + } + + void clear_set() + { + Hash_set::Iterator it{ds_signal_set}; + LEX_CSTRING *s; + while ((s= it++)) + my_free(s); + ds_signal_set.clear(); + } + + /* Hash key function for ds_signal_set. */ + static uchar *signal_key(const LEX_CSTRING *str, size_t *klen, my_bool) + { + *klen= str->length; + return (uchar*) str->str; + } + + /** + Return true if the signal is found in global signal list. + + @param signal_name Signal name identifying the signal. + + @note + If signal is found in the global signal set, it means that the + signal thread has signalled to the waiting thread. This method + must be called with the debug_sync_global.ds_mutex held. + + @retval true if signal is found in the global signal list. + @retval false otherwise. + */ + + inline bool is_signalled(const String &signal_name) + { + return ds_signal_set.find(signal_name.ptr(), signal_name.length()); + } + + void clear_signal(const String &signal_name) + { + DBUG_ENTER("clear_signal"); + LEX_CSTRING *record= ds_signal_set.find(signal_name.ptr(), + signal_name.length()); + if (record) + { + ds_signal_set.remove(record); + my_free(record); + } + DBUG_VOID_RETURN; + } + + bool set_signal(const String &signal_name) + { + /* Need to check if the signal is already in the hash set, because + Hash_set doesn't differentiate between OOM and key already in. */ + if (is_signalled(signal_name)) + return FALSE; + /* LEX_CSTRING and the string allocated with only one malloc. */ + LEX_CSTRING *s= (LEX_CSTRING *) my_malloc(PSI_NOT_INSTRUMENTED, + sizeof(LEX_CSTRING) + + signal_name.length() + 1, MYF(0)); + char *str= (char *)(s + 1); + memcpy(str, signal_name.ptr(), signal_name.length()); + str[signal_name.length()]= '\0'; + + s->length= signal_name.length(); + s->str= str; + if (ds_signal_set.insert(s)) + return TRUE; + return FALSE; + } }; + static st_debug_sync_globals debug_sync_global; /* All globals in one object */ /** @@ -161,7 +239,7 @@ int debug_sync_init(void) int rc; /* Initialize the global variables. */ - debug_sync_global.ds_signal.length(0); + debug_sync_global.clear_set(); if ((rc= mysql_cond_init(key_debug_sync_globals_ds_cond, &debug_sync_global.ds_cond, NULL)) || (rc= mysql_mutex_init(key_debug_sync_globals_ds_mutex, @@ -195,7 +273,7 @@ void debug_sync_end(void) debug_sync_C_callback_ptr= NULL; /* Destroy the global variables. */ - debug_sync_global.ds_signal.free(); + debug_sync_global.clear_set(); mysql_cond_destroy(&debug_sync_global.ds_cond); mysql_mutex_destroy(&debug_sync_global.ds_mutex); @@ -554,7 +632,7 @@ static void debug_sync_reset(THD *thd) /* Clear the global signal. */ mysql_mutex_lock(&debug_sync_global.ds_mutex); - debug_sync_global.ds_signal.length(0); + debug_sync_global.clear_set(); mysql_mutex_unlock(&debug_sync_global.ds_mutex); DBUG_VOID_RETURN; @@ -1325,13 +1403,19 @@ uchar *debug_sync_value_ptr(THD *thd) if (opt_debug_sync_timeout) { - static char on[]= "ON - current signal: '"; + static char on[]= "ON - current signals: '"; // Ensure exclusive access to debug_sync_global.ds_signal mysql_mutex_lock(&debug_sync_global.ds_mutex); - size_t lgt= (sizeof(on) /* includes '\0' */ + - debug_sync_global.ds_signal.length() + 1 /* for '\'' */); + size_t lgt= sizeof(on) + 1; /* +1 as we'll have to append ' at the end. */ + + for (size_t i= 0; i < debug_sync_global.ds_signal_set.size(); i++) + { + /* Assume each signal is separated by a comma, hence +1. */ + lgt+= debug_sync_global.ds_signal_set.at(i)->length + 1; + } + char *vend; char *vptr; @@ -1339,10 +1423,15 @@ uchar *debug_sync_value_ptr(THD *thd) { vend= value + lgt - 1; /* reserve space for '\0'. */ vptr= debug_sync_bmove_len(value, vend, STRING_WITH_LEN(on)); - vptr= debug_sync_bmove_len(vptr, vend, debug_sync_global.ds_signal.ptr(), - debug_sync_global.ds_signal.length()); - if (vptr < vend) - *(vptr++)= '\''; + for (size_t i= 0; i < debug_sync_global.ds_signal_set.size(); i++) + { + const LEX_CSTRING *s= debug_sync_global.ds_signal_set.at(i); + vptr= debug_sync_bmove_len(vptr, vend, s->str, s->length); + if (i != debug_sync_global.ds_signal_set.size() - 1) + *(vptr++)= ','; + } + DBUG_ASSERT(vptr < vend); + *(vptr++)= '\''; *vptr= '\0'; /* We have one byte reserved for the worst case. */ } mysql_mutex_unlock(&debug_sync_global.ds_mutex); @@ -1358,6 +1447,9 @@ uchar *debug_sync_value_ptr(THD *thd) } + + + /** Execute requested action at a synchronization point. @@ -1413,12 +1505,12 @@ static void debug_sync_execute(THD *thd, st_debug_sync_action *action) read access too, to create a memory barrier in order to avoid that threads just reads an old cached version of the signal. */ + mysql_mutex_lock(&debug_sync_global.ds_mutex); if (action->signal.length()) { - /* Copy the signal to the global variable. */ - if (debug_sync_global.ds_signal.copy(action->signal)) + if (debug_sync_global.set_signal(action->signal)) { /* Error is reported by my_malloc(). @@ -1461,12 +1553,12 @@ static void debug_sync_execute(THD *thd, st_debug_sync_action *action) restore_current_mutex = false; set_timespec(abstime, action->timeout); - DBUG_EXECUTE("debug_sync_exec", + // TODO turn this into a for loop printing. + DBUG_EXECUTE("debug_sync_exec", { /* Functions as DBUG_PRINT args can change keyword and line nr. */ DBUG_PRINT("debug_sync_exec", - ("wait for '%s' at: '%s' curr: '%s'", - sig_wait, dsp_name, - debug_sync_global.ds_signal.c_ptr()));); + ("wait for '%s' at: '%s'", + sig_wait, dsp_name));}); /* Wait until global signal string matches the wait_for string. @@ -1474,18 +1566,19 @@ static void debug_sync_execute(THD *thd, st_debug_sync_action *action) The facility can become disabled when some thread cannot get the required dynamic memory allocated. */ - while (stringcmp(&debug_sync_global.ds_signal, &action->wait_for) && - !(thd->killed & KILL_HARD_BIT) && opt_debug_sync_timeout) + while (!debug_sync_global.is_signalled(action->wait_for) && + !(thd->killed & KILL_HARD_BIT)&& + opt_debug_sync_timeout) { error= mysql_cond_timedwait(&debug_sync_global.ds_cond, &debug_sync_global.ds_mutex, &abstime); - DBUG_EXECUTE("debug_sync", + // TODO turn this into a for loop printing. + DBUG_EXECUTE("debug_sync", { /* Functions as DBUG_PRINT args can change keyword and line nr. */ DBUG_PRINT("debug_sync", - ("awoke from %s global: %s error: %d", - sig_wait, debug_sync_global.ds_signal.c_ptr(), - error));); + ("awoke from %s error: %d", + sig_wait, error));}); if (unlikely(error == ETIMEDOUT || error == ETIME)) { // We should not make the statement fail, even if in strict mode. @@ -1498,6 +1591,8 @@ static void debug_sync_execute(THD *thd, st_debug_sync_action *action) } error= 0; } + // TODO conditional on clear-event + debug_sync_global.clear_signal(action->wait_for); DBUG_EXECUTE("debug_sync_exec", if (thd->killed) DBUG_PRINT("debug_sync_exec", @@ -1571,10 +1666,10 @@ static void debug_sync(THD *thd, const char *sync_point_name, size_t name_len) st_debug_sync_control *ds_control= thd->debug_sync_control; st_debug_sync_action *action; DBUG_ENTER("debug_sync"); + DBUG_PRINT("debug_sync_point", ("hit: '%s'", sync_point_name)); DBUG_ASSERT(sync_point_name); DBUG_ASSERT(name_len); DBUG_ASSERT(ds_control); - DBUG_PRINT("debug_sync_point", ("hit: '%s'", sync_point_name)); /* Statistics. */ ds_control->dsp_hits++; -- cgit v1.2.1 From cd873c8688a6f21b3c859068d3146e9fd90120b0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vicen=C8=9Biu=20Ciorbaru?= Date: Wed, 29 Sep 2021 11:24:05 +0300 Subject: debug_sync: Implement NO_CLEAR_EVENT syntax When waiting on a signal, NO_CLEAR_EVENT allows one to not clear the signal, effectively allowing other threads to wait for the same signal. --- mysql-test/main/debug_sync.result | 16 ++++++++++++++++ mysql-test/main/debug_sync.test | 11 +++++++++++ sql/debug_sync.cc | 18 ++++++++++++++++-- 3 files changed, 43 insertions(+), 2 deletions(-) diff --git a/mysql-test/main/debug_sync.result b/mysql-test/main/debug_sync.result index 45cdc40e241..9b6699f9bc2 100644 --- a/mysql-test/main/debug_sync.result +++ b/mysql-test/main/debug_sync.result @@ -299,4 +299,20 @@ disconnect con1; disconnect con2; connection default; DROP TABLE t1; +# +# Test NO_CLEAR_EVENT flag. The signal should still be visible after +# the wait has completed succesfully. +# +SET DEBUG_SYNC= 'now SIGNAL s1'; +SHOW VARIABLES LIKE 'DEBUG_SYNC'; +Variable_name Value +debug_sync ON - current signals: 's1' +SET DEBUG_SYNC= 'now WAIT_FOR s1 NO_CLEAR_EVENT'; +SHOW VARIABLES LIKE 'DEBUG_SYNC'; +Variable_name Value +debug_sync ON - current signals: 's1' +SET DEBUG_SYNC= 'now WAIT_FOR s1'; +SHOW VARIABLES LIKE 'DEBUG_SYNC'; +Variable_name Value +debug_sync ON - current signals: '' SET DEBUG_SYNC= 'RESET'; diff --git a/mysql-test/main/debug_sync.test b/mysql-test/main/debug_sync.test index 0e57071e08a..0ea637a393a 100644 --- a/mysql-test/main/debug_sync.test +++ b/mysql-test/main/debug_sync.test @@ -428,6 +428,17 @@ disconnect con2; connection default; DROP TABLE t1; +--echo # +--echo # Test NO_CLEAR_EVENT flag. The signal should still be visible after +--echo # the wait has completed succesfully. +--echo # +SET DEBUG_SYNC= 'now SIGNAL s1'; +SHOW VARIABLES LIKE 'DEBUG_SYNC'; +SET DEBUG_SYNC= 'now WAIT_FOR s1 NO_CLEAR_EVENT'; +SHOW VARIABLES LIKE 'DEBUG_SYNC'; +SET DEBUG_SYNC= 'now WAIT_FOR s1'; +SHOW VARIABLES LIKE 'DEBUG_SYNC'; + # # Cleanup after test case. # Otherwise signal would contain 'flushed' here, diff --git a/sql/debug_sync.cc b/sql/debug_sync.cc index 6c847dc9927..cdbeed1244f 100644 --- a/sql/debug_sync.cc +++ b/sql/debug_sync.cc @@ -48,6 +48,8 @@ struct st_debug_sync_action String wait_for; /* signal to wait for */ String sync_point; /* sync point name */ bool need_sort; /* if new action, array needs sort */ + bool clear_event; /* do not clear signal when waited + for if false. */ }; /* Debug sync control. Referenced by THD. */ @@ -1253,6 +1255,7 @@ static bool debug_sync_eval_action(THD *thd, char *action_str, char *action_end) /* Set default for EXECUTE and TIMEOUT options. */ action->execute= 1; action->timeout= opt_debug_sync_timeout; + action->clear_event= true; /* Get next token. If none follows, set action. */ if (!(ptr= debug_sync_token(&token, &token_length, ptr, action_end))) @@ -1303,6 +1306,15 @@ static bool debug_sync_eval_action(THD *thd, char *action_str, char *action_end) goto set_action; } + /* + Try NO_CLEAR_EVENT. + */ + if (!my_strcasecmp(system_charset_info, token, "NO_CLEAR_EVENT")) { + action->clear_event= false; + /* Get next token. If none follows, set action. */ + if (!(ptr = debug_sync_token(&token, &token_length, ptr, action_end))) goto set_action; + } + /* Try HIT_LIMIT. */ @@ -1591,8 +1603,10 @@ static void debug_sync_execute(THD *thd, st_debug_sync_action *action) } error= 0; } - // TODO conditional on clear-event - debug_sync_global.clear_signal(action->wait_for); + + if (action->clear_event) + debug_sync_global.clear_signal(action->wait_for); + DBUG_EXECUTE("debug_sync_exec", if (thd->killed) DBUG_PRINT("debug_sync_exec", -- cgit v1.2.1 From c115559b66f115b424fd1322db776d3815319f8c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vicen=C8=9Biu=20Ciorbaru?= Date: Wed, 29 Sep 2021 14:04:31 +0300 Subject: Extend Binary_string::strstr to also take in a const char pointer One shouldn't have to instantiate a Binary_string every time a strstr call is needed. --- sql/sql_string.cc | 28 ++++++++++++++++------------ sql/sql_string.h | 1 + 2 files changed, 17 insertions(+), 12 deletions(-) diff --git a/sql/sql_string.cc b/sql/sql_string.cc index fbc97ab54fb..d4639fb6bc4 100644 --- a/sql/sql_string.cc +++ b/sql/sql_string.cc @@ -677,33 +677,37 @@ bool String::append_with_prefill(const char *s,uint32 arg_length, } -int Binary_string::strstr(const Binary_string &s, uint32 offset) +int Binary_string::strstr(const char *search, uint32 search_length, uint32 offset) { - if (s.length()+offset <= str_length) + if (search_length + offset <= str_length) { - if (!s.length()) + if (!search_length) return ((int) offset); // Empty string is always found - const char *str = Ptr+offset; - const char *search=s.ptr(); - const char *end=Ptr+str_length-s.length()+1; - const char *search_end=s.ptr()+s.length(); + const char *str= Ptr + offset; + const char *end= Ptr + str_length - search_length + 1; + const char *search_end= search + search_length; skip: while (str != end) { if (*str++ == *search) { - char *i,*j; - i=(char*) str; j=(char*) search+1; - while (j != search_end) - if (*i++ != *j++) goto skip; - return (int) (str-Ptr) -1; + char *i= (char*) str; + char *j= (char*) search + 1 ; + while (j != search_end) + if (*i++ != *j++) goto skip; + return (int) (str-Ptr) -1; } } } return -1; } +int Binary_string::strstr(const Binary_string &s, uint32 offset) +{ + return strstr(s.ptr(), s.length(), offset); +} + /* ** Search string from end. Offset is offset to the end of string */ diff --git a/sql/sql_string.h b/sql/sql_string.h index b1f02bdb43b..7bf0e2d2518 100644 --- a/sql/sql_string.h +++ b/sql/sql_string.h @@ -330,6 +330,7 @@ public: // Returns offset to substring or -1 int strstr(const Binary_string &search, uint32 offset=0); + int strstr(const char *search, uint32 search_length, uint32 offset=0); // Returns offset to substring or -1 int strrstr(const Binary_string &search, uint32 offset=0); -- cgit v1.2.1 From 8ff0a7f893a71843967465f7d9ceafd8ae13f2c3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vicen=C8=9Biu=20Ciorbaru?= Date: Wed, 29 Sep 2021 14:10:56 +0300 Subject: Implement DEBUG_SYNC multiple signal firing capability One can now do: set DEBUG_SYNC='... SIGNAL s1,s2,s3...' Multiple signals can be fired, they need to be split by commas. --- mysql-test/main/debug_sync.result | 4 ++++ mysql-test/main/debug_sync.test | 7 +++++-- sql/debug_sync.cc | 41 +++++++++++++++++++++++++++------------ 3 files changed, 38 insertions(+), 14 deletions(-) diff --git a/mysql-test/main/debug_sync.result b/mysql-test/main/debug_sync.result index 9b6699f9bc2..4c1711a6d6b 100644 --- a/mysql-test/main/debug_sync.result +++ b/mysql-test/main/debug_sync.result @@ -315,4 +315,8 @@ SET DEBUG_SYNC= 'now WAIT_FOR s1'; SHOW VARIABLES LIKE 'DEBUG_SYNC'; Variable_name Value debug_sync ON - current signals: '' +SET DEBUG_SYNC= 'now SIGNAL s1,s2,s5,s7'; +SHOW VARIABLES LIKE 'DEBUG_SYNC'; +Variable_name Value +debug_sync ON - current signals: 's2,s7,s1,s5' SET DEBUG_SYNC= 'RESET'; diff --git a/mysql-test/main/debug_sync.test b/mysql-test/main/debug_sync.test index 0ea637a393a..1dc3dc9c71e 100644 --- a/mysql-test/main/debug_sync.test +++ b/mysql-test/main/debug_sync.test @@ -439,10 +439,13 @@ SHOW VARIABLES LIKE 'DEBUG_SYNC'; SET DEBUG_SYNC= 'now WAIT_FOR s1'; SHOW VARIABLES LIKE 'DEBUG_SYNC'; +SET DEBUG_SYNC= 'now SIGNAL s1,s2,s5,s7'; +SHOW VARIABLES LIKE 'DEBUG_SYNC'; + + # # Cleanup after test case. -# Otherwise signal would contain 'flushed' here, -# which could confuse the next test. +# Otherwise signal would confuse the next test. # SET DEBUG_SYNC= 'RESET'; diff --git a/sql/debug_sync.cc b/sql/debug_sync.cc index cdbeed1244f..b7090efa01b 100644 --- a/sql/debug_sync.cc +++ b/sql/debug_sync.cc @@ -122,9 +122,9 @@ struct st_debug_sync_globals @retval false otherwise. */ - inline bool is_signalled(const String &signal_name) + inline bool is_signalled(const char *signal_name, size_t length) { - return ds_signal_set.find(signal_name.ptr(), signal_name.length()); + return ds_signal_set.find(signal_name, length); } void clear_signal(const String &signal_name) @@ -140,21 +140,21 @@ struct st_debug_sync_globals DBUG_VOID_RETURN; } - bool set_signal(const String &signal_name) + bool set_signal(const char *signal_name, size_t length) { /* Need to check if the signal is already in the hash set, because Hash_set doesn't differentiate between OOM and key already in. */ - if (is_signalled(signal_name)) + if (is_signalled(signal_name, length)) return FALSE; /* LEX_CSTRING and the string allocated with only one malloc. */ LEX_CSTRING *s= (LEX_CSTRING *) my_malloc(PSI_NOT_INSTRUMENTED, - sizeof(LEX_CSTRING) + - signal_name.length() + 1, MYF(0)); + sizeof(LEX_CSTRING) + length + 1, + MYF(0)); char *str= (char *)(s + 1); - memcpy(str, signal_name.ptr(), signal_name.length()); - str[signal_name.length()]= '\0'; + memcpy(str, signal_name, length); + str[length]= '\0'; - s->length= signal_name.length(); + s->length= length; s->str= str; if (ds_signal_set.insert(s)) return TRUE; @@ -1522,7 +1522,23 @@ static void debug_sync_execute(THD *thd, st_debug_sync_action *action) if (action->signal.length()) { - if (debug_sync_global.set_signal(action->signal)) + int offset= 0, pos; + bool error= false; + + /* This loop covers all signals in the list except for the last one. + Split the signal string by commas and set a signal in the global + variable for each one. */ + while (!error && (pos= action->signal.strstr(",", 1, offset)) > 0) + { + error= debug_sync_global.set_signal(action->signal.ptr() + offset, + pos - offset); + offset= pos + 1; + } + + if (error || + /* The last signal in the list. */ + debug_sync_global.set_signal(action->signal.ptr() + offset, + action->signal.length() - offset)) { /* Error is reported by my_malloc(). @@ -1578,8 +1594,9 @@ static void debug_sync_execute(THD *thd, st_debug_sync_action *action) The facility can become disabled when some thread cannot get the required dynamic memory allocated. */ - while (!debug_sync_global.is_signalled(action->wait_for) && - !(thd->killed & KILL_HARD_BIT)&& + while (!debug_sync_global.is_signalled(action->wait_for.ptr(), + action->wait_for.length()) && + !(thd->killed & KILL_HARD_BIT) && opt_debug_sync_timeout) { error= mysql_cond_timedwait(&debug_sync_global.ds_cond, -- cgit v1.2.1 From addcf08d0f429640b6b23ee73e9b80e902c82704 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vicen=C8=9Biu=20Ciorbaru?= Date: Fri, 3 Feb 2023 14:13:30 +0200 Subject: Revert test changes from "Fixed debug_sync timeout in deadlock_drop_table" After introducing multiple signals possible for debug_sync, the test changes are no longer necessary. Revert them to the original state. --- mysql-test/suite/stress/r/deadlock_drop_table.result | 3 ++- mysql-test/suite/stress/t/deadlock_drop_table.test | 7 ++----- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/mysql-test/suite/stress/r/deadlock_drop_table.result b/mysql-test/suite/stress/r/deadlock_drop_table.result index 326f694e8d9..7e549157c81 100644 --- a/mysql-test/suite/stress/r/deadlock_drop_table.result +++ b/mysql-test/suite/stress/r/deadlock_drop_table.result @@ -19,11 +19,12 @@ a b c 1 NULL NULL set debug_sync='now SIGNAL go'; set debug_sync='now WAIT_FOR parked2'; -set debug_sync='before_wait_for_refs SIGNAL waiting WAIT_FOR go2'; +set debug_sync='before_wait_for_refs SIGNAL waiting WAIT_FOR go3'; drop table t1;; connection con2; set debug_sync='now WAIT_FOR waiting'; set debug_sync='now SIGNAL go2'; +set debug_sync='now SIGNAL go3'; connection default; connection con1; connection default; diff --git a/mysql-test/suite/stress/t/deadlock_drop_table.test b/mysql-test/suite/stress/t/deadlock_drop_table.test index 0ec19f87389..b4f8f2201e0 100644 --- a/mysql-test/suite/stress/t/deadlock_drop_table.test +++ b/mysql-test/suite/stress/t/deadlock_drop_table.test @@ -20,15 +20,12 @@ set debug_sync='now WAIT_FOR parked'; select * from t1; set debug_sync='now SIGNAL go'; set debug_sync='now WAIT_FOR parked2'; -set debug_sync='before_wait_for_refs SIGNAL waiting WAIT_FOR go2'; +set debug_sync='before_wait_for_refs SIGNAL waiting WAIT_FOR go3'; --send drop table t1; --connection con2 set debug_sync='now WAIT_FOR waiting'; set debug_sync='now SIGNAL go2'; - -# Write out show processlist if the debug sync point times out -let $wait_condition= select count(*)=0 from information_schema.processlist where state like "%debug%"; -source include/wait_condition.inc; +set debug_sync='now SIGNAL go3'; --connection default --reap -- cgit v1.2.1 From 2a08b2c15c22fe1019aea00ba160f5ca7e56e231 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vicen=C8=9Biu=20Ciorbaru?= Date: Fri, 3 Feb 2023 14:18:32 +0200 Subject: sql_hset.h - include what you use uchar comes from my_global.h --- sql/sql_hset.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sql/sql_hset.h b/sql/sql_hset.h index 065a3181bec..c9ffc8a560b 100644 --- a/sql/sql_hset.h +++ b/sql/sql_hset.h @@ -15,6 +15,7 @@ along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */ +#include "my_global.h" #include "hash.h" @@ -39,7 +40,7 @@ public: Hash_set(PSI_memory_key psi_key, CHARSET_INFO *charset, ulong default_array_elements, size_t key_offset, size_t key_length, my_hash_get_key get_key, - void (*free_element)(void*), uint flags) + void (*free_element)(void*),uint flags) { my_hash_init(psi_key, &m_hash, charset, default_array_elements, key_offset, key_length, get_key, free_element, flags); -- cgit v1.2.1 From 9f16d153579eb30639b5f7e8a827d65f44475979 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vicen=C8=9Biu=20Ciorbaru?= Date: Fri, 3 Feb 2023 15:00:49 +0200 Subject: debug_sync: Print all current active signals within the trace file during wait When running with DBUG trace enabled, print all current active signals. The output looks like this with the signals present in curr: T@6 ... debug_sync_exec: wait for 'nothing' at: 'now', curr: 'something,from_function,from_myvar' --- sql/debug_sync.cc | 55 ++++++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 50 insertions(+), 5 deletions(-) diff --git a/sql/debug_sync.cc b/sql/debug_sync.cc index b7090efa01b..aa6956060b4 100644 --- a/sql/debug_sync.cc +++ b/sql/debug_sync.cc @@ -18,6 +18,7 @@ #include "mariadb.h" #include "debug_sync.h" +#include #if defined(ENABLED_DEBUG_SYNC) @@ -351,6 +352,40 @@ void debug_sync_init_thread(THD *thd) } +/** + Returns an allocated buffer containing a comma-separated C string of all + active signals. + + Buffer must be freed by the caller. +*/ +static const char *get_signal_set_as_string() +{ + mysql_mutex_assert_owner(&debug_sync_global.ds_mutex); + size_t req_size= 1; // In case of empty set for the end '\0' char. + + for (size_t i= 0; i < debug_sync_global.ds_signal_set.size(); i++) + req_size+= debug_sync_global.ds_signal_set.at(i)->length + 1; + + char *buf= (char *) my_malloc(PSI_NOT_INSTRUMENTED, req_size, MYF(0)); + if (!buf) + return nullptr; + memset(buf, '\0', req_size); + + char *cur_pos= buf; + for (size_t i= 0; i < debug_sync_global.ds_signal_set.size(); i++) + { + const LEX_CSTRING *signal= debug_sync_global.ds_signal_set.at(i); + memcpy(cur_pos, signal->str, signal->length); + if (i != debug_sync_global.ds_signal_set.size() - 1) + cur_pos[signal->length]= ','; + else + cur_pos[signal->length] = '\0'; + cur_pos+= signal->length + 1; + } + return buf; +} + + /** End the debug sync facility at thread end. @@ -1581,12 +1616,22 @@ static void debug_sync_execute(THD *thd, st_debug_sync_action *action) restore_current_mutex = false; set_timespec(abstime, action->timeout); - // TODO turn this into a for loop printing. DBUG_EXECUTE("debug_sync_exec", { - /* Functions as DBUG_PRINT args can change keyword and line nr. */ - DBUG_PRINT("debug_sync_exec", - ("wait for '%s' at: '%s'", - sig_wait, dsp_name));}); + const char *signal_set= get_signal_set_as_string(); + if (!signal_set) + { + DBUG_PRINT("debug_sync_exec", + ("Out of memory when fetching signal set")); + } + else + { + /* Functions as DBUG_PRINT args can change keyword and line nr. */ + DBUG_PRINT("debug_sync_exec", + ("wait for '%s' at: '%s', curr: '%s'", + sig_wait, dsp_name, signal_set)); + my_free((void *)signal_set); + }}); + /* Wait until global signal string matches the wait_for string. -- cgit v1.2.1 From bef20b5f36d21a2e7a03d283e158e66a64a16754 Mon Sep 17 00:00:00 2001 From: Igor Babaev Date: Thu, 2 Feb 2023 22:38:32 -0800 Subject: MDEV-30538 Plans for SELECT and multi-table UPDATE/DELETE unexpectedly differ This patch allowed transformation of EXISTS subqueries into equivalent IN predicands at the top level of WHERE conditions for multi-table UPDATE and DELETE statements. There was no reason to prohibit the transformation for such statements. The transformation provides more opportunities of using semi-join optimizations. Approved by Oleksandr Byelkin --- mysql-test/main/multi_update.result | 120 +++++++++++++++++++++++++++++++ mysql-test/main/multi_update.test | 70 ++++++++++++++++++ mysql-test/main/update_use_source.result | 12 ++-- sql/item_subselect.cc | 4 +- 4 files changed, 201 insertions(+), 5 deletions(-) diff --git a/mysql-test/main/multi_update.result b/mysql-test/main/multi_update.result index 61e04c3d4a9..d6cf9ba685f 100644 --- a/mysql-test/main/multi_update.result +++ b/mysql-test/main/multi_update.result @@ -1251,3 +1251,123 @@ EXPLAIN } } DROP TABLES t1, t2; +# End of 10.3 tests +# +# MDEV-28538: multi-table UPDATE/DELETE with possible exists-to-in +# +create table t1 (c1 int, c2 int, c3 int, index idx(c2)); +insert into t1 values +(1,1,1),(3,2,2),(1,3,3), +(2,1,4),(2,2,5),(4,3,6), +(2,4,7),(2,5,8); +create table t2 (c1 int, c2 int, c3 int, index idx(c2)); +insert into t2 values +(1,7,1),(1,8,2),(1,3,3), +(2,1,4),(2,2,5),(2,3,6), +(2,4,7),(2,5,8); +create table t3 (c1 int, c2 int, c3 int, index idx(c2)); +insert into t3 values +(1,1,1),(1,2,2),(1,3,3), +(2,1,4),(2,2,5),(2,3,6), +(2,4,7),(2,5,8); +insert into t3 select c1+1, c2+2, c3 from t3; +insert into t3 select c1, c2+2, c3 from t3; +analyze table t1,t2,t3 persistent for all; +Table Op Msg_type Msg_text +test.t1 analyze status Engine-independent statistics collected +test.t1 analyze status OK +test.t2 analyze status Engine-independent statistics collected +test.t2 analyze status OK +test.t3 analyze status Engine-independent statistics collected +test.t3 analyze status OK +explain select * from t1,t3 +where t1.c2 = t3.c2 and +t1.c1 > 1 and +exists (select 'X' from t2 where t2.c1 = t1.c1 and t2.c2 > 4); +id select_type table type possible_keys key key_len ref rows Extra +1 PRIMARY t1 ALL idx NULL NULL NULL 8 Using where +1 PRIMARY eq_ref distinct_key distinct_key 4 func 1 +1 PRIMARY t3 ref idx idx 5 test.t1.c2 3 +2 MATERIALIZED t2 range idx idx 5 NULL 3 Using index condition; Using where +explain delete from t1 using t1,t3 +where t1.c2 = t3.c2 and +t1.c1 > 1 and +exists (select 'X' from t2 where t2.c1 = t1.c1 and t2.c2 > 4); +id select_type table type possible_keys key key_len ref rows Extra +1 PRIMARY t1 ALL idx NULL NULL NULL 8 Using where +1 PRIMARY eq_ref distinct_key distinct_key 4 func 1 +1 PRIMARY t3 ref idx idx 5 test.t1.c2 3 Using index +2 MATERIALIZED t2 range idx idx 5 NULL 3 Using where +explain update t1,t3 set t1.c1 = t1.c1+10 +where t1.c2 = t3.c2 and +t1.c1 > 1 and +exists (select 'X' from t2 where t2.c1 = t1.c1 and t2.c2 > 4); +id select_type table type possible_keys key key_len ref rows Extra +1 PRIMARY t1 ALL idx NULL NULL NULL 8 Using where +1 PRIMARY eq_ref distinct_key distinct_key 4 func 1 +1 PRIMARY t3 ref idx idx 5 test.t1.c2 3 Using index +2 MATERIALIZED t2 range idx idx 5 NULL 3 Using where +create table t as select * from t1; +select * from t1,t3 +where t1.c2 = t3.c2 and +t1.c1 > 1 and +exists (select 'X' from t2 where t2.c1 = t1.c1 and t2.c2 > 4); +c1 c2 c3 c1 c2 c3 +2 1 4 1 1 1 +2 1 4 2 1 4 +2 2 5 1 2 2 +2 2 5 2 2 5 +2 4 7 2 4 7 +2 4 7 2 4 2 +2 4 7 3 4 5 +2 4 7 1 4 2 +2 4 7 2 4 5 +2 5 8 2 5 8 +2 5 8 2 5 3 +2 5 8 3 5 6 +2 5 8 1 5 3 +2 5 8 2 5 6 +2 5 8 2 5 1 +2 5 8 3 5 4 +select * from t1; +c1 c2 c3 +1 1 1 +3 2 2 +1 3 3 +2 1 4 +2 2 5 +4 3 6 +2 4 7 +2 5 8 +delete from t1 using t1,t3 +where t1.c2 = t3.c2 and +t1.c1 > 1 and +exists (select 'X' from t2 where t2.c1 = t1.c1 and t2.c2 > 4); +select * from t1; +c1 c2 c3 +1 1 1 +3 2 2 +1 3 3 +4 3 6 +truncate table t1; +insert into t1 select * from t; +analyze table t1 persistent for all; +Table Op Msg_type Msg_text +test.t1 analyze status Engine-independent statistics collected +test.t1 analyze status Table is already up to date +update t1,t3 set t1.c1 = t1.c1+10 +where t1.c2 = t3.c2 and +t1.c1 > 1 and +exists (select 'X' from t2 where t2.c1 = t1.c1 and t2.c2 > 4); +select * from t1; +c1 c2 c3 +1 1 1 +3 2 2 +1 3 3 +12 1 4 +12 2 5 +4 3 6 +12 4 7 +12 5 8 +drop table t1,t2,t3,t; +# End of 10.4 tests diff --git a/mysql-test/main/multi_update.test b/mysql-test/main/multi_update.test index 54c64918e03..48e6250393b 100644 --- a/mysql-test/main/multi_update.test +++ b/mysql-test/main/multi_update.test @@ -1130,3 +1130,73 @@ EXPLAIN FORMAT=JSON UPDATE t2 JOIN t1 USING(a) SET t2.part=2 WHERE t2.part=1 AND EXPLAIN FORMAT=JSON UPDATE t2 JOIN t1 USING(a) SET t2.part=3 WHERE t2.part=2 AND t1.part=2; DROP TABLES t1, t2; + +--echo # End of 10.3 tests + +--echo # +--echo # MDEV-28538: multi-table UPDATE/DELETE with possible exists-to-in +--echo # + +create table t1 (c1 int, c2 int, c3 int, index idx(c2)); +insert into t1 values +(1,1,1),(3,2,2),(1,3,3), +(2,1,4),(2,2,5),(4,3,6), +(2,4,7),(2,5,8); + +create table t2 (c1 int, c2 int, c3 int, index idx(c2)); +insert into t2 values +(1,7,1),(1,8,2),(1,3,3), +(2,1,4),(2,2,5),(2,3,6), +(2,4,7),(2,5,8); + +create table t3 (c1 int, c2 int, c3 int, index idx(c2)); +insert into t3 values +(1,1,1),(1,2,2),(1,3,3), +(2,1,4),(2,2,5),(2,3,6), +(2,4,7),(2,5,8); +insert into t3 select c1+1, c2+2, c3 from t3; +insert into t3 select c1, c2+2, c3 from t3; + +analyze table t1,t2,t3 persistent for all; + +let $c= + t1.c2 = t3.c2 and + t1.c1 > 1 and + exists (select 'X' from t2 where t2.c1 = t1.c1 and t2.c2 > 4); + +let $q1= +select * from t1,t3 +where $c; + +eval explain $q1; + +let $q2= +delete from t1 using t1,t3 +where $c; + +eval explain $q2; + +let $q3= +update t1,t3 set t1.c1 = t1.c1+10 +where $c; + +eval explain $q3; + +create table t as select * from t1; + +eval $q1; +select * from t1; + +eval $q2; +select * from t1; + +truncate table t1; +insert into t1 select * from t; +analyze table t1 persistent for all; + +eval $q3; +select * from t1; + +drop table t1,t2,t3,t; + +--echo # End of 10.4 tests diff --git a/mysql-test/main/update_use_source.result b/mysql-test/main/update_use_source.result index 9e43b54d81c..57787671e77 100644 --- a/mysql-test/main/update_use_source.result +++ b/mysql-test/main/update_use_source.result @@ -76,7 +76,8 @@ rollback; explain update t1 set c1=0 where exists (select 'X' from t1 a where a.c2 = t1.c2) and c2 > 3; id select_type table type possible_keys key key_len ref rows Extra 1 PRIMARY t1 ALL NULL NULL NULL NULL 8 Using where -2 DEPENDENT SUBQUERY a ALL NULL NULL NULL NULL 8 Using where +1 PRIMARY eq_ref distinct_key distinct_key 4 func 1 +2 MATERIALIZED a ALL NULL NULL NULL NULL 8 start transaction; update t1 set c1=c1+10 where exists (select 'X' from t1 a where a.c2 = t1.c2) and c2 >= 3; affected rows: 4 @@ -317,7 +318,8 @@ rollback; explain update t1 set c1=0 where exists (select 'X' from t1 a where a.c2 = t1.c2) and c2 > 3; id select_type table type possible_keys key key_len ref rows Extra 1 PRIMARY t1 range t1_c2 t1_c2 5 NULL 2 Using where -2 DEPENDENT SUBQUERY a ref t1_c2 t1_c2 5 test.t1.c2 4 Using index +1 PRIMARY eq_ref distinct_key distinct_key 4 func 1 +2 MATERIALIZED a range t1_c2 t1_c2 5 NULL 2 Using where; Using index start transaction; update t1 set c1=c1+10 where exists (select 'X' from t1 a where a.c2 = t1.c2) and c2 >= 3; affected rows: 4 @@ -558,7 +560,8 @@ rollback; explain update t1 set c1=0 where exists (select 'X' from t1 a where a.c2 = t1.c2) and c2 > 3; id select_type table type possible_keys key key_len ref rows Extra 1 PRIMARY t1 range t1_c2 t1_c2 5 NULL 2 Using where -2 DEPENDENT SUBQUERY a ref t1_c2 t1_c2 5 test.t1.c2 1 Using index +1 PRIMARY eq_ref distinct_key distinct_key 4 func 1 +2 MATERIALIZED a range t1_c2 t1_c2 5 NULL 2 Using where; Using index start transaction; update t1 set c1=c1+10 where exists (select 'X' from t1 a where a.c2 = t1.c2) and c2 >= 3; affected rows: 4 @@ -800,7 +803,8 @@ rollback; explain update t1 set c1=0 where exists (select 'X' from t1 a where a.c2 = t1.c2) and c2 > 3; id select_type table type possible_keys key key_len ref rows Extra 1 PRIMARY t1 range t1_c2 t1_c2 5 NULL 2 Using where -2 DEPENDENT SUBQUERY a ref t1_c2 t1_c2 5 test.t1.c2 1 Using index +1 PRIMARY eq_ref distinct_key distinct_key 4 func 1 +2 MATERIALIZED a range t1_c2 t1_c2 5 NULL 2 Using where; Using index start transaction; update t1 set c1=c1+10 where exists (select 'X' from t1 a where a.c2 = t1.c2) and c2 >= 3; affected rows: 4 diff --git a/sql/item_subselect.cc b/sql/item_subselect.cc index 461bd9fb144..1454073e459 100644 --- a/sql/item_subselect.cc +++ b/sql/item_subselect.cc @@ -2825,7 +2825,9 @@ bool Item_exists_subselect::select_prepare_to_be_in() bool trans_res= FALSE; DBUG_ENTER("Item_exists_subselect::select_prepare_to_be_in"); if (!optimizer && - thd->lex->sql_command == SQLCOM_SELECT && + (thd->lex->sql_command == SQLCOM_SELECT || + thd->lex->sql_command == SQLCOM_UPDATE_MULTI || + thd->lex->sql_command == SQLCOM_DELETE_MULTI) && !unit->first_select()->is_part_of_union() && optimizer_flag(thd, OPTIMIZER_SWITCH_EXISTS_TO_IN) && (is_top_level_item() || -- cgit v1.2.1 From 29b4bd4ea9d1b7cd6a241c83ff0daf7856107c55 Mon Sep 17 00:00:00 2001 From: Daniel Black Date: Mon, 6 Feb 2023 19:16:15 +1100 Subject: MDEV-30573 Server doesn't build with GCOV by GCC 11+ __gcov_flush was never an external symbol in the documentation. It was removed in gcc-11. The correct function to use is __gcov_dump which is defined in the gcov.h header. --- dbug/dbug.c | 6 +++--- mysys/stacktrace.c | 8 ++++---- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/dbug/dbug.c b/dbug/dbug.c index a6d893e3f49..30b92b22dd0 100644 --- a/dbug/dbug.c +++ b/dbug/dbug.c @@ -86,7 +86,7 @@ #include #include #ifdef HAVE_gcov -extern void __gcov_flush(); +#include #endif #ifndef DBUG_OFF @@ -2212,7 +2212,7 @@ void _db_suicide_() fprintf(stderr, "SIGKILL myself\n"); fflush(stderr); #ifdef HAVE_gcov - __gcov_flush(); + __gcov_dump(); #endif retval= kill(getpid(), SIGKILL); @@ -2262,7 +2262,7 @@ my_bool _db_my_assert(const char *file, int line, const char *msg) fprintf(stderr, "%s:%d: assert: %s\n", file, line, msg); fflush(stderr); #ifdef HAVE_gcov - __gcov_flush(); + __gcov_dump(); #endif } return a; diff --git a/mysys/stacktrace.c b/mysys/stacktrace.c index 844d8a0b28f..f203bba4d8d 100644 --- a/mysys/stacktrace.c +++ b/mysys/stacktrace.c @@ -34,6 +34,9 @@ #include #endif +#ifdef HAVE_gcov +#include +#endif /** Default handler for printing stacktrace */ @@ -409,9 +412,6 @@ end: /* Produce a core for the thread */ void my_write_core(int sig) { -#ifdef HAVE_gcov - extern void __gcov_flush(void); -#endif signal(sig, SIG_DFL); #ifdef HAVE_gcov /* @@ -419,7 +419,7 @@ void my_write_core(int sig) information from this process, causing gcov output to be incomplete. So we force the writing of coverage information here before terminating. */ - __gcov_flush(); + __gcov_dump(); #endif pthread_kill(pthread_self(), sig); #if defined(P_MYID) && !defined(SCO) -- cgit v1.2.1 From f4b900e6fa28b9439e7453d6bbc4570aa5ed0ef5 Mon Sep 17 00:00:00 2001 From: Daniel Black Date: Thu, 5 Jan 2023 12:21:20 +1100 Subject: MDEV-24301 [Warning] Aborted connection (This connection closed normally) Warning on a normal graceful disconnnect is excessive, so lets not do it. MDEV-19282 restructed the code from 10.3 so applying this as a 10.4+ fix. --- sql/mysqld.cc | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/sql/mysqld.cc b/sql/mysqld.cc index 9203743adfe..1fd69583ee4 100644 --- a/sql/mysqld.cc +++ b/sql/mysqld.cc @@ -2576,11 +2576,9 @@ void close_connection(THD *thd, uint sql_errno) net_send_error(thd, sql_errno, ER_DEFAULT(sql_errno), NULL); thd->print_aborted_warning(lvl, ER_DEFAULT(sql_errno)); } - else - thd->print_aborted_warning(lvl, (thd->main_security_ctx.user ? - "This connection closed normally" : - "This connection closed normally without" - " authentication")); + else if (!thd->main_security_ctx.user) + thd->print_aborted_warning(lvl, "This connection closed normally without" + " authentication"); thd->disconnect(); -- cgit v1.2.1 From d8c7dc2813a912b7fbb029189fa5ccbf5816f6f9 Mon Sep 17 00:00:00 2001 From: Daniel Bartholomew Date: Mon, 6 Feb 2023 09:34:19 -0500 Subject: bump the VERSION --- VERSION | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/VERSION b/VERSION index 156ceae1801..2abc1c05da3 100644 --- a/VERSION +++ b/VERSION @@ -1,4 +1,4 @@ MYSQL_VERSION_MAJOR=10 MYSQL_VERSION_MINOR=4 -MYSQL_VERSION_PATCH=28 +MYSQL_VERSION_PATCH=29 SERVER_MATURITY=stable -- cgit v1.2.1 From f6da6b249e551cb606005e7a353883d252cba84b Mon Sep 17 00:00:00 2001 From: Daniel Bartholomew Date: Mon, 6 Feb 2023 09:59:18 -0500 Subject: bump the VERSION --- VERSION | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/VERSION b/VERSION index 0283e48b39c..4a712ac1045 100644 --- a/VERSION +++ b/VERSION @@ -1,4 +1,4 @@ MYSQL_VERSION_MAJOR=10 MYSQL_VERSION_MINOR=5 -MYSQL_VERSION_PATCH=19 +MYSQL_VERSION_PATCH=20 SERVER_MATURITY=stable -- cgit v1.2.1 From 80ae69c8bc948382920b083ba203369e941cc90e Mon Sep 17 00:00:00 2001 From: Daniel Bartholomew Date: Mon, 6 Feb 2023 10:24:21 -0500 Subject: bump the VERSION --- VERSION | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/VERSION b/VERSION index 0acffd643c8..017d7bd5ba5 100644 --- a/VERSION +++ b/VERSION @@ -1,4 +1,4 @@ MYSQL_VERSION_MAJOR=10 MYSQL_VERSION_MINOR=6 -MYSQL_VERSION_PATCH=12 +MYSQL_VERSION_PATCH=13 SERVER_MATURITY=stable -- cgit v1.2.1 From d3b84ef458973ca4bbe1e33d94497f929d15a6a3 Mon Sep 17 00:00:00 2001 From: Daniel Bartholomew Date: Mon, 6 Feb 2023 10:49:10 -0500 Subject: bump the VERSION --- VERSION | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/VERSION b/VERSION index 1218ef7f434..215e558a471 100644 --- a/VERSION +++ b/VERSION @@ -1,4 +1,4 @@ MYSQL_VERSION_MAJOR=10 MYSQL_VERSION_MINOR=8 -MYSQL_VERSION_PATCH=7 +MYSQL_VERSION_PATCH=8 SERVER_MATURITY=stable -- cgit v1.2.1 From 93c827150da0ab192677069aad5a7137f83b5af4 Mon Sep 17 00:00:00 2001 From: Daniel Bartholomew Date: Mon, 6 Feb 2023 10:50:17 -0500 Subject: bump the VERSION --- VERSION | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/VERSION b/VERSION index 03da2c314a5..d2c4c84b782 100644 --- a/VERSION +++ b/VERSION @@ -1,4 +1,4 @@ MYSQL_VERSION_MAJOR=10 MYSQL_VERSION_MINOR=9 -MYSQL_VERSION_PATCH=5 +MYSQL_VERSION_PATCH=6 SERVER_MATURITY=stable -- cgit v1.2.1 From dcd93d019acb921fd6129792d5294f88572b48a2 Mon Sep 17 00:00:00 2001 From: Daniel Bartholomew Date: Mon, 6 Feb 2023 10:51:40 -0500 Subject: bump the VERSION --- VERSION | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/VERSION b/VERSION index 4d9021a0d59..96a9a52bfd8 100644 --- a/VERSION +++ b/VERSION @@ -1,4 +1,4 @@ MYSQL_VERSION_MAJOR=10 MYSQL_VERSION_MINOR=10 -MYSQL_VERSION_PATCH=3 +MYSQL_VERSION_PATCH=4 SERVER_MATURITY=stable -- cgit v1.2.1 From 461402a56432fa5cd0f6d53118ccce23081fca18 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marko=20M=C3=A4kel=C3=A4?= Date: Mon, 6 Feb 2023 20:29:29 +0200 Subject: MDEV-30479 OPT_PAGE_CHECKSUM mismatch after innodb_undo_log_truncate=ON page_recv_t::trim(): Do remove log records for mini-transactions that end right at the threshold LSN. This will avoid an inconsistency where a dirty page had been evicted from the buffer pool during undo tablespace truncation, and recovery would attempt to apply log records for which the last available copy in the data file is too new. These changes would be discarded anyway. --- storage/innobase/log/log0recv.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/storage/innobase/log/log0recv.cc b/storage/innobase/log/log0recv.cc index d21251dd2d9..7129de59e64 100644 --- a/storage/innobase/log/log0recv.cc +++ b/storage/innobase/log/log0recv.cc @@ -1616,7 +1616,7 @@ inline bool page_recv_t::trim(lsn_t start_lsn) { while (log.head) { - if (log.head->lsn >= start_lsn) return false; + if (log.head->lsn > start_lsn) return false; last_offset= 1; /* the next record must not be same_page */ log_rec_t *next= log.head->next; recv_sys.free(log.head); -- cgit v1.2.1 From acd23da4c2363511aae7d984c24cc6847aa3f19c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marko=20M=C3=A4kel=C3=A4?= Date: Mon, 6 Feb 2023 20:29:42 +0200 Subject: MDEV-30479 optimization: Invoke recv_sys_t::trim() earlier recv_sys_t::parse(): Discard old page-level redo log when parsing a TRIM_PAGES record. recv_sys_t::apply(): trim() was invoked in parse() already. recv_sys_t::truncated_undo_spaces[]: Only store the size, no LSN. --- storage/innobase/include/log0recv.h | 12 +++--------- storage/innobase/log/log0recv.cc | 14 +++++++------- 2 files changed, 10 insertions(+), 16 deletions(-) diff --git a/storage/innobase/include/log0recv.h b/storage/innobase/include/log0recv.h index e4a8f0d25a2..73d5724f612 100644 --- a/storage/innobase/include/log0recv.h +++ b/storage/innobase/include/log0recv.h @@ -266,15 +266,9 @@ private: @param lsn log sequence number of the shrink operation */ inline void trim(const page_id_t page_id, lsn_t lsn); - /** Undo tablespaces for which truncate has been logged - (indexed by page_id_t::space() - srv_undo_space_id_start) */ - struct trunc - { - /** log sequence number of FILE_CREATE, or 0 if none */ - lsn_t lsn; - /** truncated size of the tablespace, or 0 if not truncated */ - unsigned pages; - } truncated_undo_spaces[127]; + /** Truncated undo tablespace size for which truncate has been logged + (indexed by page_id_t::space() - srv_undo_space_id_start), or 0 */ + unsigned truncated_undo_spaces[127]; public: /** The contents of the doublewrite buffer */ diff --git a/storage/innobase/log/log0recv.cc b/storage/innobase/log/log0recv.cc index 7129de59e64..4a6527962f6 100644 --- a/storage/innobase/log/log0recv.cc +++ b/storage/innobase/log/log0recv.cc @@ -1949,8 +1949,10 @@ same_page: goto record_corrupted; static_assert(UT_ARR_SIZE(truncated_undo_spaces) == TRX_SYS_MAX_UNDO_SPACES, "compatibility"); - truncated_undo_spaces[space_id - srv_undo_space_id_start]= - { recovered_lsn, page_no }; + /* The entire undo tablespace will be reinitialized by + innodb_undo_log_truncate=ON. Discard old log for all pages. */ + trim({space_id, 0}, recovered_lsn); + truncated_undo_spaces[space_id - srv_undo_space_id_start]= page_no; if (undo_space_trunc) undo_space_trunc(space_id); #endif @@ -2675,17 +2677,15 @@ void recv_sys_t::apply(bool last_batch) for (auto id= srv_undo_tablespaces_open; id--;) { - const trunc& t= truncated_undo_spaces[id]; - if (t.lsn) + if (unsigned pages= truncated_undo_spaces[id]) { - trim(page_id_t(id + srv_undo_space_id_start, 0), t.lsn); - if (fil_space_t *space = fil_space_get(id + srv_undo_space_id_start)) + if (fil_space_t *space= fil_space_get(id + srv_undo_space_id_start)) { ut_ad(UT_LIST_GET_LEN(space->chain) == 1); fil_node_t *file= UT_LIST_GET_FIRST(space->chain); ut_ad(file->is_open()); os_file_truncate(file->name, file->handle, - os_offset_t{t.pages} << srv_page_size_shift, true); + os_offset_t{pages} << srv_page_size_shift, true); } } } -- cgit v1.2.1 From 762fe015c15cdf5e0bdc57ac1f9f6f71e7484560 Mon Sep 17 00:00:00 2001 From: Daniel Black Date: Sat, 4 Feb 2023 16:35:30 +1100 Subject: MDEV-30558: ER_KILL_{,QUERY_}DENIED_ERROR - normalize id type The error string from ER_KILL_QUERY_DENIED_ERROR took a different type to ER_KILL_DENIED_ERROR for the thread id. This shows up in differences on 32 big endian arches like powerpc (Deb notation). Normalize the passing of the THD->id to its real type of my_thread_id, and cast to (long long) on output. As such normalize the ER_KILL_QUERY_DENIED_ERROR to that convention too. Note for upwards merge, convert the type to %lld on new translations of ER_KILL_QUERY_DENIED_ERROR. --- sql/share/errmsg-utf8.txt | 10 +++++----- sql/sql_parse.cc | 12 ++++++------ 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/sql/share/errmsg-utf8.txt b/sql/share/errmsg-utf8.txt index dde8337f01c..8bc2b784830 100644 --- a/sql/share/errmsg-utf8.txt +++ b/sql/share/errmsg-utf8.txt @@ -8268,11 +8268,11 @@ ER_INVALID_DEFAULT_VALUE_FOR_FIELD 22007 eng "Incorrect default value '%-.128T' for column '%.192s'" hindi "गलत डिफ़ॉल्ट मान '%-.128T' कॉलम '%.192s' के लिए" ER_KILL_QUERY_DENIED_ERROR - chi "你不是查询%lu的所有者" - eng "You are not owner of query %lu" - ger "Sie sind nicht Eigentümer von Abfrage %lu" - hindi "आप क्वेरी %lu के OWNER नहीं हैं" - rus "Вы не являетесь владельцем запроса %lu" + chi "你不是查询%lld的所有者" + eng "You are not owner of query %lld" + ger "Sie sind nicht Eigentümer von Abfrage %lld" + hindi "आप क्वेरी %lld के OWNER नहीं हैं" + rus "Вы не являетесь владельцем запроса %lld" ER_NO_EIS_FOR_FIELD chi "没有收集无关的统计信息列'%s'" eng "Engine-independent statistics are not collected for column '%s'" diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc index 7840f581789..a00e5b82b12 100644 --- a/sql/sql_parse.cc +++ b/sql/sql_parse.cc @@ -130,7 +130,7 @@ static bool wsrep_mysql_parse(THD *thd, char *rawbuf, uint length, */ static bool execute_sqlcom_select(THD *thd, TABLE_LIST *all_tables); -static void sql_kill(THD *thd, longlong id, killed_state state, killed_type type); +static void sql_kill(THD *thd, my_thread_id id, killed_state state, killed_type type); static void sql_kill_user(THD *thd, LEX_USER *user, killed_state state); static bool lock_tables_precheck(THD *thd, TABLE_LIST *tables); static bool execute_show_status(THD *, TABLE_LIST *); @@ -5616,7 +5616,7 @@ mysql_execute_command(THD *thd) MYF(0)); goto error; } - sql_kill(thd, it->val_int(), lex->kill_signal, lex->kill_type); + sql_kill(thd, (my_thread_id) it->val_int(), lex->kill_signal, lex->kill_type); } else sql_kill_user(thd, get_current_user(thd, lex->users_list.head()), @@ -9146,12 +9146,12 @@ THD *find_thread_by_id(longlong id, bool query_id) */ uint -kill_one_thread(THD *thd, longlong id, killed_state kill_signal, killed_type type) +kill_one_thread(THD *thd, my_thread_id id, killed_state kill_signal, killed_type type) { THD *tmp; uint error= (type == KILL_TYPE_QUERY ? ER_NO_SUCH_QUERY : ER_NO_SUCH_THREAD); DBUG_ENTER("kill_one_thread"); - DBUG_PRINT("enter", ("id: %lld signal: %d", id, kill_signal)); + DBUG_PRINT("enter", ("id: %lld signal: %d", (long long) id, kill_signal)); tmp= find_thread_by_id(id, type == KILL_TYPE_QUERY); if (!tmp) DBUG_RETURN(error); @@ -9323,7 +9323,7 @@ static uint kill_threads_for_user(THD *thd, LEX_USER *user, */ static -void sql_kill(THD *thd, longlong id, killed_state state, killed_type type) +void sql_kill(THD *thd, my_thread_id id, killed_state state, killed_type type) { uint error; #ifdef WITH_WSREP @@ -9352,7 +9352,7 @@ void sql_kill(THD *thd, longlong id, killed_state state, killed_type type) wsrep_error_label: error= (type == KILL_TYPE_QUERY ? ER_KILL_QUERY_DENIED_ERROR : ER_KILL_DENIED_ERROR); - my_error(error, MYF(0), id); + my_error(error, MYF(0), (long long) id); #endif /* WITH_WSREP */ } -- cgit v1.2.1 From ecc93c9824886bb7a06afe9022bf694a60e35cee Mon Sep 17 00:00:00 2001 From: Daniel Black Date: Fri, 3 Feb 2023 16:00:11 +1100 Subject: MDEV-30492 Crash when use mariabackup.exe with config 'innodb_flush_method=async_unbuffered' Normalize innodb_flush_method, the same as the service, before attempting to print it. --- extra/mariabackup/xtrabackup.cc | 11 ++++++++++ .../suite/mariabackup/full_backup_win.result | 12 +++++++++++ mysql-test/suite/mariabackup/full_backup_win.test | 24 ++++++++++++++++++++++ 3 files changed, 47 insertions(+) create mode 100644 mysql-test/suite/mariabackup/full_backup_win.result create mode 100644 mysql-test/suite/mariabackup/full_backup_win.test diff --git a/extra/mariabackup/xtrabackup.cc b/extra/mariabackup/xtrabackup.cc index bb440eec7f8..f7a5d00b92c 100644 --- a/extra/mariabackup/xtrabackup.cc +++ b/extra/mariabackup/xtrabackup.cc @@ -1896,6 +1896,17 @@ xb_get_one_option(int optid, break; case OPT_INNODB_FLUSH_METHOD: +#ifdef _WIN32 + /* From: storage/innobase/handler/ha_innodb.cc:innodb_init_params */ + switch (srv_file_flush_method) { + case SRV_ALL_O_DIRECT_FSYNC + 1 /* "async_unbuffered"="unbuffered" */: + srv_file_flush_method= SRV_ALL_O_DIRECT_FSYNC; + break; + case SRV_ALL_O_DIRECT_FSYNC + 2 /* "normal"="fsync" */: + srv_file_flush_method= SRV_FSYNC; + break; + } +#endif ut_a(srv_file_flush_method <= IF_WIN(SRV_ALL_O_DIRECT_FSYNC, SRV_O_DIRECT_NO_FSYNC)); ADD_PRINT_PARAM_OPT(innodb_flush_method_names[srv_file_flush_method]); diff --git a/mysql-test/suite/mariabackup/full_backup_win.result b/mysql-test/suite/mariabackup/full_backup_win.result new file mode 100644 index 00000000000..940c7056d3f --- /dev/null +++ b/mysql-test/suite/mariabackup/full_backup_win.result @@ -0,0 +1,12 @@ +# +# MDEV-30492 Crash when use mariabackup.exe with config 'innodb_flush_method=async_unbuffered' +# +# xtrabackup backup +# xtrabackup prepare +# shutdown server +# remove datadir +# xtrabackup move back +# restart +# +# End of 10.4 tests +# diff --git a/mysql-test/suite/mariabackup/full_backup_win.test b/mysql-test/suite/mariabackup/full_backup_win.test new file mode 100644 index 00000000000..5a1d1c38026 --- /dev/null +++ b/mysql-test/suite/mariabackup/full_backup_win.test @@ -0,0 +1,24 @@ +--source include/windows.inc + +let $targetdir=$MYSQLTEST_VARDIR/tmp/backup; + +--echo # +--echo # MDEV-30492 Crash when use mariabackup.exe with config 'innodb_flush_method=async_unbuffered' +--echo # + +echo # xtrabackup backup; +--disable_result_log +exec $XTRABACKUP --defaults-file=$MYSQLTEST_VARDIR/my.cnf --innodb_flush_method=normal --backup --target-dir=$targetdir; +--enable_result_log + +echo # xtrabackup prepare; +--disable_result_log +exec $XTRABACKUP --prepare --innodb-flush-method=async_unbuffered --target-dir=$targetdir; +-- source include/restart_and_restore.inc +--enable_result_log + +rmdir $targetdir; + +--echo # +--echo # End of 10.4 tests +--echo # -- cgit v1.2.1 From 17423c6c515032fd474d0154dcdc52ddda73e5c7 Mon Sep 17 00:00:00 2001 From: Daniel Black Date: Fri, 3 Feb 2023 11:51:20 +1100 Subject: MDEV-30554 RockDB libatomic linking on riscv64 The existing storage/rocksdb/CMakeCache.txt defined ATOMIC_EXTRA_LIBS when atomics where required. This was determined by the toplevel configure.cmake test (HAVE_GCC_C11_ATOMICS_WITH_LIBATOMIC). As build_rocksdb.cmake is included after ATOMIC_EXTRA_LIBS was set, we just need to use it. As such no riscv64 specific macro is needed in build_rocksdb.cmake. As highlighted by Gianfranco Costamagna (@LocutusOfBorg) in #2472 overwriting SYSTEM_LIBS was problematic. This is corrected in case in future SYSTEM_LIBS is changed elsewhere. Closes #2472. --- storage/rocksdb/build_rocksdb.cmake | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/storage/rocksdb/build_rocksdb.cmake b/storage/rocksdb/build_rocksdb.cmake index e23862ee659..647e51e2f90 100644 --- a/storage/rocksdb/build_rocksdb.cmake +++ b/storage/rocksdb/build_rocksdb.cmake @@ -129,10 +129,6 @@ if(CMAKE_SYSTEM_PROCESSOR MATCHES "ppc64") ADD_DEFINITIONS(-DHAVE_POWER8 -DHAS_ALTIVEC) endif(CMAKE_SYSTEM_PROCESSOR MATCHES "ppc64") -if(CMAKE_SYSTEM_PROCESSOR STREQUAL "riscv64") - set(SYSTEM_LIBS ${SYSTEM_LIBS} -latomic) -endif() - option(WITH_FALLOCATE "build with fallocate" ON) if(WITH_FALLOCATE AND UNIX) @@ -161,9 +157,9 @@ include_directories(SYSTEM ${ROCKSDB_SOURCE_DIR}/third-party/gtest-1.7.0/fused-s find_package(Threads REQUIRED) if(WIN32) - set(SYSTEM_LIBS ${SYSTEM_LIBS} Shlwapi.lib Rpcrt4.lib) + set(SYSTEM_LIBS ${SYSTEM_LIBS} ${ATOMIC_EXTRA_LIBS} Shlwapi.lib Rpcrt4.lib) else() - set(SYSTEM_LIBS ${CMAKE_THREAD_LIBS_INIT} ${LIBRT} ${CMAKE_DL_LIBS}) + set(SYSTEM_LIBS ${SYSTEM_LIBS} ${CMAKE_THREAD_LIBS_INIT} ${LIBRT} ${CMAKE_DL_LIBS} ${ATOMIC_EXTRA_LIBS}) endif() set(ROCKSDB_LIBS rocksdblib}) -- cgit v1.2.1 From 2b494ccc15d500be9de22140307d6fee1b28bdc8 Mon Sep 17 00:00:00 2001 From: Daniel Black Date: Mon, 6 Feb 2023 18:00:15 +1100 Subject: MDEV-30572: my_large_malloc will only retry on ENOMEM Correct error in to only say "continuing to smaller size" if it really is. --- mysys/my_largepage.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mysys/my_largepage.c b/mysys/my_largepage.c index 0fdc4e17a26..c5fc2a1264e 100644 --- a/mysys/my_largepage.c +++ b/mysys/my_largepage.c @@ -354,7 +354,7 @@ uchar *my_large_malloc(size_t *size, myf my_flags) ptr= NULL; if (my_flags & MY_WME) { - if (large_page_size) + if (large_page_size && errno == ENOMEM) { my_printf_error(EE_OUTOFMEMORY, "Couldn't allocate %zu bytes (Large/HugeTLB memory " -- cgit v1.2.1 From 785386c807478919e1c95f87fc8d45a6c5c23817 Mon Sep 17 00:00:00 2001 From: Daniel Black Date: Thu, 2 Feb 2023 10:03:11 +1100 Subject: innodb: cmake - sched_getcpu removed - not used --- storage/innobase/CMakeLists.txt | 6 ------ 1 file changed, 6 deletions(-) diff --git a/storage/innobase/CMakeLists.txt b/storage/innobase/CMakeLists.txt index 6083d77748a..ae19773d98b 100644 --- a/storage/innobase/CMakeLists.txt +++ b/storage/innobase/CMakeLists.txt @@ -118,12 +118,6 @@ IF(WITH_INNODB_EXTRA_DEBUG) ENDIF() ADD_FEATURE_INFO(INNODB_EXTRA_DEBUG WITH_INNODB_EXTRA_DEBUG "Extra InnoDB debug checks") - -CHECK_FUNCTION_EXISTS(sched_getcpu HAVE_SCHED_GETCPU) -IF(HAVE_SCHED_GETCPU) - ADD_DEFINITIONS(-DHAVE_SCHED_GETCPU=1) -ENDIF() - CHECK_FUNCTION_EXISTS(nanosleep HAVE_NANOSLEEP) IF(HAVE_NANOSLEEP) ADD_DEFINITIONS(-DHAVE_NANOSLEEP=1) -- cgit v1.2.1 From a9eb272f9147b2889b95b3f53353e1c735defaba Mon Sep 17 00:00:00 2001 From: Tuukka Pasanen Date: Wed, 1 Feb 2023 09:49:58 +0200 Subject: MDEV-30534: Remove EOL Debian version 9 (stretch) from autobake-deb.sh Debian 9 has EOL July 6th, 2020. This commit cleans it up from debian/autobake-deb.sh which is used to build official versions of MariaDB --- debian/autobake-deb.sh | 6 ------ 1 file changed, 6 deletions(-) diff --git a/debian/autobake-deb.sh b/debian/autobake-deb.sh index 9ab06d41a5f..aa5a6651cea 100755 --- a/debian/autobake-deb.sh +++ b/debian/autobake-deb.sh @@ -65,12 +65,6 @@ then LSBID="unknown" fi case "${LSBNAME}" in - stretch) - # MDEV-16525 libzstd-dev-1.1.3 minimum version - sed -e '/libzstd-dev/d' \ - -e 's/libcurl4/libcurl3/g' -i debian/control - remove_rocksdb_tools - ;& buster) ;& bullseye|bookworm) -- cgit v1.2.1 From 493f2bca76116c1696d42823e2218b1552aeaf8c Mon Sep 17 00:00:00 2001 From: Vladislav Vaintroub Date: Tue, 7 Feb 2023 14:04:37 +0100 Subject: Add more workaround atop existing WolfSSL 5.5.4 workaround to compile ASAN on buildbot The -D flag was not passed to asm compiler, despite SET_PROPERTY(COMPILE_OPTIONS) The exact reason for that remains unknown. It was not seen with gcc, as nor was be reproduced on newer CMake. --- extra/wolfssl/CMakeLists.txt | 3 +++ 1 file changed, 3 insertions(+) diff --git a/extra/wolfssl/CMakeLists.txt b/extra/wolfssl/CMakeLists.txt index 7bd5f1694ed..0aee5865867 100644 --- a/extra/wolfssl/CMakeLists.txt +++ b/extra/wolfssl/CMakeLists.txt @@ -12,6 +12,9 @@ IF(MSVC) SET(WOLFSSL_X86_64_BUILD 1) SET(HAVE_INTEL_RDSEED 1) SET(HAVE_INTEL_RDRAND 1) +ELSEIF(CMAKE_ASM_COMPILER_ID MATCHES "Clang" AND CMAKE_VERSION VERSION_LESS 3.16) + + # WolfSSL 5.5.4 bug workaround below does not work, due to some CMake bug ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|amd64") SET(WOLFSSL_X86_64_BUILD 1) IF(CMAKE_C_COMPILER_ID MATCHES GNU AND CMAKE_C_COMPILER_VERSION VERSION_LESS 4.9) -- cgit v1.2.1 From aa028e02c3342c3e35a552beecf8f0f3110dc8d0 Mon Sep 17 00:00:00 2001 From: Vladislav Vaintroub Date: Thu, 9 Feb 2023 09:15:08 +0100 Subject: Update Windows time zone mappings using latest CLDR data --- sql/win_tzname_data.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sql/win_tzname_data.h b/sql/win_tzname_data.h index 792cdbc7a13..8a240118ac3 100644 --- a/sql/win_tzname_data.h +++ b/sql/win_tzname_data.h @@ -44,7 +44,7 @@ {L"UTC-02","Etc/GMT+2"}, {L"Azores Standard Time","Atlantic/Azores"}, {L"Cape Verde Standard Time","Atlantic/Cape_Verde"}, -{L"UTC","Etc/GMT"}, +{L"UTC","Etc/UTC"}, {L"GMT Standard Time","Europe/London"}, {L"Greenwich Standard Time","Atlantic/Reykjavik"}, {L"Sao Tome Standard Time","Africa/Sao_Tome"}, @@ -64,6 +64,7 @@ {L"South Africa Standard Time","Africa/Johannesburg"}, {L"FLE Standard Time","Europe/Kiev"}, {L"Israel Standard Time","Asia/Jerusalem"}, +{L"South Sudan Standard Time","Africa/Juba"}, {L"Kaliningrad Standard Time","Europe/Kaliningrad"}, {L"Sudan Standard Time","Africa/Khartoum"}, {L"Libya Standard Time","Africa/Tripoli"}, -- cgit v1.2.1 From 8dab66141619f7e6a541a8d4a848596e919e9593 Mon Sep 17 00:00:00 2001 From: Vladislav Vaintroub Date: Thu, 9 Feb 2023 10:32:25 +0100 Subject: MDEV-30624 HeidiSQL 12.3 --- win/packaging/heidisql.cmake | 2 +- win/packaging/heidisql.wxi.in | 31 ++++++++++++++++++++++++++++++- 2 files changed, 31 insertions(+), 2 deletions(-) diff --git a/win/packaging/heidisql.cmake b/win/packaging/heidisql.cmake index b406e918b8f..45a407371ba 100644 --- a/win/packaging/heidisql.cmake +++ b/win/packaging/heidisql.cmake @@ -1,4 +1,4 @@ -SET(HEIDISQL_BASE_NAME "HeidiSQL_11.3_32_Portable") +SET(HEIDISQL_BASE_NAME "HeidiSQL_12.3_32_Portable") SET(HEIDISQL_ZIP "${HEIDISQL_BASE_NAME}.zip") SET(HEIDISQL_URL "http://www.heidisql.com/downloads/releases/${HEIDISQL_ZIP}") SET(HEIDISQL_DOWNLOAD_DIR ${THIRD_PARTY_DOWNLOAD_LOCATION}/${HEIDISQL_BASE_NAME}) diff --git a/win/packaging/heidisql.wxi.in b/win/packaging/heidisql.wxi.in index 58d95210783..831efb6971f 100644 --- a/win/packaging/heidisql.wxi.in +++ b/win/packaging/heidisql.wxi.in @@ -34,7 +34,6 @@ - @@ -63,6 +62,29 @@ + + + + + + + + + + + + + + + + + + + + + + @@ -91,6 +113,13 @@ + + + + + + + -- cgit v1.2.1 From 08c852026ddaa1ae7717aa31950946c9da457f1f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vicen=C8=9Biu=20Ciorbaru?= Date: Tue, 7 Feb 2023 13:57:20 +0200 Subject: Apply clang-tidy to remove empty constructors / destructors This patch is the result of running run-clang-tidy -fix -header-filter=.* -checks='-*,modernize-use-equals-default' . Code style changes have been done on top. The result of this change leads to the following improvements: 1. Binary size reduction. * For a -DBUILD_CONFIG=mysql_release build, the binary size is reduced by ~400kb. * A raw -DCMAKE_BUILD_TYPE=Release reduces the binary size by ~1.4kb. 2. Compiler can better understand the intent of the code, thus it leads to more optimization possibilities. Additionally it enabled detecting unused variables that had an empty default constructor but not marked so explicitly. Particular change required following this patch in sql/opt_range.cc result_keys, an unused template class Bitmap now correctly issues unused variable warnings. Setting Bitmap template class constructor to default allows the compiler to identify that there are no side-effects when instantiating the class. Previously the compiler could not issue the warning as it assumed Bitmap class (being a template) would not be performing a NO-OP for its default constructor. This prevented the "unused variable warning". --- client/mysqlbinlog.cc | 4 +- include/ilist.h | 7 +- include/my_atomic_wrapper.h | 2 +- include/my_counter.h | 2 +- include/span.h | 2 +- mysys_ssl/my_crypt.cc | 2 +- plugin/handler_socket/handlersocket/database.cpp | 8 +- plugin/handler_socket/handlersocket/database.hpp | 6 +- plugin/handler_socket/handlersocket/hstcpsvr.hpp | 2 +- .../handlersocket/hstcpsvr_worker.hpp | 2 +- plugin/handler_socket/libhsclient/hstcpcli.hpp | 2 +- plugin/handler_socket/libhsclient/util.hpp | 2 +- plugin/query_response_time/query_response_time.cc | 2 +- plugin/versioning/versioning.cc | 8 +- sql/derived_handler.h | 2 +- sql/event_data_objects.cc | 8 +- sql/event_db_repository.h | 2 +- sql/field.h | 10 +- sql/filesort_utils.h | 14 +- sql/gcalc_slicescan.h | 2 +- sql/group_by_handler.h | 2 +- sql/handler.h | 24 +- sql/hash_filo.h | 2 +- sql/hostname.cc | 3 +- sql/item.h | 20 +- sql/item_buff.cc | 2 +- sql/item_cmpfunc.h | 55 +- sql/item_create.cc | 940 ++++++++++----------- sql/item_create.h | 16 +- sql/item_func.cc | 2 +- sql/item_func.h | 5 +- sql/item_geofunc.cc | 4 +- sql/item_inetfunc.cc | 4 +- sql/item_subselect.h | 2 +- sql/item_sum.h | 2 +- sql/log.cc | 10 +- sql/log.h | 12 +- sql/log_event.cc | 6 +- sql/log_event.h | 31 +- sql/mdl.cc | 14 +- sql/mdl.h | 8 +- sql/multi_range_read.h | 2 +- sql/my_apc.h | 2 +- sql/my_json_writer.h | 4 +- sql/mysqld.cc | 9 +- sql/opt_range.cc | 23 +- sql/opt_range.h | 4 +- sql/opt_table_elimination.cc | 4 +- sql/parse_file.h | 6 +- sql/partition_element.h | 2 +- sql/partition_info.h | 2 +- sql/protocol.h | 2 +- sql/rowid_filter.h | 4 +- sql/rpl_injector.cc | 4 +- sql/rpl_injector.h | 2 +- sql/select_handler.h | 2 +- sql/semisync_master.h | 2 +- sql/semisync_master_ack_receiver.h | 2 +- sql/semisync_slave.h | 2 +- sql/session_tracker.h | 2 +- sql/set_var.h | 6 +- sql/sp.h | 2 +- sql/sp_head.h | 66 +- sql/spatial.h | 32 +- sql/sql_acl.cc | 15 +- sql/sql_acl.h | 12 +- sql/sql_admin.h | 24 +- sql/sql_alter.h | 15 +- sql/sql_base.cc | 2 +- sql/sql_base.h | 2 +- sql/sql_bitmap.h | 2 +- sql/sql_cache.h | 14 +- sql/sql_class.cc | 4 +- sql/sql_class.h | 30 +- sql/sql_cmd.h | 6 +- sql/sql_crypt.h | 4 +- sql/sql_cursor.cc | 4 +- sql/sql_debug.h | 2 +- sql/sql_error.h | 10 +- sql/sql_explain.h | 4 +- sql/sql_expression_cache.h | 4 +- sql/sql_join_cache.h | 4 +- sql/sql_lex.h | 24 +- sql/sql_lifo_buffer.h | 2 +- sql/sql_partition_admin.h | 21 +- sql/sql_prepare.cc | 4 +- sql/sql_prepare.h | 2 +- sql/sql_schema.h | 2 +- sql/sql_select.h | 4 +- sql/sql_show.cc | 6 +- sql/sql_signal.h | 9 +- sql/sql_statistics.cc | 4 +- sql/sql_string.h | 7 +- sql/sql_truncate.h | 6 +- sql/sql_type.h | 108 +-- sql/sql_type_json.h | 2 +- sql/sql_window.cc | 4 +- sql/sql_window.h | 2 +- sql/structs.h | 4 +- sql/sys_vars_shared.h | 2 +- sql/table.cc | 2 +- sql/table.h | 21 +- sql/threadpool.h | 5 +- sql/threadpool_generic.cc | 3 +- sql/tztime.cc | 4 +- sql/tztime.h | 4 +- sql/vers_string.h | 2 +- sql/wsrep_condition_variable.h | 3 +- sql/wsrep_schema.cc | 7 +- sql/wsrep_server_state.cc | 3 +- storage/archive/ha_archive.h | 4 +- storage/blackhole/ha_blackhole.h | 4 +- storage/connect/blkfil.h | 12 +- storage/connect/block.h | 2 +- storage/connect/bson.h | 4 +- storage/connect/bsonudf.h | 2 +- storage/connect/catalog.h | 2 +- storage/connect/colblk.h | 6 +- storage/connect/csort.h | 2 +- storage/connect/filamdbf.h | 2 +- storage/connect/filter.h | 2 +- storage/connect/jsonudf.h | 2 +- storage/connect/tabbson.h | 2 +- storage/connect/tabdos.h | 2 +- storage/connect/tabfix.h | 2 +- storage/connect/tabfmt.h | 2 +- storage/connect/tabjmg.h | 2 +- storage/connect/tabjson.h | 2 +- storage/connect/tabmul.h | 2 +- storage/connect/taboccur.h | 4 +- storage/connect/tabpivot.h | 2 +- storage/connect/tabsys.h | 4 +- storage/connect/tabutil.h | 2 +- storage/connect/tabvct.h | 2 +- storage/connect/tabvir.h | 4 +- storage/connect/tabxcl.h | 2 +- storage/connect/tabzip.h | 4 +- storage/connect/xtable.h | 2 +- storage/example/ha_example.h | 4 +- storage/federated/ha_federated.cc | 2 +- storage/federated/ha_federated.h | 2 +- storage/federatedx/federatedx_io_null.cc | 4 +- storage/federatedx/federatedx_pushdown.cc | 4 +- storage/federatedx/ha_federatedx.cc | 2 +- storage/federatedx/ha_federatedx.h | 2 +- storage/heap/ha_heap.h | 2 +- storage/innobase/handler/ha_innodb.cc | 6 +- storage/innobase/include/buf0buf.h | 8 +- storage/innobase/include/dict0types.h | 2 +- storage/innobase/include/ib0mutex.h | 2 +- storage/innobase/include/os0file.h | 2 +- storage/innobase/include/rem0rec.h | 2 +- storage/innobase/include/row0mysql.h | 2 +- storage/innobase/include/sync0types.h | 4 +- storage/innobase/include/trx0purge.h | 2 +- storage/innobase/include/ut0mutex.h | 4 +- storage/innobase/include/ut0new.h | 2 +- storage/innobase/include/ut0ut.h | 2 +- storage/innobase/row/row0import.cc | 6 +- storage/innobase/trx/trx0trx.cc | 4 +- storage/maria/ha_maria.h | 2 +- storage/mroonga/lib/mrn_count_skip_checker.cpp | 3 +- storage/mroonga/lib/mrn_database_repairer.cpp | 3 +- storage/mroonga/lib/mrn_field_normalizer.cpp | 3 +- .../mroonga/lib/mrn_multiple_column_key_codec.cpp | 3 +- storage/mroonga/lib/mrn_query_parser.cpp | 3 +- storage/mroonga/lib/mrn_time_converter.cpp | 6 +- storage/mroonga/vendor/groonga/lib/dat/array.hpp | 2 +- storage/mroonga/vendor/groonga/lib/dat/cursor.hpp | 4 +- storage/mroonga/vendor/groonga/lib/dat/dat.hpp | 10 +- .../mroonga/vendor/groonga/lib/dat/id-cursor.cpp | 2 +- storage/mroonga/vendor/groonga/lib/dat/key.hpp | 2 +- .../vendor/groonga/lib/dat/predictive-cursor.cpp | 2 +- .../vendor/groonga/lib/dat/prefix-cursor.cpp | 2 +- storage/mroonga/vendor/groonga/lib/dat/string.hpp | 4 +- storage/mroonga/vendor/groonga/lib/dat/trie.cpp | 2 +- storage/myisam/ha_myisam.h | 2 +- storage/perfschema/cursor_by_account.h | 3 +- storage/perfschema/cursor_by_host.h | 3 +- storage/perfschema/cursor_by_thread.h | 3 +- storage/perfschema/cursor_by_thread_connect_attr.h | 3 +- storage/perfschema/cursor_by_user.h | 3 +- storage/perfschema/ha_perfschema.cc | 3 +- storage/perfschema/pfs_engine_table.cc | 6 +- storage/perfschema/pfs_engine_table.h | 33 +- storage/perfschema/pfs_visitor.cc | 88 +- storage/perfschema/pfs_visitor.h | 12 +- storage/perfschema/table_accounts.h | 3 +- storage/perfschema/table_all_instr.h | 3 +- .../table_esgs_by_account_by_event_name.h | 3 +- .../perfschema/table_esgs_by_host_by_event_name.h | 3 +- .../table_esgs_by_thread_by_event_name.h | 3 +- .../perfschema/table_esgs_by_user_by_event_name.h | 3 +- .../perfschema/table_esgs_global_by_event_name.h | 3 +- .../table_esms_by_account_by_event_name.h | 3 +- storage/perfschema/table_esms_by_digest.h | 3 +- .../perfschema/table_esms_by_host_by_event_name.h | 3 +- .../table_esms_by_thread_by_event_name.h | 3 +- .../perfschema/table_esms_by_user_by_event_name.h | 3 +- .../perfschema/table_esms_global_by_event_name.h | 3 +- storage/perfschema/table_events_stages.h | 12 +- storage/perfschema/table_events_statements.h | 12 +- storage/perfschema/table_events_waits.h | 12 +- storage/perfschema/table_events_waits_summary.h | 3 +- .../table_ews_by_account_by_event_name.h | 3 +- .../perfschema/table_ews_by_host_by_event_name.h | 3 +- .../perfschema/table_ews_by_thread_by_event_name.h | 3 +- .../perfschema/table_ews_by_user_by_event_name.h | 3 +- .../perfschema/table_ews_global_by_event_name.h | 3 +- storage/perfschema/table_file_instances.h | 3 +- .../perfschema/table_file_summary_by_event_name.h | 3 +- .../perfschema/table_file_summary_by_instance.h | 3 +- storage/perfschema/table_host_cache.h | 3 +- storage/perfschema/table_hosts.h | 3 +- storage/perfschema/table_os_global_by_type.h | 3 +- storage/perfschema/table_performance_timers.h | 3 +- .../table_session_account_connect_attrs.h | 3 +- storage/perfschema/table_session_connect_attrs.h | 3 +- storage/perfschema/table_setup_actors.h | 3 +- storage/perfschema/table_setup_consumers.h | 3 +- storage/perfschema/table_setup_instruments.h | 3 +- storage/perfschema/table_setup_objects.h | 3 +- storage/perfschema/table_setup_timers.h | 3 +- storage/perfschema/table_socket_instances.h | 3 +- .../table_socket_summary_by_event_name.h | 3 +- .../perfschema/table_socket_summary_by_instance.h | 3 +- storage/perfschema/table_sync_instances.h | 9 +- storage/perfschema/table_threads.h | 3 +- storage/perfschema/table_tiws_by_index_usage.h | 3 +- storage/perfschema/table_tiws_by_table.h | 3 +- storage/perfschema/table_tlws_by_table.h | 3 +- storage/perfschema/table_users.h | 3 +- storage/rocksdb/ha_rocksdb.cc | 2 +- storage/rocksdb/ha_rocksdb.h | 2 +- storage/rocksdb/rdb_compact_filter.h | 4 +- storage/rocksdb/rdb_datadic.h | 4 +- storage/rocksdb/rdb_mutex_wrapper.h | 4 +- storage/rocksdb/rdb_threads.h | 2 +- storage/sequence/sequence.cc | 2 +- storage/spider/hs_client/hstcpcli.hpp | 2 +- storage/spider/hs_client/util.hpp | 2 +- storage/spider/spd_db_include.h | 20 +- 242 files changed, 1101 insertions(+), 1341 deletions(-) diff --git a/client/mysqlbinlog.cc b/client/mysqlbinlog.cc index 79f567d4186..aa994df7557 100644 --- a/client/mysqlbinlog.cc +++ b/client/mysqlbinlog.cc @@ -303,8 +303,8 @@ class Load_log_processor } public: - Load_log_processor() {} - ~Load_log_processor() {} + Load_log_processor() = default; + ~Load_log_processor() = default; int init() { diff --git a/include/ilist.h b/include/ilist.h index 6e7219937dd..f9afb5ec986 100644 --- a/include/ilist.h +++ b/include/ilist.h @@ -27,12 +27,11 @@ // Derive your class from this struct to insert to a linked list. template struct ilist_node { - ilist_node() noexcept #ifndef DBUG_OFF - : next(NULL), prev(NULL) + ilist_node() noexcept : next(NULL), prev(NULL) {} +#else + ilist_node() = default; #endif - { - } ilist_node(ilist_node *next, ilist_node *prev) noexcept : next(next), prev(prev) diff --git a/include/my_atomic_wrapper.h b/include/my_atomic_wrapper.h index c574fba4a8e..f5a4b8b80d3 100644 --- a/include/my_atomic_wrapper.h +++ b/include/my_atomic_wrapper.h @@ -39,7 +39,7 @@ public: Atomic_relaxed(const Atomic_relaxed &rhs) { m.store(rhs, std::memory_order_relaxed); } Atomic_relaxed(Type val) : m(val) {} - Atomic_relaxed() {} + Atomic_relaxed() = default; operator Type() const { return m.load(std::memory_order_relaxed); } Type operator=(const Type val) diff --git a/include/my_counter.h b/include/my_counter.h index c5cbe296df0..f85b8e80bd7 100644 --- a/include/my_counter.h +++ b/include/my_counter.h @@ -31,7 +31,7 @@ public: Atomic_counter(const Atomic_counter &rhs) { m_counter.store(rhs, std::memory_order_relaxed); } Atomic_counter(Type val): m_counter(val) {} - Atomic_counter() {} + Atomic_counter() = default; Type operator++(int) { return add(1); } Type operator--(int) { return sub(1); } diff --git a/include/span.h b/include/span.h index 0e8516933c6..4ea200f5494 100644 --- a/include/span.h +++ b/include/span.h @@ -81,7 +81,7 @@ public: span(const span &other) : data_(other.data_), size_(other.size_) {} - ~span(){}; + ~span() = default; span &operator=(const span &other) { diff --git a/mysys_ssl/my_crypt.cc b/mysys_ssl/my_crypt.cc index e512eee9066..a8643f6e5b6 100644 --- a/mysys_ssl/my_crypt.cc +++ b/mysys_ssl/my_crypt.cc @@ -104,7 +104,7 @@ public: uchar oiv[MY_AES_BLOCK_SIZE]; MyCTX_nopad() : MyCTX() { } - ~MyCTX_nopad() { } + ~MyCTX_nopad() = default; int init(const EVP_CIPHER *cipher, int encrypt, const uchar *key, uint klen, const uchar *iv, uint ivlen) diff --git a/plugin/handler_socket/handlersocket/database.cpp b/plugin/handler_socket/handlersocket/database.cpp index 9c0a2d81b98..17a7cd78c58 100644 --- a/plugin/handler_socket/handlersocket/database.cpp +++ b/plugin/handler_socket/handlersocket/database.cpp @@ -189,9 +189,7 @@ database::database(const config& c) { } -database::~database() -{ -} +database::~database() = default; dbcontext_ptr database::create_context(bool for_write) volatile @@ -226,9 +224,7 @@ dbcontext::dbcontext(volatile database *d, bool for_write) user_level_lock_timeout = d->get_conf().get_int("wrlock_timeout", 12); } -dbcontext::~dbcontext() -{ -} +dbcontext::~dbcontext() = default; namespace { diff --git a/plugin/handler_socket/handlersocket/database.hpp b/plugin/handler_socket/handlersocket/database.hpp index a4aee0874c7..ed5d00800d9 100644 --- a/plugin/handler_socket/handlersocket/database.hpp +++ b/plugin/handler_socket/handlersocket/database.hpp @@ -27,7 +27,7 @@ struct dbcontext_i; typedef std::auto_ptr dbcontext_ptr; struct database_i { - virtual ~database_i() { } + virtual ~database_i() = default; virtual dbcontext_ptr create_context(bool for_write) volatile = 0; virtual void stop() volatile = 0; virtual const config& get_conf() const volatile = 0; @@ -57,7 +57,7 @@ struct prep_stmt { }; struct dbcallback_i { - virtual ~dbcallback_i () { } + virtual ~dbcallback_i() = default; virtual void dbcb_set_prep_stmt(size_t pst_id, const prep_stmt& v) = 0; virtual const prep_stmt *dbcb_get_prep_stmt(size_t pst_id) const = 0; virtual void dbcb_resp_short(uint32_t code, const char *msg) = 0; @@ -111,7 +111,7 @@ struct cmd_exec_args { }; struct dbcontext_i { - virtual ~dbcontext_i() { } + virtual ~dbcontext_i() = default; virtual void init_thread(const void *stack_bottom, volatile int& shutdown_flag) = 0; virtual void term_thread() = 0; diff --git a/plugin/handler_socket/handlersocket/hstcpsvr.hpp b/plugin/handler_socket/handlersocket/hstcpsvr.hpp index 811bfa25613..5fbed92402b 100644 --- a/plugin/handler_socket/handlersocket/hstcpsvr.hpp +++ b/plugin/handler_socket/handlersocket/hstcpsvr.hpp @@ -47,7 +47,7 @@ struct hstcpsvr_i; typedef std::auto_ptr hstcpsvr_ptr; struct hstcpsvr_i { - virtual ~hstcpsvr_i() { } + virtual ~hstcpsvr_i() = default; virtual std::string start_listen() = 0; static hstcpsvr_ptr create(const config& conf); }; diff --git a/plugin/handler_socket/handlersocket/hstcpsvr_worker.hpp b/plugin/handler_socket/handlersocket/hstcpsvr_worker.hpp index 497581c27a7..25612adec0f 100644 --- a/plugin/handler_socket/handlersocket/hstcpsvr_worker.hpp +++ b/plugin/handler_socket/handlersocket/hstcpsvr_worker.hpp @@ -24,7 +24,7 @@ struct hstcpsvr_worker_arg { }; struct hstcpsvr_worker_i { - virtual ~hstcpsvr_worker_i() { } + virtual ~hstcpsvr_worker_i() = default; virtual void run() = 0; static hstcpsvr_worker_ptr create(const hstcpsvr_worker_arg& arg); }; diff --git a/plugin/handler_socket/libhsclient/hstcpcli.hpp b/plugin/handler_socket/libhsclient/hstcpcli.hpp index 11dec8ebb0b..fa0d4db1742 100644 --- a/plugin/handler_socket/libhsclient/hstcpcli.hpp +++ b/plugin/handler_socket/libhsclient/hstcpcli.hpp @@ -33,7 +33,7 @@ struct hstcpcli_i; typedef std::auto_ptr hstcpcli_ptr; struct hstcpcli_i { - virtual ~hstcpcli_i() { } + virtual ~hstcpcli_i() = default; virtual void close() = 0; virtual int reconnect() = 0; virtual bool stable_point() = 0; diff --git a/plugin/handler_socket/libhsclient/util.hpp b/plugin/handler_socket/libhsclient/util.hpp index 93d78cc7dc0..60b5441703d 100644 --- a/plugin/handler_socket/libhsclient/util.hpp +++ b/plugin/handler_socket/libhsclient/util.hpp @@ -13,7 +13,7 @@ namespace dena { /* boost::noncopyable */ struct noncopyable { - noncopyable() { } + noncopyable() = default; private: noncopyable(const noncopyable&); noncopyable& operator =(const noncopyable&); diff --git a/plugin/query_response_time/query_response_time.cc b/plugin/query_response_time/query_response_time.cc index a669f7d4236..e344f45b392 100644 --- a/plugin/query_response_time/query_response_time.cc +++ b/plugin/query_response_time/query_response_time.cc @@ -153,7 +153,7 @@ class time_collector public: time_collector(utility& u): m_utility(&u) { flush(); } - ~time_collector() { } + ~time_collector() = default; uint32_t count(uint index) { return m_count[index]; } uint64_t total(uint index) { return m_total[index]; } void flush() diff --git a/plugin/versioning/versioning.cc b/plugin/versioning/versioning.cc index fd0e7099666..e150e4e8465 100644 --- a/plugin/versioning/versioning.cc +++ b/plugin/versioning/versioning.cc @@ -35,8 +35,8 @@ public: static Create_func_trt s_singleton; protected: - Create_func_trt() {} - virtual ~Create_func_trt() {} + Create_func_trt() = default; + virtual ~Create_func_trt() = default; }; template @@ -131,8 +131,8 @@ public: static Create_func_trt_trx_sees s_singleton; protected: - Create_func_trt_trx_sees() {} - virtual ~Create_func_trt_trx_sees() {} + Create_func_trt_trx_sees() = default; + virtual ~Create_func_trt_trx_sees() = default; }; template diff --git a/sql/derived_handler.h b/sql/derived_handler.h index 171165bbe6f..f6feed8db32 100644 --- a/sql/derived_handler.h +++ b/sql/derived_handler.h @@ -56,7 +56,7 @@ public: derived_handler(THD *thd_arg, handlerton *ht_arg) : thd(thd_arg), ht(ht_arg), derived(0),table(0), tmp_table_param(0), unit(0), select(0) {} - virtual ~derived_handler() {} + virtual ~derived_handler() = default; /* Functions to scan data. All these returns 0 if ok, error code in case diff --git a/sql/event_data_objects.cc b/sql/event_data_objects.cc index f47e390c883..95b88abc2a9 100644 --- a/sql/event_data_objects.cc +++ b/sql/event_data_objects.cc @@ -314,9 +314,7 @@ Event_queue_element::Event_queue_element(): SYNOPSIS Event_queue_element::Event_queue_element() */ -Event_queue_element::~Event_queue_element() -{ -} +Event_queue_element::~Event_queue_element() = default; /* @@ -342,9 +340,7 @@ Event_timed::Event_timed(): Event_timed::~Event_timed() */ -Event_timed::~Event_timed() -{ -} +Event_timed::~Event_timed() = default; /* diff --git a/sql/event_db_repository.h b/sql/event_db_repository.h index b89a1a15155..29b5031bc28 100644 --- a/sql/event_db_repository.h +++ b/sql/event_db_repository.h @@ -71,7 +71,7 @@ class Event_parse_data; class Event_db_repository { public: - Event_db_repository(){} + Event_db_repository() = default; bool create_event(THD *thd, Event_parse_data *parse_data, diff --git a/sql/field.h b/sql/field.h index 6388fa2e08e..23bb00e68cb 100644 --- a/sql/field.h +++ b/sql/field.h @@ -562,7 +562,7 @@ public: name.length= 0; }; Virtual_column_info* clone(THD *thd); - ~Virtual_column_info() {}; + ~Virtual_column_info() = default; enum_vcol_info_type get_vcol_type() const { return vcol_type; @@ -761,7 +761,7 @@ public: Field(uchar *ptr_arg,uint32 length_arg,uchar *null_ptr_arg, uchar null_bit_arg, utype unireg_check_arg, const LEX_CSTRING *field_name_arg); - virtual ~Field() {} + virtual ~Field() = default; DTCollation dtcollation() const { @@ -5215,7 +5215,7 @@ public: LEX_CSTRING col_name, org_col_name; ulong length; uint flags, decimals; - Send_field() {} + Send_field() = default; Send_field(Field *field) { field->make_send_field(this); @@ -5320,8 +5320,8 @@ public: Field *from_field,*to_field; String tmp; // For items - Copy_field() {} - ~Copy_field() {} + Copy_field() = default; + ~Copy_field() = default; void set(Field *to,Field *from,bool save); // Field to field void set(uchar *to,Field *from); // Field to string void (*do_copy)(Copy_field *); diff --git a/sql/filesort_utils.h b/sql/filesort_utils.h index 1ab1ba2daa8..1f80c145c70 100644 --- a/sql/filesort_utils.h +++ b/sql/filesort_utils.h @@ -112,17 +112,11 @@ public: /** We need an assignment operator, see filesort(). This happens to have the same semantics as the one that would be - generated by the compiler. We still implement it here, to show shallow - assignment explicitly: we have two objects sharing the same array. + generated by the compiler. + Note that this is a shallow copy. We have two objects sharing the same + array. */ - Filesort_buffer &operator=(const Filesort_buffer &rhs) - { - m_idx_array= rhs.m_idx_array; - m_record_length= rhs.m_record_length; - m_start_of_data= rhs.m_start_of_data; - allocated_size= rhs.allocated_size; - return *this; - } + Filesort_buffer &operator=(const Filesort_buffer &rhs) = default; private: typedef Bounds_checked_array Idx_array; diff --git a/sql/gcalc_slicescan.h b/sql/gcalc_slicescan.h index b5188f29dfd..37e887e87e5 100644 --- a/sql/gcalc_slicescan.h +++ b/sql/gcalc_slicescan.h @@ -344,7 +344,7 @@ public: { return complete_ring() || complete_poly(); } - virtual ~Gcalc_shape_transporter() {} + virtual ~Gcalc_shape_transporter() = default; }; diff --git a/sql/group_by_handler.h b/sql/group_by_handler.h index 108ebc989d9..d025cc766d6 100644 --- a/sql/group_by_handler.h +++ b/sql/group_by_handler.h @@ -72,7 +72,7 @@ public: group_by_handler(THD *thd_arg, handlerton *ht_arg) : thd(thd_arg), ht(ht_arg), table(0) {} - virtual ~group_by_handler() {} + virtual ~group_by_handler() = default; /* Functions to scan data. All these returns 0 if ok, error code in case diff --git a/sql/handler.h b/sql/handler.h index f7a2838b3d9..6085111bc25 100644 --- a/sql/handler.h +++ b/sql/handler.h @@ -842,7 +842,7 @@ struct xid_t { long bqual_length; char data[XIDDATASIZE]; // not \0-terminated ! - xid_t() {} /* Remove gcc warning */ + xid_t() = default; /* Remove gcc warning */ bool eq(struct xid_t *xid) const { return !xid->is_null() && eq(xid->gtrid_length, xid->bqual_length, xid->data); } bool eq(long g, long b, const char *d) const @@ -1529,7 +1529,7 @@ struct handlerton public: virtual bool add_table(const char *tname, size_t tlen) = 0; virtual bool add_file(const char *fname) = 0; - protected: virtual ~discovered_list() {} + protected: virtual ~discovered_list() = default; }; /* @@ -1710,7 +1710,7 @@ struct THD_TRANS m_unsafe_rollback_flags= 0; } bool is_empty() const { return ha_list == NULL; } - THD_TRANS() {} /* Remove gcc warning */ + THD_TRANS() = default; /* Remove gcc warning */ unsigned int m_unsafe_rollback_flags; /* @@ -1954,7 +1954,7 @@ struct Table_period_info: Sql_alloc struct start_end_t { - start_end_t() {}; + start_end_t() = default; start_end_t(const LEX_CSTRING& _start, const LEX_CSTRING& _end) : start(_start), end(_end) {} @@ -2262,9 +2262,9 @@ struct Table_specification_st: public HA_CREATE_INFO, class inplace_alter_handler_ctx : public Sql_alloc { public: - inplace_alter_handler_ctx() {} + inplace_alter_handler_ctx() = default; - virtual ~inplace_alter_handler_ctx() {} + virtual ~inplace_alter_handler_ctx() = default; virtual void set_shared_data(const inplace_alter_handler_ctx& ctx) {} }; @@ -2490,8 +2490,8 @@ typedef struct st_key_create_information class TABLEOP_HOOKS { public: - TABLEOP_HOOKS() {} - virtual ~TABLEOP_HOOKS() {} + TABLEOP_HOOKS() = default; + virtual ~TABLEOP_HOOKS() = default; inline void prelock(TABLE **tables, uint count) { @@ -2532,7 +2532,7 @@ typedef class Item COND; typedef struct st_ha_check_opt { - st_ha_check_opt() {} /* Remove gcc warning */ + st_ha_check_opt() = default; /* Remove gcc warning */ uint flags; /* isam layer flags (e.g. for myisamchk) */ uint sql_flags; /* sql layer flags - for something myisamchk cannot do */ time_t start_time; /* When check/repair starts */ @@ -2911,8 +2911,8 @@ uint calculate_key_len(TABLE *, uint, const uchar *, key_part_map); class Handler_share { public: - Handler_share() {} - virtual ~Handler_share() {} + Handler_share() = default; + virtual ~Handler_share() = default; }; enum class Compare_keys : uint32_t @@ -4969,7 +4969,7 @@ public: const LEX_CSTRING *wild_arg); Discovered_table_list(THD *thd_arg, Dynamic_array *tables_arg) : thd(thd_arg), wild(NULL), with_temps(true), tables(tables_arg) {} - ~Discovered_table_list() {} + ~Discovered_table_list() = default; bool add_table(const char *tname, size_t tlen); bool add_file(const char *fname); diff --git a/sql/hash_filo.h b/sql/hash_filo.h index d815c428ac6..7aa905a852b 100644 --- a/sql/hash_filo.h +++ b/sql/hash_filo.h @@ -35,7 +35,7 @@ class hash_filo_element private: hash_filo_element *next_used,*prev_used; public: - hash_filo_element() {} + hash_filo_element() = default; hash_filo_element *next() { return next_used; } hash_filo_element *prev() diff --git a/sql/hostname.cc b/sql/hostname.cc index 968914fd56e..0805c37f9fa 100644 --- a/sql/hostname.cc +++ b/sql/hostname.cc @@ -74,8 +74,7 @@ Host_errors::Host_errors() m_local(0) {} -Host_errors::~Host_errors() -{} +Host_errors::~Host_errors() = default; void Host_errors::reset() { diff --git a/sql/item.h b/sql/item.h index 4fbb7324570..31568aafc8c 100644 --- a/sql/item.h +++ b/sql/item.h @@ -287,7 +287,7 @@ private: TABLE_LIST *save_next_local; public: - Name_resolution_context_state() {} /* Remove gcc warning */ + Name_resolution_context_state() = default; /* Remove gcc warning */ public: /* Save the state of a name resolution context. */ @@ -388,7 +388,7 @@ class sp_rcontext; class Sp_rcontext_handler { public: - virtual ~Sp_rcontext_handler() {} + virtual ~Sp_rcontext_handler() = default; /** A prefix used for SP variable names in queries: - EXPLAIN EXTENDED @@ -461,8 +461,8 @@ public: required, otherwise we only reading it and SELECT privilege might be required. */ - Settable_routine_parameter() {} - virtual ~Settable_routine_parameter() {} + Settable_routine_parameter() = default; + virtual ~Settable_routine_parameter() = default; virtual void set_required_privilege(bool rw) {}; /* @@ -544,7 +544,7 @@ class Rewritable_query_parameter limit_clause_param(false) { } - virtual ~Rewritable_query_parameter() { } + virtual ~Rewritable_query_parameter() = default; virtual bool append_for_log(THD *thd, String *str) = 0; }; @@ -704,7 +704,7 @@ public: class Item_const { public: - virtual ~Item_const() {} + virtual ~Item_const() = default; virtual const Type_all_attributes *get_type_all_attributes_from_const() const= 0; virtual bool const_is_null() const { return false; } virtual const longlong *const_ptr_longlong() const { return NULL; } @@ -2741,8 +2741,8 @@ class Field_enumerator { public: virtual void visit_field(Item_field *field)= 0; - virtual ~Field_enumerator() {}; /* purecov: inspected */ - Field_enumerator() {} /* Remove gcc warning */ + virtual ~Field_enumerator() = default;; /* purecov: inspected */ + Field_enumerator() = default; /* Remove gcc warning */ }; class Item_string; @@ -3265,7 +3265,7 @@ public: Item_result_field(THD *thd, Item_result_field *item): Item_fixed_hybrid(thd, item), result_field(item->result_field) {} - ~Item_result_field() {} /* Required with gcc 2.95 */ + ~Item_result_field() = default; /* Required with gcc 2.95 */ Field *get_tmp_table_field() { return result_field; } Field *create_tmp_field_ex(TABLE *table, Tmp_field_src *src, const Tmp_field_param *param); @@ -7540,7 +7540,7 @@ public: */ virtual void close()= 0; - virtual ~Item_iterator() {} + virtual ~Item_iterator() = default; }; diff --git a/sql/item_buff.cc b/sql/item_buff.cc index 05cef6871be..1079394e830 100644 --- a/sql/item_buff.cc +++ b/sql/item_buff.cc @@ -61,7 +61,7 @@ Cached_item *new_Cached_item(THD *thd, Item *item, bool pass_through_ref) } } -Cached_item::~Cached_item() {} +Cached_item::~Cached_item() = default; /** Compare with old value and replace value with new value. diff --git a/sql/item_cmpfunc.h b/sql/item_cmpfunc.h index 0641213c7c9..24f2b35576d 100644 --- a/sql/item_cmpfunc.h +++ b/sql/item_cmpfunc.h @@ -251,8 +251,7 @@ protected: Item_bool_func(thd, a), value(a_value), affirmative(a_affirmative) {} - ~Item_func_truth() - {} + ~Item_func_truth() = default; private: /** True for X IS [NOT] TRUE, @@ -274,7 +273,7 @@ class Item_func_istrue : public Item_func_truth { public: Item_func_istrue(THD *thd, Item *a): Item_func_truth(thd, a, true, true) {} - ~Item_func_istrue() {} + ~Item_func_istrue() = default; virtual const char* func_name() const { return "istrue"; } Item *get_copy(THD *thd) { return get_item_copy(thd, this); } @@ -290,7 +289,7 @@ class Item_func_isnottrue : public Item_func_truth public: Item_func_isnottrue(THD *thd, Item *a): Item_func_truth(thd, a, true, false) {} - ~Item_func_isnottrue() {} + ~Item_func_isnottrue() = default; virtual const char* func_name() const { return "isnottrue"; } Item *get_copy(THD *thd) { return get_item_copy(thd, this); } @@ -306,7 +305,7 @@ class Item_func_isfalse : public Item_func_truth { public: Item_func_isfalse(THD *thd, Item *a): Item_func_truth(thd, a, false, true) {} - ~Item_func_isfalse() {} + ~Item_func_isfalse() = default; virtual const char* func_name() const { return "isfalse"; } Item *get_copy(THD *thd) { return get_item_copy(thd, this); } @@ -322,7 +321,7 @@ class Item_func_isnotfalse : public Item_func_truth public: Item_func_isnotfalse(THD *thd, Item *a): Item_func_truth(thd, a, false, false) {} - ~Item_func_isnotfalse() {} + ~Item_func_isnotfalse() = default; virtual const char* func_name() const { return "isnotfalse"; } Item *get_copy(THD *thd) { return get_item_copy(thd, this); } @@ -1325,13 +1324,13 @@ public: CHARSET_INFO *collation; uint count; uint used_count; - in_vector() {} + in_vector() = default; in_vector(THD *thd, uint elements, uint element_length, qsort2_cmp cmp_func, CHARSET_INFO *cmp_coll) :base((char*) thd_calloc(thd, elements * element_length)), size(element_length), compare(cmp_func), collation(cmp_coll), count(elements), used_count(elements) {} - virtual ~in_vector() {} + virtual ~in_vector() = default; virtual void set(uint pos,Item *item)=0; virtual uchar *get_value(Item *item)=0; void sort() @@ -1530,7 +1529,7 @@ class cmp_item :public Sql_alloc public: CHARSET_INFO *cmp_charset; cmp_item() { cmp_charset= &my_charset_bin; } - virtual ~cmp_item() {} + virtual ~cmp_item() = default; virtual void store_value(Item *item)= 0; /** @returns result (TRUE, FALSE or UNKNOWN) of @@ -1559,7 +1558,7 @@ class cmp_item_string : public cmp_item_scalar protected: String *value_res; public: - cmp_item_string () {} + cmp_item_string () = default; cmp_item_string (CHARSET_INFO *cs) { cmp_charset= cs; } void set_charset(CHARSET_INFO *cs) { cmp_charset= cs; } friend class cmp_item_sort_string; @@ -1625,7 +1624,7 @@ class cmp_item_int : public cmp_item_scalar { longlong value; public: - cmp_item_int() {} /* Remove gcc warning */ + cmp_item_int() = default; /* Remove gcc warning */ void store_value(Item *item) { value= item->val_int(); @@ -1658,7 +1657,7 @@ class cmp_item_temporal: public cmp_item_scalar protected: longlong value; public: - cmp_item_temporal() {} + cmp_item_temporal() = default; int compare(cmp_item *ci); }; @@ -1714,7 +1713,7 @@ class cmp_item_real : public cmp_item_scalar { double value; public: - cmp_item_real() {} /* Remove gcc warning */ + cmp_item_real() = default; /* Remove gcc warning */ void store_value(Item *item) { value= item->val_real(); @@ -1744,7 +1743,7 @@ class cmp_item_decimal : public cmp_item_scalar { my_decimal value; public: - cmp_item_decimal() {} /* Remove gcc warning */ + cmp_item_decimal() = default; /* Remove gcc warning */ void store_value(Item *item); int cmp(Item *arg); int cmp_not_null(const Value *val); @@ -3509,8 +3508,8 @@ Item *and_expressions(Item *a, Item *b, Item **org_item); class Comp_creator { public: - Comp_creator() {} /* Remove gcc warning */ - virtual ~Comp_creator() {} /* Remove gcc warning */ + Comp_creator() = default; /* Remove gcc warning */ + virtual ~Comp_creator() = default; /* Remove gcc warning */ /** Create operation with given arguments. */ @@ -3529,8 +3528,8 @@ public: class Eq_creator :public Comp_creator { public: - Eq_creator() {} /* Remove gcc warning */ - virtual ~Eq_creator() {} /* Remove gcc warning */ + Eq_creator() = default; /* Remove gcc warning */ + virtual ~Eq_creator() = default; /* Remove gcc warning */ Item_bool_rowready_func2* create(THD *thd, Item *a, Item *b) const; Item_bool_rowready_func2* create_swap(THD *thd, Item *a, Item *b) const; const char* symbol(bool invert) const { return invert? "<>" : "="; } @@ -3541,8 +3540,8 @@ public: class Ne_creator :public Comp_creator { public: - Ne_creator() {} /* Remove gcc warning */ - virtual ~Ne_creator() {} /* Remove gcc warning */ + Ne_creator() = default; /* Remove gcc warning */ + virtual ~Ne_creator() = default; /* Remove gcc warning */ Item_bool_rowready_func2* create(THD *thd, Item *a, Item *b) const; Item_bool_rowready_func2* create_swap(THD *thd, Item *a, Item *b) const; const char* symbol(bool invert) const { return invert? "=" : "<>"; } @@ -3553,8 +3552,8 @@ public: class Gt_creator :public Comp_creator { public: - Gt_creator() {} /* Remove gcc warning */ - virtual ~Gt_creator() {} /* Remove gcc warning */ + Gt_creator() = default; /* Remove gcc warning */ + virtual ~Gt_creator() = default; /* Remove gcc warning */ Item_bool_rowready_func2* create(THD *thd, Item *a, Item *b) const; Item_bool_rowready_func2* create_swap(THD *thd, Item *a, Item *b) const; const char* symbol(bool invert) const { return invert? "<=" : ">"; } @@ -3565,8 +3564,8 @@ public: class Lt_creator :public Comp_creator { public: - Lt_creator() {} /* Remove gcc warning */ - virtual ~Lt_creator() {} /* Remove gcc warning */ + Lt_creator() = default; /* Remove gcc warning */ + virtual ~Lt_creator() = default; /* Remove gcc warning */ Item_bool_rowready_func2* create(THD *thd, Item *a, Item *b) const; Item_bool_rowready_func2* create_swap(THD *thd, Item *a, Item *b) const; const char* symbol(bool invert) const { return invert? ">=" : "<"; } @@ -3577,8 +3576,8 @@ public: class Ge_creator :public Comp_creator { public: - Ge_creator() {} /* Remove gcc warning */ - virtual ~Ge_creator() {} /* Remove gcc warning */ + Ge_creator() = default; /* Remove gcc warning */ + virtual ~Ge_creator() = default; /* Remove gcc warning */ Item_bool_rowready_func2* create(THD *thd, Item *a, Item *b) const; Item_bool_rowready_func2* create_swap(THD *thd, Item *a, Item *b) const; const char* symbol(bool invert) const { return invert? "<" : ">="; } @@ -3589,8 +3588,8 @@ public: class Le_creator :public Comp_creator { public: - Le_creator() {} /* Remove gcc warning */ - virtual ~Le_creator() {} /* Remove gcc warning */ + Le_creator() = default; /* Remove gcc warning */ + virtual ~Le_creator() = default; /* Remove gcc warning */ Item_bool_rowready_func2* create(THD *thd, Item *a, Item *b) const; Item_bool_rowready_func2* create_swap(THD *thd, Item *a, Item *b) const; const char* symbol(bool invert) const { return invert? ">" : "<="; } diff --git a/sql/item_create.cc b/sql/item_create.cc index 9fc43df2aea..616ba3a641a 100644 --- a/sql/item_create.cc +++ b/sql/item_create.cc @@ -61,9 +61,9 @@ public: protected: /** Constructor. */ - Create_func_arg0() {} + Create_func_arg0() = default; /** Destructor. */ - virtual ~Create_func_arg0() {} + virtual ~Create_func_arg0() = default; }; @@ -87,9 +87,9 @@ public: protected: /** Constructor. */ - Create_func_arg1() {} + Create_func_arg1() = default; /** Destructor. */ - virtual ~Create_func_arg1() {} + virtual ~Create_func_arg1() = default; }; @@ -113,9 +113,9 @@ public: virtual Item *create_2_arg(THD *thd, Item *arg1, Item *arg2) = 0; protected: /** Constructor. */ - Create_func_arg2() {} + Create_func_arg2() = default; /** Destructor. */ - virtual ~Create_func_arg2() {} + virtual ~Create_func_arg2() = default; }; @@ -140,9 +140,9 @@ public: virtual Item *create_3_arg(THD *thd, Item *arg1, Item *arg2, Item *arg3) = 0; protected: /** Constructor. */ - Create_func_arg3() {} + Create_func_arg3() = default; /** Destructor. */ - virtual ~Create_func_arg3() {} + virtual ~Create_func_arg3() = default; }; @@ -162,9 +162,9 @@ public: protected: /** Constructor. */ - Create_sp_func() {} + Create_sp_func() = default; /** Destructor. */ - virtual ~Create_sp_func() {} + virtual ~Create_sp_func() = default; }; @@ -207,8 +207,8 @@ public: static Create_func_abs s_singleton; protected: - Create_func_abs() {} - virtual ~Create_func_abs() {} + Create_func_abs() = default; + virtual ~Create_func_abs() = default; }; @@ -220,8 +220,8 @@ public: static Create_func_acos s_singleton; protected: - Create_func_acos() {} - virtual ~Create_func_acos() {} + Create_func_acos() = default; + virtual ~Create_func_acos() = default; }; @@ -233,8 +233,8 @@ public: static Create_func_addtime s_singleton; protected: - Create_func_addtime() {} - virtual ~Create_func_addtime() {} + Create_func_addtime() = default; + virtual ~Create_func_addtime() = default; }; @@ -246,8 +246,8 @@ public: static Create_func_aes_encrypt s_singleton; protected: - Create_func_aes_encrypt() {} - virtual ~Create_func_aes_encrypt() {} + Create_func_aes_encrypt() = default; + virtual ~Create_func_aes_encrypt() = default; }; @@ -259,8 +259,8 @@ public: static Create_func_aes_decrypt s_singleton; protected: - Create_func_aes_decrypt() {} - virtual ~Create_func_aes_decrypt() {} + Create_func_aes_decrypt() = default; + virtual ~Create_func_aes_decrypt() = default; }; @@ -273,8 +273,8 @@ public: static Create_func_area s_singleton; protected: - Create_func_area() {} - virtual ~Create_func_area() {} + Create_func_area() = default; + virtual ~Create_func_area() = default; }; #endif @@ -288,8 +288,8 @@ public: static Create_func_as_wkb s_singleton; protected: - Create_func_as_wkb() {} - virtual ~Create_func_as_wkb() {} + Create_func_as_wkb() = default; + virtual ~Create_func_as_wkb() = default; }; #endif @@ -303,8 +303,8 @@ public: static Create_func_as_wkt s_singleton; protected: - Create_func_as_wkt() {} - virtual ~Create_func_as_wkt() {} + Create_func_as_wkt() = default; + virtual ~Create_func_as_wkt() = default; }; #endif @@ -317,8 +317,8 @@ public: static Create_func_asin s_singleton; protected: - Create_func_asin() {} - virtual ~Create_func_asin() {} + Create_func_asin() = default; + virtual ~Create_func_asin() = default; }; @@ -331,8 +331,8 @@ public: static Create_func_atan s_singleton; protected: - Create_func_atan() {} - virtual ~Create_func_atan() {} + Create_func_atan() = default; + virtual ~Create_func_atan() = default; }; @@ -344,8 +344,8 @@ public: static Create_func_benchmark s_singleton; protected: - Create_func_benchmark() {} - virtual ~Create_func_benchmark() {} + Create_func_benchmark() = default; + virtual ~Create_func_benchmark() = default; }; @@ -357,8 +357,8 @@ public: static Create_func_bin s_singleton; protected: - Create_func_bin() {} - virtual ~Create_func_bin() {} + Create_func_bin() = default; + virtual ~Create_func_bin() = default; }; @@ -370,8 +370,8 @@ public: static Create_func_binlog_gtid_pos s_singleton; protected: - Create_func_binlog_gtid_pos() {} - virtual ~Create_func_binlog_gtid_pos() {} + Create_func_binlog_gtid_pos() = default; + virtual ~Create_func_binlog_gtid_pos() = default; }; @@ -383,8 +383,8 @@ public: static Create_func_bit_count s_singleton; protected: - Create_func_bit_count() {} - virtual ~Create_func_bit_count() {} + Create_func_bit_count() = default; + virtual ~Create_func_bit_count() = default; }; @@ -396,8 +396,8 @@ public: static Create_func_bit_length s_singleton; protected: - Create_func_bit_length() {} - virtual ~Create_func_bit_length() {} + Create_func_bit_length() = default; + virtual ~Create_func_bit_length() = default; }; @@ -409,8 +409,8 @@ public: static Create_func_ceiling s_singleton; protected: - Create_func_ceiling() {} - virtual ~Create_func_ceiling() {} + Create_func_ceiling() = default; + virtual ~Create_func_ceiling() = default; }; @@ -423,8 +423,8 @@ public: static Create_func_centroid s_singleton; protected: - Create_func_centroid() {} - virtual ~Create_func_centroid() {} + Create_func_centroid() = default; + virtual ~Create_func_centroid() = default; }; @@ -436,8 +436,8 @@ public: static Create_func_chr s_singleton; protected: - Create_func_chr() {} - virtual ~Create_func_chr() {} + Create_func_chr() = default; + virtual ~Create_func_chr() = default; }; @@ -449,8 +449,8 @@ public: static Create_func_convexhull s_singleton; protected: - Create_func_convexhull() {} - virtual ~Create_func_convexhull() {} + Create_func_convexhull() = default; + virtual ~Create_func_convexhull() = default; }; @@ -462,8 +462,8 @@ public: static Create_func_pointonsurface s_singleton; protected: - Create_func_pointonsurface() {} - virtual ~Create_func_pointonsurface() {} + Create_func_pointonsurface() = default; + virtual ~Create_func_pointonsurface() = default; }; @@ -478,8 +478,8 @@ public: static Create_func_char_length s_singleton; protected: - Create_func_char_length() {} - virtual ~Create_func_char_length() {} + Create_func_char_length() = default; + virtual ~Create_func_char_length() = default; }; @@ -491,8 +491,8 @@ public: static Create_func_coercibility s_singleton; protected: - Create_func_coercibility() {} - virtual ~Create_func_coercibility() {} + Create_func_coercibility() = default; + virtual ~Create_func_coercibility() = default; }; class Create_func_dyncol_check : public Create_func_arg1 @@ -503,8 +503,8 @@ public: static Create_func_dyncol_check s_singleton; protected: - Create_func_dyncol_check() {} - virtual ~Create_func_dyncol_check() {} + Create_func_dyncol_check() = default; + virtual ~Create_func_dyncol_check() = default; }; class Create_func_dyncol_exists : public Create_func_arg2 @@ -515,8 +515,8 @@ public: static Create_func_dyncol_exists s_singleton; protected: - Create_func_dyncol_exists() {} - virtual ~Create_func_dyncol_exists() {} + Create_func_dyncol_exists() = default; + virtual ~Create_func_dyncol_exists() = default; }; class Create_func_dyncol_list : public Create_func_arg1 @@ -527,8 +527,8 @@ public: static Create_func_dyncol_list s_singleton; protected: - Create_func_dyncol_list() {} - virtual ~Create_func_dyncol_list() {} + Create_func_dyncol_list() = default; + virtual ~Create_func_dyncol_list() = default; }; class Create_func_dyncol_json : public Create_func_arg1 @@ -539,8 +539,8 @@ public: static Create_func_dyncol_json s_singleton; protected: - Create_func_dyncol_json() {} - virtual ~Create_func_dyncol_json() {} + Create_func_dyncol_json() = default; + virtual ~Create_func_dyncol_json() = default; }; @@ -552,8 +552,8 @@ public: static Create_func_compress s_singleton; protected: - Create_func_compress() {} - virtual ~Create_func_compress() {} + Create_func_compress() = default; + virtual ~Create_func_compress() = default; }; @@ -566,8 +566,8 @@ public: static Create_func_concat s_singleton; protected: - Create_func_concat() {} - virtual ~Create_func_concat() {} + Create_func_concat() = default; + virtual ~Create_func_concat() = default; }; @@ -580,8 +580,8 @@ public: static Create_func_concat_operator_oracle s_singleton; protected: - Create_func_concat_operator_oracle() {} - virtual ~Create_func_concat_operator_oracle() {} + Create_func_concat_operator_oracle() = default; + virtual ~Create_func_concat_operator_oracle() = default; }; @@ -593,8 +593,8 @@ public: static Create_func_decode_histogram s_singleton; protected: - Create_func_decode_histogram() {} - virtual ~Create_func_decode_histogram() {} + Create_func_decode_histogram() = default; + virtual ~Create_func_decode_histogram() = default; }; @@ -607,8 +607,8 @@ public: static Create_func_decode_oracle s_singleton; protected: - Create_func_decode_oracle() {} - virtual ~Create_func_decode_oracle() {} + Create_func_decode_oracle() = default; + virtual ~Create_func_decode_oracle() = default; }; @@ -621,8 +621,8 @@ public: static Create_func_concat_ws s_singleton; protected: - Create_func_concat_ws() {} - virtual ~Create_func_concat_ws() {} + Create_func_concat_ws() = default; + virtual ~Create_func_concat_ws() = default; }; @@ -634,8 +634,8 @@ public: static Create_func_connection_id s_singleton; protected: - Create_func_connection_id() {} - virtual ~Create_func_connection_id() {} + Create_func_connection_id() = default; + virtual ~Create_func_connection_id() = default; }; @@ -648,8 +648,8 @@ class Create_func_mbr_contains : public Create_func_arg2 static Create_func_mbr_contains s_singleton; protected: - Create_func_mbr_contains() {} - virtual ~Create_func_mbr_contains() {} + Create_func_mbr_contains() = default; + virtual ~Create_func_mbr_contains() = default; }; @@ -661,8 +661,8 @@ public: static Create_func_contains s_singleton; protected: - Create_func_contains() {} - virtual ~Create_func_contains() {} + Create_func_contains() = default; + virtual ~Create_func_contains() = default; }; #endif @@ -675,8 +675,8 @@ public: static Create_func_nvl2 s_singleton; protected: - Create_func_nvl2() {} - virtual ~Create_func_nvl2() {} + Create_func_nvl2() = default; + virtual ~Create_func_nvl2() = default; }; @@ -688,8 +688,8 @@ public: static Create_func_conv s_singleton; protected: - Create_func_conv() {} - virtual ~Create_func_conv() {} + Create_func_conv() = default; + virtual ~Create_func_conv() = default; }; @@ -701,8 +701,8 @@ public: static Create_func_convert_tz s_singleton; protected: - Create_func_convert_tz() {} - virtual ~Create_func_convert_tz() {} + Create_func_convert_tz() = default; + virtual ~Create_func_convert_tz() = default; }; @@ -714,8 +714,8 @@ public: static Create_func_cos s_singleton; protected: - Create_func_cos() {} - virtual ~Create_func_cos() {} + Create_func_cos() = default; + virtual ~Create_func_cos() = default; }; @@ -727,8 +727,8 @@ public: static Create_func_cot s_singleton; protected: - Create_func_cot() {} - virtual ~Create_func_cot() {} + Create_func_cot() = default; + virtual ~Create_func_cot() = default; }; @@ -740,8 +740,8 @@ public: static Create_func_crc32 s_singleton; protected: - Create_func_crc32() {} - virtual ~Create_func_crc32() {} + Create_func_crc32() = default; + virtual ~Create_func_crc32() = default; }; @@ -754,8 +754,8 @@ public: static Create_func_crosses s_singleton; protected: - Create_func_crosses() {} - virtual ~Create_func_crosses() {} + Create_func_crosses() = default; + virtual ~Create_func_crosses() = default; }; #endif @@ -768,8 +768,8 @@ public: static Create_func_datediff s_singleton; protected: - Create_func_datediff() {} - virtual ~Create_func_datediff() {} + Create_func_datediff() = default; + virtual ~Create_func_datediff() = default; }; @@ -781,8 +781,8 @@ public: static Create_func_dayname s_singleton; protected: - Create_func_dayname() {} - virtual ~Create_func_dayname() {} + Create_func_dayname() = default; + virtual ~Create_func_dayname() = default; }; @@ -794,8 +794,8 @@ public: static Create_func_dayofmonth s_singleton; protected: - Create_func_dayofmonth() {} - virtual ~Create_func_dayofmonth() {} + Create_func_dayofmonth() = default; + virtual ~Create_func_dayofmonth() = default; }; @@ -807,8 +807,8 @@ public: static Create_func_dayofweek s_singleton; protected: - Create_func_dayofweek() {} - virtual ~Create_func_dayofweek() {} + Create_func_dayofweek() = default; + virtual ~Create_func_dayofweek() = default; }; @@ -820,8 +820,8 @@ public: static Create_func_dayofyear s_singleton; protected: - Create_func_dayofyear() {} - virtual ~Create_func_dayofyear() {} + Create_func_dayofyear() = default; + virtual ~Create_func_dayofyear() = default; }; @@ -833,8 +833,8 @@ public: static Create_func_degrees s_singleton; protected: - Create_func_degrees() {} - virtual ~Create_func_degrees() {} + Create_func_degrees() = default; + virtual ~Create_func_degrees() = default; }; @@ -847,8 +847,8 @@ public: static Create_func_des_decrypt s_singleton; protected: - Create_func_des_decrypt() {} - virtual ~Create_func_des_decrypt() {} + Create_func_des_decrypt() = default; + virtual ~Create_func_des_decrypt() = default; }; @@ -861,8 +861,8 @@ public: static Create_func_des_encrypt s_singleton; protected: - Create_func_des_encrypt() {} - virtual ~Create_func_des_encrypt() {} + Create_func_des_encrypt() = default; + virtual ~Create_func_des_encrypt() = default; }; @@ -875,8 +875,8 @@ public: static Create_func_dimension s_singleton; protected: - Create_func_dimension() {} - virtual ~Create_func_dimension() {} + Create_func_dimension() = default; + virtual ~Create_func_dimension() = default; }; #endif @@ -890,8 +890,8 @@ class Create_func_mbr_disjoint : public Create_func_arg2 static Create_func_mbr_disjoint s_singleton; protected: - Create_func_mbr_disjoint() {} - virtual ~Create_func_mbr_disjoint() {} + Create_func_mbr_disjoint() = default; + virtual ~Create_func_mbr_disjoint() = default; }; @@ -903,8 +903,8 @@ public: static Create_func_disjoint s_singleton; protected: - Create_func_disjoint() {} - virtual ~Create_func_disjoint() {} + Create_func_disjoint() = default; + virtual ~Create_func_disjoint() = default; }; @@ -916,8 +916,8 @@ class Create_func_distance : public Create_func_arg2 static Create_func_distance s_singleton; protected: - Create_func_distance() {} - virtual ~Create_func_distance() {} + Create_func_distance() = default; + virtual ~Create_func_distance() = default; }; @@ -929,8 +929,8 @@ class Create_func_distance_sphere: public Create_native_func static Create_func_distance_sphere s_singleton; protected: - Create_func_distance_sphere() {} - virtual ~Create_func_distance_sphere() {} + Create_func_distance_sphere() = default; + virtual ~Create_func_distance_sphere() = default; }; #endif @@ -945,8 +945,8 @@ public: static Create_func_elt s_singleton; protected: - Create_func_elt() {} - virtual ~Create_func_elt() {} + Create_func_elt() = default; + virtual ~Create_func_elt() = default; }; @@ -958,8 +958,8 @@ public: static Create_func_encode s_singleton; protected: - Create_func_encode() {} - virtual ~Create_func_encode() {} + Create_func_encode() = default; + virtual ~Create_func_encode() = default; }; @@ -972,8 +972,8 @@ public: static Create_func_encrypt s_singleton; protected: - Create_func_encrypt() {} - virtual ~Create_func_encrypt() {} + Create_func_encrypt() = default; + virtual ~Create_func_encrypt() = default; }; @@ -986,8 +986,8 @@ public: static Create_func_endpoint s_singleton; protected: - Create_func_endpoint() {} - virtual ~Create_func_endpoint() {} + Create_func_endpoint() = default; + virtual ~Create_func_endpoint() = default; }; #endif @@ -1001,8 +1001,8 @@ public: static Create_func_envelope s_singleton; protected: - Create_func_envelope() {} - virtual ~Create_func_envelope() {} + Create_func_envelope() = default; + virtual ~Create_func_envelope() = default; }; class Create_func_boundary : public Create_func_arg1 @@ -1013,8 +1013,8 @@ public: static Create_func_boundary s_singleton; protected: - Create_func_boundary() {} - virtual ~Create_func_boundary() {} + Create_func_boundary() = default; + virtual ~Create_func_boundary() = default; }; #endif /*HAVE_SPATIAL*/ @@ -1028,8 +1028,8 @@ class Create_func_mbr_equals : public Create_func_arg2 static Create_func_mbr_equals s_singleton; protected: - Create_func_mbr_equals() {} - virtual ~Create_func_mbr_equals() {} + Create_func_mbr_equals() = default; + virtual ~Create_func_mbr_equals() = default; }; @@ -1041,8 +1041,8 @@ public: static Create_func_equals s_singleton; protected: - Create_func_equals() {} - virtual ~Create_func_equals() {} + Create_func_equals() = default; + virtual ~Create_func_equals() = default; }; #endif @@ -1055,8 +1055,8 @@ public: static Create_func_exp s_singleton; protected: - Create_func_exp() {} - virtual ~Create_func_exp() {} + Create_func_exp() = default; + virtual ~Create_func_exp() = default; }; @@ -1069,8 +1069,8 @@ public: static Create_func_export_set s_singleton; protected: - Create_func_export_set() {} - virtual ~Create_func_export_set() {} + Create_func_export_set() = default; + virtual ~Create_func_export_set() = default; }; @@ -1083,8 +1083,8 @@ public: static Create_func_exteriorring s_singleton; protected: - Create_func_exteriorring() {} - virtual ~Create_func_exteriorring() {} + Create_func_exteriorring() = default; + virtual ~Create_func_exteriorring() = default; }; #endif @@ -1098,8 +1098,8 @@ public: static Create_func_field s_singleton; protected: - Create_func_field() {} - virtual ~Create_func_field() {} + Create_func_field() = default; + virtual ~Create_func_field() = default; }; @@ -1111,8 +1111,8 @@ public: static Create_func_find_in_set s_singleton; protected: - Create_func_find_in_set() {} - virtual ~Create_func_find_in_set() {} + Create_func_find_in_set() = default; + virtual ~Create_func_find_in_set() = default; }; @@ -1124,8 +1124,8 @@ public: static Create_func_floor s_singleton; protected: - Create_func_floor() {} - virtual ~Create_func_floor() {} + Create_func_floor() = default; + virtual ~Create_func_floor() = default; }; @@ -1138,8 +1138,8 @@ public: static Create_func_format s_singleton; protected: - Create_func_format() {} - virtual ~Create_func_format() {} + Create_func_format() = default; + virtual ~Create_func_format() = default; }; @@ -1151,8 +1151,8 @@ public: static Create_func_found_rows s_singleton; protected: - Create_func_found_rows() {} - virtual ~Create_func_found_rows() {} + Create_func_found_rows() = default; + virtual ~Create_func_found_rows() = default; }; @@ -1164,8 +1164,8 @@ public: static Create_func_from_base64 s_singleton; protected: - Create_func_from_base64() {} - virtual ~Create_func_from_base64() {} + Create_func_from_base64() = default; + virtual ~Create_func_from_base64() = default; }; @@ -1177,8 +1177,8 @@ public: static Create_func_from_days s_singleton; protected: - Create_func_from_days() {} - virtual ~Create_func_from_days() {} + Create_func_from_days() = default; + virtual ~Create_func_from_days() = default; }; @@ -1191,8 +1191,8 @@ public: static Create_func_from_unixtime s_singleton; protected: - Create_func_from_unixtime() {} - virtual ~Create_func_from_unixtime() {} + Create_func_from_unixtime() = default; + virtual ~Create_func_from_unixtime() = default; }; @@ -1206,8 +1206,8 @@ public: static Create_func_geometry_from_text s_singleton; protected: - Create_func_geometry_from_text() {} - virtual ~Create_func_geometry_from_text() {} + Create_func_geometry_from_text() = default; + virtual ~Create_func_geometry_from_text() = default; }; #endif @@ -1222,8 +1222,8 @@ public: static Create_func_geometry_from_wkb s_singleton; protected: - Create_func_geometry_from_wkb() {} - virtual ~Create_func_geometry_from_wkb() {} + Create_func_geometry_from_wkb() = default; + virtual ~Create_func_geometry_from_wkb() = default; }; #endif @@ -1238,8 +1238,8 @@ public: static Create_func_geometry_from_json s_singleton; protected: - Create_func_geometry_from_json() {} - virtual ~Create_func_geometry_from_json() {} + Create_func_geometry_from_json() = default; + virtual ~Create_func_geometry_from_json() = default; }; @@ -1252,8 +1252,8 @@ public: static Create_func_as_geojson s_singleton; protected: - Create_func_as_geojson() {} - virtual ~Create_func_as_geojson() {} + Create_func_as_geojson() = default; + virtual ~Create_func_as_geojson() = default; }; #endif /*HAVE_SPATIAL*/ @@ -1267,8 +1267,8 @@ public: static Create_func_geometry_type s_singleton; protected: - Create_func_geometry_type() {} - virtual ~Create_func_geometry_type() {} + Create_func_geometry_type() = default; + virtual ~Create_func_geometry_type() = default; }; #endif @@ -1282,8 +1282,8 @@ public: static Create_func_geometryn s_singleton; protected: - Create_func_geometryn() {} - virtual ~Create_func_geometryn() {} + Create_func_geometryn() = default; + virtual ~Create_func_geometryn() = default; }; #endif @@ -1296,8 +1296,8 @@ public: static Create_func_get_lock s_singleton; protected: - Create_func_get_lock() {} - virtual ~Create_func_get_lock() {} + Create_func_get_lock() = default; + virtual ~Create_func_get_lock() = default; }; @@ -1325,8 +1325,8 @@ public: static Create_func_glength s_singleton; protected: - Create_func_glength() {} - virtual ~Create_func_glength() {} + Create_func_glength() = default; + virtual ~Create_func_glength() = default; }; #endif @@ -1340,8 +1340,8 @@ public: static Create_func_greatest s_singleton; protected: - Create_func_greatest() {} - virtual ~Create_func_greatest() {} + Create_func_greatest() = default; + virtual ~Create_func_greatest() = default; }; @@ -1353,8 +1353,8 @@ public: static Create_func_hex s_singleton; protected: - Create_func_hex() {} - virtual ~Create_func_hex() {} + Create_func_hex() = default; + virtual ~Create_func_hex() = default; }; @@ -1366,8 +1366,8 @@ public: static Create_func_ifnull s_singleton; protected: - Create_func_ifnull() {} - virtual ~Create_func_ifnull() {} + Create_func_ifnull() = default; + virtual ~Create_func_ifnull() = default; }; @@ -1379,8 +1379,8 @@ public: static Create_func_inet_ntoa s_singleton; protected: - Create_func_inet_ntoa() {} - virtual ~Create_func_inet_ntoa() {} + Create_func_inet_ntoa() = default; + virtual ~Create_func_inet_ntoa() = default; }; @@ -1392,8 +1392,8 @@ public: static Create_func_inet_aton s_singleton; protected: - Create_func_inet_aton() {} - virtual ~Create_func_inet_aton() {} + Create_func_inet_aton() = default; + virtual ~Create_func_inet_aton() = default; }; @@ -1405,8 +1405,8 @@ public: static Create_func_inet6_aton s_singleton; protected: - Create_func_inet6_aton() {} - virtual ~Create_func_inet6_aton() {} + Create_func_inet6_aton() = default; + virtual ~Create_func_inet6_aton() = default; }; @@ -1418,8 +1418,8 @@ public: static Create_func_inet6_ntoa s_singleton; protected: - Create_func_inet6_ntoa() {} - virtual ~Create_func_inet6_ntoa() {} + Create_func_inet6_ntoa() = default; + virtual ~Create_func_inet6_ntoa() = default; }; @@ -1431,8 +1431,8 @@ public: static Create_func_is_ipv4 s_singleton; protected: - Create_func_is_ipv4() {} - virtual ~Create_func_is_ipv4() {} + Create_func_is_ipv4() = default; + virtual ~Create_func_is_ipv4() = default; }; @@ -1444,8 +1444,8 @@ public: static Create_func_is_ipv6 s_singleton; protected: - Create_func_is_ipv6() {} - virtual ~Create_func_is_ipv6() {} + Create_func_is_ipv6() = default; + virtual ~Create_func_is_ipv6() = default; }; @@ -1457,8 +1457,8 @@ public: static Create_func_is_ipv4_compat s_singleton; protected: - Create_func_is_ipv4_compat() {} - virtual ~Create_func_is_ipv4_compat() {} + Create_func_is_ipv4_compat() = default; + virtual ~Create_func_is_ipv4_compat() = default; }; @@ -1470,8 +1470,8 @@ public: static Create_func_is_ipv4_mapped s_singleton; protected: - Create_func_is_ipv4_mapped() {} - virtual ~Create_func_is_ipv4_mapped() {} + Create_func_is_ipv4_mapped() = default; + virtual ~Create_func_is_ipv4_mapped() = default; }; @@ -1483,8 +1483,8 @@ public: static Create_func_instr s_singleton; protected: - Create_func_instr() {} - virtual ~Create_func_instr() {} + Create_func_instr() = default; + virtual ~Create_func_instr() = default; }; @@ -1497,8 +1497,8 @@ public: static Create_func_interiorringn s_singleton; protected: - Create_func_interiorringn() {} - virtual ~Create_func_interiorringn() {} + Create_func_interiorringn() = default; + virtual ~Create_func_interiorringn() = default; }; #endif @@ -1512,8 +1512,8 @@ public: static Create_func_relate s_singleton; protected: - Create_func_relate() {} - virtual ~Create_func_relate() {} + Create_func_relate() = default; + virtual ~Create_func_relate() = default; }; @@ -1525,8 +1525,8 @@ class Create_func_mbr_intersects : public Create_func_arg2 static Create_func_mbr_intersects s_singleton; protected: - Create_func_mbr_intersects() {} - virtual ~Create_func_mbr_intersects() {} + Create_func_mbr_intersects() = default; + virtual ~Create_func_mbr_intersects() = default; }; @@ -1538,8 +1538,8 @@ public: static Create_func_intersects s_singleton; protected: - Create_func_intersects() {} - virtual ~Create_func_intersects() {} + Create_func_intersects() = default; + virtual ~Create_func_intersects() = default; }; @@ -1551,8 +1551,8 @@ public: static Create_func_intersection s_singleton; protected: - Create_func_intersection() {} - virtual ~Create_func_intersection() {} + Create_func_intersection() = default; + virtual ~Create_func_intersection() = default; }; @@ -1564,8 +1564,8 @@ public: static Create_func_difference s_singleton; protected: - Create_func_difference() {} - virtual ~Create_func_difference() {} + Create_func_difference() = default; + virtual ~Create_func_difference() = default; }; @@ -1577,8 +1577,8 @@ public: static Create_func_union s_singleton; protected: - Create_func_union() {} - virtual ~Create_func_union() {} + Create_func_union() = default; + virtual ~Create_func_union() = default; }; @@ -1590,8 +1590,8 @@ public: static Create_func_symdifference s_singleton; protected: - Create_func_symdifference() {} - virtual ~Create_func_symdifference() {} + Create_func_symdifference() = default; + virtual ~Create_func_symdifference() = default; }; @@ -1603,8 +1603,8 @@ public: static Create_func_buffer s_singleton; protected: - Create_func_buffer() {} - virtual ~Create_func_buffer() {} + Create_func_buffer() = default; + virtual ~Create_func_buffer() = default; }; #endif /*HAVE_SPATIAL*/ @@ -1617,8 +1617,8 @@ public: static Create_func_is_free_lock s_singleton; protected: - Create_func_is_free_lock() {} - virtual ~Create_func_is_free_lock() {} + Create_func_is_free_lock() = default; + virtual ~Create_func_is_free_lock() = default; }; @@ -1630,8 +1630,8 @@ public: static Create_func_is_used_lock s_singleton; protected: - Create_func_is_used_lock() {} - virtual ~Create_func_is_used_lock() {} + Create_func_is_used_lock() = default; + virtual ~Create_func_is_used_lock() = default; }; @@ -1644,8 +1644,8 @@ public: static Create_func_isclosed s_singleton; protected: - Create_func_isclosed() {} - virtual ~Create_func_isclosed() {} + Create_func_isclosed() = default; + virtual ~Create_func_isclosed() = default; }; @@ -1657,8 +1657,8 @@ public: static Create_func_isring s_singleton; protected: - Create_func_isring() {} - virtual ~Create_func_isring() {} + Create_func_isring() = default; + virtual ~Create_func_isring() = default; }; #endif @@ -1672,8 +1672,8 @@ public: static Create_func_isempty s_singleton; protected: - Create_func_isempty() {} - virtual ~Create_func_isempty() {} + Create_func_isempty() = default; + virtual ~Create_func_isempty() = default; }; #endif @@ -1686,8 +1686,8 @@ public: static Create_func_isnull s_singleton; protected: - Create_func_isnull() {} - virtual ~Create_func_isnull() {} + Create_func_isnull() = default; + virtual ~Create_func_isnull() = default; }; @@ -1700,8 +1700,8 @@ public: static Create_func_issimple s_singleton; protected: - Create_func_issimple() {} - virtual ~Create_func_issimple() {} + Create_func_issimple() = default; + virtual ~Create_func_issimple() = default; }; #endif @@ -1714,8 +1714,8 @@ public: static Create_func_json_exists s_singleton; protected: - Create_func_json_exists() {} - virtual ~Create_func_json_exists() {} + Create_func_json_exists() = default; + virtual ~Create_func_json_exists() = default; }; @@ -1727,8 +1727,8 @@ public: static Create_func_json_valid s_singleton; protected: - Create_func_json_valid() {} - virtual ~Create_func_json_valid() {} + Create_func_json_valid() = default; + virtual ~Create_func_json_valid() = default; }; @@ -1740,8 +1740,8 @@ public: static Create_func_json_compact s_singleton; protected: - Create_func_json_compact() {} - virtual ~Create_func_json_compact() {} + Create_func_json_compact() = default; + virtual ~Create_func_json_compact() = default; }; @@ -1753,8 +1753,8 @@ public: static Create_func_json_loose s_singleton; protected: - Create_func_json_loose() {} - virtual ~Create_func_json_loose() {} + Create_func_json_loose() = default; + virtual ~Create_func_json_loose() = default; }; @@ -1767,8 +1767,8 @@ public: static Create_func_json_detailed s_singleton; protected: - Create_func_json_detailed() {} - virtual ~Create_func_json_detailed() {} + Create_func_json_detailed() = default; + virtual ~Create_func_json_detailed() = default; }; @@ -1780,8 +1780,8 @@ public: static Create_func_json_type s_singleton; protected: - Create_func_json_type() {} - virtual ~Create_func_json_type() {} + Create_func_json_type() = default; + virtual ~Create_func_json_type() = default; }; @@ -1793,8 +1793,8 @@ public: static Create_func_json_depth s_singleton; protected: - Create_func_json_depth() {} - virtual ~Create_func_json_depth() {} + Create_func_json_depth() = default; + virtual ~Create_func_json_depth() = default; }; @@ -1806,8 +1806,8 @@ public: static Create_func_json_value s_singleton; protected: - Create_func_json_value() {} - virtual ~Create_func_json_value() {} + Create_func_json_value() = default; + virtual ~Create_func_json_value() = default; }; @@ -1819,8 +1819,8 @@ public: static Create_func_json_query s_singleton; protected: - Create_func_json_query() {} - virtual ~Create_func_json_query() {} + Create_func_json_query() = default; + virtual ~Create_func_json_query() = default; }; @@ -1833,8 +1833,8 @@ public: static Create_func_json_keys s_singleton; protected: - Create_func_json_keys() {} - virtual ~Create_func_json_keys() {} + Create_func_json_keys() = default; + virtual ~Create_func_json_keys() = default; }; @@ -1847,8 +1847,8 @@ public: static Create_func_json_contains s_singleton; protected: - Create_func_json_contains() {} - virtual ~Create_func_json_contains() {} + Create_func_json_contains() = default; + virtual ~Create_func_json_contains() = default; }; @@ -1861,8 +1861,8 @@ public: static Create_func_json_contains_path s_singleton; protected: - Create_func_json_contains_path() {} - virtual ~Create_func_json_contains_path() {} + Create_func_json_contains_path() = default; + virtual ~Create_func_json_contains_path() = default; }; @@ -1875,8 +1875,8 @@ public: static Create_func_json_extract s_singleton; protected: - Create_func_json_extract() {} - virtual ~Create_func_json_extract() {} + Create_func_json_extract() = default; + virtual ~Create_func_json_extract() = default; }; @@ -1889,8 +1889,8 @@ public: static Create_func_json_search s_singleton; protected: - Create_func_json_search() {} - virtual ~Create_func_json_search() {} + Create_func_json_search() = default; + virtual ~Create_func_json_search() = default; }; @@ -1903,8 +1903,8 @@ public: static Create_func_json_array s_singleton; protected: - Create_func_json_array() {} - virtual ~Create_func_json_array() {} + Create_func_json_array() = default; + virtual ~Create_func_json_array() = default; }; @@ -1917,8 +1917,8 @@ public: static Create_func_json_array_append s_singleton; protected: - Create_func_json_array_append() {} - virtual ~Create_func_json_array_append() {} + Create_func_json_array_append() = default; + virtual ~Create_func_json_array_append() = default; }; @@ -1931,8 +1931,8 @@ public: static Create_func_json_array_insert s_singleton; protected: - Create_func_json_array_insert() {} - virtual ~Create_func_json_array_insert() {} + Create_func_json_array_insert() = default; + virtual ~Create_func_json_array_insert() = default; }; @@ -1945,8 +1945,8 @@ public: static Create_func_json_insert s_singleton; protected: - Create_func_json_insert() {} - virtual ~Create_func_json_insert() {} + Create_func_json_insert() = default; + virtual ~Create_func_json_insert() = default; }; @@ -1959,8 +1959,8 @@ public: static Create_func_json_set s_singleton; protected: - Create_func_json_set() {} - virtual ~Create_func_json_set() {} + Create_func_json_set() = default; + virtual ~Create_func_json_set() = default; }; @@ -1973,8 +1973,8 @@ public: static Create_func_json_replace s_singleton; protected: - Create_func_json_replace() {} - virtual ~Create_func_json_replace() {} + Create_func_json_replace() = default; + virtual ~Create_func_json_replace() = default; }; @@ -1987,8 +1987,8 @@ public: static Create_func_json_remove s_singleton; protected: - Create_func_json_remove() {} - virtual ~Create_func_json_remove() {} + Create_func_json_remove() = default; + virtual ~Create_func_json_remove() = default; }; @@ -2001,8 +2001,8 @@ public: static Create_func_json_object s_singleton; protected: - Create_func_json_object() {} - virtual ~Create_func_json_object() {} + Create_func_json_object() = default; + virtual ~Create_func_json_object() = default; }; @@ -2015,8 +2015,8 @@ public: static Create_func_json_length s_singleton; protected: - Create_func_json_length() {} - virtual ~Create_func_json_length() {} + Create_func_json_length() = default; + virtual ~Create_func_json_length() = default; }; @@ -2029,8 +2029,8 @@ public: static Create_func_json_merge s_singleton; protected: - Create_func_json_merge() {} - virtual ~Create_func_json_merge() {} + Create_func_json_merge() = default; + virtual ~Create_func_json_merge() = default; }; @@ -2043,8 +2043,8 @@ public: static Create_func_json_merge_patch s_singleton; protected: - Create_func_json_merge_patch() {} - virtual ~Create_func_json_merge_patch() {} + Create_func_json_merge_patch() = default; + virtual ~Create_func_json_merge_patch() = default; }; @@ -2056,8 +2056,8 @@ public: static Create_func_json_quote s_singleton; protected: - Create_func_json_quote() {} - virtual ~Create_func_json_quote() {} + Create_func_json_quote() = default; + virtual ~Create_func_json_quote() = default; }; @@ -2069,8 +2069,8 @@ public: static Create_func_json_unquote s_singleton; protected: - Create_func_json_unquote() {} - virtual ~Create_func_json_unquote() {} + Create_func_json_unquote() = default; + virtual ~Create_func_json_unquote() = default; }; @@ -2082,8 +2082,8 @@ public: static Create_func_last_day s_singleton; protected: - Create_func_last_day() {} - virtual ~Create_func_last_day() {} + Create_func_last_day() = default; + virtual ~Create_func_last_day() = default; }; @@ -2096,8 +2096,8 @@ public: static Create_func_last_insert_id s_singleton; protected: - Create_func_last_insert_id() {} - virtual ~Create_func_last_insert_id() {} + Create_func_last_insert_id() = default; + virtual ~Create_func_last_insert_id() = default; }; @@ -2109,8 +2109,8 @@ public: static Create_func_lcase s_singleton; protected: - Create_func_lcase() {} - virtual ~Create_func_lcase() {} + Create_func_lcase() = default; + virtual ~Create_func_lcase() = default; }; @@ -2123,8 +2123,8 @@ public: static Create_func_least s_singleton; protected: - Create_func_least() {} - virtual ~Create_func_least() {} + Create_func_least() = default; + virtual ~Create_func_least() = default; }; @@ -2136,8 +2136,8 @@ public: static Create_func_length s_singleton; protected: - Create_func_length() {} - virtual ~Create_func_length() {} + Create_func_length() = default; + virtual ~Create_func_length() = default; }; class Create_func_octet_length : public Create_func_arg1 @@ -2148,8 +2148,8 @@ public: static Create_func_octet_length s_singleton; protected: - Create_func_octet_length() {} - virtual ~Create_func_octet_length() {} + Create_func_octet_length() = default; + virtual ~Create_func_octet_length() = default; }; @@ -2189,8 +2189,8 @@ public: static Create_func_ln s_singleton; protected: - Create_func_ln() {} - virtual ~Create_func_ln() {} + Create_func_ln() = default; + virtual ~Create_func_ln() = default; }; @@ -2202,8 +2202,8 @@ public: static Create_func_load_file s_singleton; protected: - Create_func_load_file() {} - virtual ~Create_func_load_file() {} + Create_func_load_file() = default; + virtual ~Create_func_load_file() = default; }; @@ -2216,8 +2216,8 @@ public: static Create_func_locate s_singleton; protected: - Create_func_locate() {} - virtual ~Create_func_locate() {} + Create_func_locate() = default; + virtual ~Create_func_locate() = default; }; @@ -2230,8 +2230,8 @@ public: static Create_func_log s_singleton; protected: - Create_func_log() {} - virtual ~Create_func_log() {} + Create_func_log() = default; + virtual ~Create_func_log() = default; }; @@ -2243,8 +2243,8 @@ public: static Create_func_log10 s_singleton; protected: - Create_func_log10() {} - virtual ~Create_func_log10() {} + Create_func_log10() = default; + virtual ~Create_func_log10() = default; }; @@ -2256,8 +2256,8 @@ public: static Create_func_log2 s_singleton; protected: - Create_func_log2() {} - virtual ~Create_func_log2() {} + Create_func_log2() = default; + virtual ~Create_func_log2() = default; }; @@ -2274,8 +2274,8 @@ public: static Create_func_lpad s_singleton; protected: - Create_func_lpad() {} - virtual ~Create_func_lpad() {} + Create_func_lpad() = default; + virtual ~Create_func_lpad() = default; Item *create_native_std(THD *thd, const LEX_CSTRING *name, List *items); Item *create_native_oracle(THD *thd, const LEX_CSTRING *name, @@ -2303,8 +2303,8 @@ public: static Create_func_ltrim s_singleton; protected: - Create_func_ltrim() {} - virtual ~Create_func_ltrim() {} + Create_func_ltrim() = default; + virtual ~Create_func_ltrim() = default; }; @@ -2316,8 +2316,8 @@ public: static Create_func_ltrim_oracle s_singleton; protected: - Create_func_ltrim_oracle() {} - virtual ~Create_func_ltrim_oracle() {} + Create_func_ltrim_oracle() = default; + virtual ~Create_func_ltrim_oracle() = default; }; @@ -2329,8 +2329,8 @@ public: static Create_func_makedate s_singleton; protected: - Create_func_makedate() {} - virtual ~Create_func_makedate() {} + Create_func_makedate() = default; + virtual ~Create_func_makedate() = default; }; @@ -2342,8 +2342,8 @@ public: static Create_func_maketime s_singleton; protected: - Create_func_maketime() {} - virtual ~Create_func_maketime() {} + Create_func_maketime() = default; + virtual ~Create_func_maketime() = default; }; @@ -2356,8 +2356,8 @@ public: static Create_func_make_set s_singleton; protected: - Create_func_make_set() {} - virtual ~Create_func_make_set() {} + Create_func_make_set() = default; + virtual ~Create_func_make_set() = default; }; @@ -2370,8 +2370,8 @@ public: static Create_func_master_pos_wait s_singleton; protected: - Create_func_master_pos_wait() {} - virtual ~Create_func_master_pos_wait() {} + Create_func_master_pos_wait() = default; + virtual ~Create_func_master_pos_wait() = default; }; @@ -2384,8 +2384,8 @@ public: static Create_func_master_gtid_wait s_singleton; protected: - Create_func_master_gtid_wait() {} - virtual ~Create_func_master_gtid_wait() {} + Create_func_master_gtid_wait() = default; + virtual ~Create_func_master_gtid_wait() = default; }; @@ -2397,8 +2397,8 @@ public: static Create_func_md5 s_singleton; protected: - Create_func_md5() {} - virtual ~Create_func_md5() {} + Create_func_md5() = default; + virtual ~Create_func_md5() = default; }; @@ -2410,8 +2410,8 @@ public: static Create_func_monthname s_singleton; protected: - Create_func_monthname() {} - virtual ~Create_func_monthname() {} + Create_func_monthname() = default; + virtual ~Create_func_monthname() = default; }; @@ -2423,8 +2423,8 @@ public: static Create_func_name_const s_singleton; protected: - Create_func_name_const() {} - virtual ~Create_func_name_const() {} + Create_func_name_const() = default; + virtual ~Create_func_name_const() = default; }; @@ -2436,8 +2436,8 @@ public: static Create_func_nullif s_singleton; protected: - Create_func_nullif() {} - virtual ~Create_func_nullif() {} + Create_func_nullif() = default; + virtual ~Create_func_nullif() = default; }; @@ -2450,8 +2450,8 @@ public: static Create_func_numgeometries s_singleton; protected: - Create_func_numgeometries() {} - virtual ~Create_func_numgeometries() {} + Create_func_numgeometries() = default; + virtual ~Create_func_numgeometries() = default; }; #endif @@ -2465,8 +2465,8 @@ public: static Create_func_numinteriorring s_singleton; protected: - Create_func_numinteriorring() {} - virtual ~Create_func_numinteriorring() {} + Create_func_numinteriorring() = default; + virtual ~Create_func_numinteriorring() = default; }; #endif @@ -2480,8 +2480,8 @@ public: static Create_func_numpoints s_singleton; protected: - Create_func_numpoints() {} - virtual ~Create_func_numpoints() {} + Create_func_numpoints() = default; + virtual ~Create_func_numpoints() = default; }; #endif @@ -2494,8 +2494,8 @@ public: static Create_func_oct s_singleton; protected: - Create_func_oct() {} - virtual ~Create_func_oct() {} + Create_func_oct() = default; + virtual ~Create_func_oct() = default; }; @@ -2507,8 +2507,8 @@ public: static Create_func_ord s_singleton; protected: - Create_func_ord() {} - virtual ~Create_func_ord() {} + Create_func_ord() = default; + virtual ~Create_func_ord() = default; }; @@ -2521,8 +2521,8 @@ class Create_func_mbr_overlaps : public Create_func_arg2 static Create_func_mbr_overlaps s_singleton; protected: - Create_func_mbr_overlaps() {} - virtual ~Create_func_mbr_overlaps() {} + Create_func_mbr_overlaps() = default; + virtual ~Create_func_mbr_overlaps() = default; }; @@ -2534,8 +2534,8 @@ public: static Create_func_overlaps s_singleton; protected: - Create_func_overlaps() {} - virtual ~Create_func_overlaps() {} + Create_func_overlaps() = default; + virtual ~Create_func_overlaps() = default; }; #endif @@ -2548,8 +2548,8 @@ public: static Create_func_period_add s_singleton; protected: - Create_func_period_add() {} - virtual ~Create_func_period_add() {} + Create_func_period_add() = default; + virtual ~Create_func_period_add() = default; }; @@ -2561,8 +2561,8 @@ public: static Create_func_period_diff s_singleton; protected: - Create_func_period_diff() {} - virtual ~Create_func_period_diff() {} + Create_func_period_diff() = default; + virtual ~Create_func_period_diff() = default; }; @@ -2574,8 +2574,8 @@ public: static Create_func_pi s_singleton; protected: - Create_func_pi() {} - virtual ~Create_func_pi() {} + Create_func_pi() = default; + virtual ~Create_func_pi() = default; }; @@ -2588,8 +2588,8 @@ public: static Create_func_pointn s_singleton; protected: - Create_func_pointn() {} - virtual ~Create_func_pointn() {} + Create_func_pointn() = default; + virtual ~Create_func_pointn() = default; }; #endif @@ -2602,8 +2602,8 @@ public: static Create_func_pow s_singleton; protected: - Create_func_pow() {} - virtual ~Create_func_pow() {} + Create_func_pow() = default; + virtual ~Create_func_pow() = default; }; @@ -2615,8 +2615,8 @@ public: static Create_func_quote s_singleton; protected: - Create_func_quote() {} - virtual ~Create_func_quote() {} + Create_func_quote() = default; + virtual ~Create_func_quote() = default; }; @@ -2628,8 +2628,8 @@ public: static Create_func_regexp_instr s_singleton; protected: - Create_func_regexp_instr() {} - virtual ~Create_func_regexp_instr() {} + Create_func_regexp_instr() = default; + virtual ~Create_func_regexp_instr() = default; }; @@ -2641,8 +2641,8 @@ public: static Create_func_regexp_replace s_singleton; protected: - Create_func_regexp_replace() {} - virtual ~Create_func_regexp_replace() {} + Create_func_regexp_replace() = default; + virtual ~Create_func_regexp_replace() = default; }; @@ -2654,8 +2654,8 @@ public: static Create_func_regexp_substr s_singleton; protected: - Create_func_regexp_substr() {} - virtual ~Create_func_regexp_substr() {} + Create_func_regexp_substr() = default; + virtual ~Create_func_regexp_substr() = default; }; @@ -2667,8 +2667,8 @@ public: static Create_func_radians s_singleton; protected: - Create_func_radians() {} - virtual ~Create_func_radians() {} + Create_func_radians() = default; + virtual ~Create_func_radians() = default; }; @@ -2681,8 +2681,8 @@ public: static Create_func_rand s_singleton; protected: - Create_func_rand() {} - virtual ~Create_func_rand() {} + Create_func_rand() = default; + virtual ~Create_func_rand() = default; }; @@ -2694,8 +2694,8 @@ public: static Create_func_release_lock s_singleton; protected: - Create_func_release_lock() {} - virtual ~Create_func_release_lock() {} + Create_func_release_lock() = default; + virtual ~Create_func_release_lock() = default; }; @@ -2707,8 +2707,8 @@ public: static Create_func_replace_oracle s_singleton; protected: - Create_func_replace_oracle() {} - virtual ~Create_func_replace_oracle() {} + Create_func_replace_oracle() = default; + virtual ~Create_func_replace_oracle() = default; }; @@ -2720,8 +2720,8 @@ public: static Create_func_reverse s_singleton; protected: - Create_func_reverse() {} - virtual ~Create_func_reverse() {} + Create_func_reverse() = default; + virtual ~Create_func_reverse() = default; }; @@ -2734,8 +2734,8 @@ public: static Create_func_round s_singleton; protected: - Create_func_round() {} - virtual ~Create_func_round() {} + Create_func_round() = default; + virtual ~Create_func_round() = default; }; @@ -2752,8 +2752,8 @@ public: static Create_func_rpad s_singleton; protected: - Create_func_rpad() {} - virtual ~Create_func_rpad() {} + Create_func_rpad() = default; + virtual ~Create_func_rpad() = default; Item *create_native_std(THD *thd, const LEX_CSTRING *name, List *items); Item *create_native_oracle(THD *thd, const LEX_CSTRING *name, @@ -2781,8 +2781,8 @@ public: static Create_func_rtrim s_singleton; protected: - Create_func_rtrim() {} - virtual ~Create_func_rtrim() {} + Create_func_rtrim() = default; + virtual ~Create_func_rtrim() = default; }; @@ -2794,8 +2794,8 @@ public: static Create_func_rtrim_oracle s_singleton; protected: - Create_func_rtrim_oracle() {} - virtual ~Create_func_rtrim_oracle() {} + Create_func_rtrim_oracle() = default; + virtual ~Create_func_rtrim_oracle() = default; }; @@ -2807,8 +2807,8 @@ public: static Create_func_sec_to_time s_singleton; protected: - Create_func_sec_to_time() {} - virtual ~Create_func_sec_to_time() {} + Create_func_sec_to_time() = default; + virtual ~Create_func_sec_to_time() = default; }; @@ -2820,8 +2820,8 @@ public: static Create_func_sha s_singleton; protected: - Create_func_sha() {} - virtual ~Create_func_sha() {} + Create_func_sha() = default; + virtual ~Create_func_sha() = default; }; @@ -2833,8 +2833,8 @@ public: static Create_func_sha2 s_singleton; protected: - Create_func_sha2() {} - virtual ~Create_func_sha2() {} + Create_func_sha2() = default; + virtual ~Create_func_sha2() = default; }; @@ -2846,8 +2846,8 @@ public: static Create_func_sign s_singleton; protected: - Create_func_sign() {} - virtual ~Create_func_sign() {} + Create_func_sign() = default; + virtual ~Create_func_sign() = default; }; @@ -2859,8 +2859,8 @@ public: static Create_func_sin s_singleton; protected: - Create_func_sin() {} - virtual ~Create_func_sin() {} + Create_func_sin() = default; + virtual ~Create_func_sin() = default; }; @@ -2872,8 +2872,8 @@ public: static Create_func_sleep s_singleton; protected: - Create_func_sleep() {} - virtual ~Create_func_sleep() {} + Create_func_sleep() = default; + virtual ~Create_func_sleep() = default; }; @@ -2885,8 +2885,8 @@ public: static Create_func_soundex s_singleton; protected: - Create_func_soundex() {} - virtual ~Create_func_soundex() {} + Create_func_soundex() = default; + virtual ~Create_func_soundex() = default; }; @@ -2898,8 +2898,8 @@ public: static Create_func_space s_singleton; protected: - Create_func_space() {} - virtual ~Create_func_space() {} + Create_func_space() = default; + virtual ~Create_func_space() = default; }; @@ -2911,8 +2911,8 @@ public: static Create_func_sqrt s_singleton; protected: - Create_func_sqrt() {} - virtual ~Create_func_sqrt() {} + Create_func_sqrt() = default; + virtual ~Create_func_sqrt() = default; }; @@ -2925,8 +2925,8 @@ public: static Create_func_srid s_singleton; protected: - Create_func_srid() {} - virtual ~Create_func_srid() {} + Create_func_srid() = default; + virtual ~Create_func_srid() = default; }; #endif @@ -2940,8 +2940,8 @@ public: static Create_func_startpoint s_singleton; protected: - Create_func_startpoint() {} - virtual ~Create_func_startpoint() {} + Create_func_startpoint() = default; + virtual ~Create_func_startpoint() = default; }; #endif @@ -2954,8 +2954,8 @@ public: static Create_func_str_to_date s_singleton; protected: - Create_func_str_to_date() {} - virtual ~Create_func_str_to_date() {} + Create_func_str_to_date() = default; + virtual ~Create_func_str_to_date() = default; }; @@ -2967,8 +2967,8 @@ public: static Create_func_strcmp s_singleton; protected: - Create_func_strcmp() {} - virtual ~Create_func_strcmp() {} + Create_func_strcmp() = default; + virtual ~Create_func_strcmp() = default; }; @@ -2980,8 +2980,8 @@ public: static Create_func_substr_index s_singleton; protected: - Create_func_substr_index() {} - virtual ~Create_func_substr_index() {} + Create_func_substr_index() = default; + virtual ~Create_func_substr_index() = default; }; @@ -2994,8 +2994,8 @@ public: static Create_func_substr_oracle s_singleton; protected: - Create_func_substr_oracle() {} - virtual ~Create_func_substr_oracle() {} + Create_func_substr_oracle() = default; + virtual ~Create_func_substr_oracle() = default; }; @@ -3007,8 +3007,8 @@ public: static Create_func_subtime s_singleton; protected: - Create_func_subtime() {} - virtual ~Create_func_subtime() {} + Create_func_subtime() = default; + virtual ~Create_func_subtime() = default; }; @@ -3020,8 +3020,8 @@ public: static Create_func_tan s_singleton; protected: - Create_func_tan() {} - virtual ~Create_func_tan() {} + Create_func_tan() = default; + virtual ~Create_func_tan() = default; }; @@ -3033,8 +3033,8 @@ public: static Create_func_time_format s_singleton; protected: - Create_func_time_format() {} - virtual ~Create_func_time_format() {} + Create_func_time_format() = default; + virtual ~Create_func_time_format() = default; }; @@ -3046,8 +3046,8 @@ public: static Create_func_time_to_sec s_singleton; protected: - Create_func_time_to_sec() {} - virtual ~Create_func_time_to_sec() {} + Create_func_time_to_sec() = default; + virtual ~Create_func_time_to_sec() = default; }; @@ -3059,8 +3059,8 @@ public: static Create_func_timediff s_singleton; protected: - Create_func_timediff() {} - virtual ~Create_func_timediff() {} + Create_func_timediff() = default; + virtual ~Create_func_timediff() = default; }; @@ -3072,8 +3072,8 @@ public: static Create_func_to_base64 s_singleton; protected: - Create_func_to_base64() {} - virtual ~Create_func_to_base64() {} + Create_func_to_base64() = default; + virtual ~Create_func_to_base64() = default; }; @@ -3085,8 +3085,8 @@ public: static Create_func_to_days s_singleton; protected: - Create_func_to_days() {} - virtual ~Create_func_to_days() {} + Create_func_to_days() = default; + virtual ~Create_func_to_days() = default; }; class Create_func_to_seconds : public Create_func_arg1 @@ -3097,8 +3097,8 @@ public: static Create_func_to_seconds s_singleton; protected: - Create_func_to_seconds() {} - virtual ~Create_func_to_seconds() {} + Create_func_to_seconds() = default; + virtual ~Create_func_to_seconds() = default; }; @@ -3111,8 +3111,8 @@ public: static Create_func_touches s_singleton; protected: - Create_func_touches() {} - virtual ~Create_func_touches() {} + Create_func_touches() = default; + virtual ~Create_func_touches() = default; }; #endif @@ -3125,8 +3125,8 @@ public: static Create_func_ucase s_singleton; protected: - Create_func_ucase() {} - virtual ~Create_func_ucase() {} + Create_func_ucase() = default; + virtual ~Create_func_ucase() = default; }; @@ -3138,8 +3138,8 @@ public: static Create_func_uncompress s_singleton; protected: - Create_func_uncompress() {} - virtual ~Create_func_uncompress() {} + Create_func_uncompress() = default; + virtual ~Create_func_uncompress() = default; }; @@ -3151,8 +3151,8 @@ public: static Create_func_uncompressed_length s_singleton; protected: - Create_func_uncompressed_length() {} - virtual ~Create_func_uncompressed_length() {} + Create_func_uncompressed_length() = default; + virtual ~Create_func_uncompressed_length() = default; }; @@ -3164,8 +3164,8 @@ public: static Create_func_unhex s_singleton; protected: - Create_func_unhex() {} - virtual ~Create_func_unhex() {} + Create_func_unhex() = default; + virtual ~Create_func_unhex() = default; }; @@ -3178,8 +3178,8 @@ public: static Create_func_unix_timestamp s_singleton; protected: - Create_func_unix_timestamp() {} - virtual ~Create_func_unix_timestamp() {} + Create_func_unix_timestamp() = default; + virtual ~Create_func_unix_timestamp() = default; }; @@ -3191,8 +3191,8 @@ public: static Create_func_uuid s_singleton; protected: - Create_func_uuid() {} - virtual ~Create_func_uuid() {} + Create_func_uuid() = default; + virtual ~Create_func_uuid() = default; }; @@ -3204,8 +3204,8 @@ public: static Create_func_uuid_short s_singleton; protected: - Create_func_uuid_short() {} - virtual ~Create_func_uuid_short() {} + Create_func_uuid_short() = default; + virtual ~Create_func_uuid_short() = default; }; @@ -3217,8 +3217,8 @@ public: static Create_func_version s_singleton; protected: - Create_func_version() {} - virtual ~Create_func_version() {} + Create_func_version() = default; + virtual ~Create_func_version() = default; }; @@ -3230,8 +3230,8 @@ public: static Create_func_weekday s_singleton; protected: - Create_func_weekday() {} - virtual ~Create_func_weekday() {} + Create_func_weekday() = default; + virtual ~Create_func_weekday() = default; }; @@ -3243,8 +3243,8 @@ public: static Create_func_weekofyear s_singleton; protected: - Create_func_weekofyear() {} - virtual ~Create_func_weekofyear() {} + Create_func_weekofyear() = default; + virtual ~Create_func_weekofyear() = default; }; @@ -3257,8 +3257,8 @@ class Create_func_mbr_within : public Create_func_arg2 static Create_func_mbr_within s_singleton; protected: - Create_func_mbr_within() {} - virtual ~Create_func_mbr_within() {} + Create_func_mbr_within() = default; + virtual ~Create_func_mbr_within() = default; }; @@ -3270,8 +3270,8 @@ public: static Create_func_within s_singleton; protected: - Create_func_within() {} - virtual ~Create_func_within() {} + Create_func_within() = default; + virtual ~Create_func_within() = default; }; #endif @@ -3284,8 +3284,8 @@ public: static Create_func_wsrep_last_written_gtid s_singleton; protected: - Create_func_wsrep_last_written_gtid() {} - virtual ~Create_func_wsrep_last_written_gtid() {} + Create_func_wsrep_last_written_gtid() = default; + virtual ~Create_func_wsrep_last_written_gtid() = default; }; @@ -3297,8 +3297,8 @@ public: static Create_func_wsrep_last_seen_gtid s_singleton; protected: - Create_func_wsrep_last_seen_gtid() {} - virtual ~Create_func_wsrep_last_seen_gtid() {} + Create_func_wsrep_last_seen_gtid() = default; + virtual ~Create_func_wsrep_last_seen_gtid() = default; }; @@ -3311,8 +3311,8 @@ public: static Create_func_wsrep_sync_wait_upto s_singleton; protected: - Create_func_wsrep_sync_wait_upto() {} - virtual ~Create_func_wsrep_sync_wait_upto() {} + Create_func_wsrep_sync_wait_upto() = default; + virtual ~Create_func_wsrep_sync_wait_upto() = default; }; #endif /* WITH_WSREP */ @@ -3325,8 +3325,8 @@ public: static Create_func_x s_singleton; protected: - Create_func_x() {} - virtual ~Create_func_x() {} + Create_func_x() = default; + virtual ~Create_func_x() = default; }; #endif @@ -3339,8 +3339,8 @@ public: static Create_func_xml_extractvalue s_singleton; protected: - Create_func_xml_extractvalue() {} - virtual ~Create_func_xml_extractvalue() {} + Create_func_xml_extractvalue() = default; + virtual ~Create_func_xml_extractvalue() = default; }; @@ -3352,8 +3352,8 @@ public: static Create_func_xml_update s_singleton; protected: - Create_func_xml_update() {} - virtual ~Create_func_xml_update() {} + Create_func_xml_update() = default; + virtual ~Create_func_xml_update() = default; }; @@ -3366,8 +3366,8 @@ public: static Create_func_y s_singleton; protected: - Create_func_y() {} - virtual ~Create_func_y() {} + Create_func_y() = default; + virtual ~Create_func_y() = default; }; #endif @@ -3381,8 +3381,8 @@ public: static Create_func_year_week s_singleton; protected: - Create_func_year_week() {} - virtual ~Create_func_year_week() {} + Create_func_year_week() = default; + virtual ~Create_func_year_week() = default; }; diff --git a/sql/item_create.h b/sql/item_create.h index 5f1103bb60f..8456644ff6d 100644 --- a/sql/item_create.h +++ b/sql/item_create.h @@ -63,9 +63,9 @@ public: protected: /** Constructor */ - Create_func() {} + Create_func() = default; /** Destructor */ - virtual ~Create_func() {} + virtual ~Create_func() = default; }; @@ -95,9 +95,9 @@ public: protected: /** Constructor. */ - Create_native_func() {} + Create_native_func() = default; /** Destructor. */ - virtual ~Create_native_func() {} + virtual ~Create_native_func() = default; }; @@ -138,9 +138,9 @@ public: protected: /** Constructor. */ - Create_qfunc() {} + Create_qfunc() = default; /** Destructor. */ - virtual ~Create_qfunc() {} + virtual ~Create_qfunc() = default; }; @@ -187,9 +187,9 @@ public: protected: /** Constructor. */ - Create_udf_func() {} + Create_udf_func() = default; /** Destructor. */ - virtual ~Create_udf_func() {} + virtual ~Create_udf_func() = default; }; #endif diff --git a/sql/item_func.cc b/sql/item_func.cc index d275dbaa50d..e0d30b94067 100644 --- a/sql/item_func.cc +++ b/sql/item_func.cc @@ -3919,7 +3919,7 @@ class Interruptible_wait Interruptible_wait(THD *thd) : m_thd(thd) {} - ~Interruptible_wait() {} + ~Interruptible_wait() = default; public: /** diff --git a/sql/item_func.h b/sql/item_func.h index ef36d5204d2..41f2a52616d 100644 --- a/sql/item_func.h +++ b/sql/item_func.h @@ -490,7 +490,7 @@ public: class Handler { public: - virtual ~Handler() { } + virtual ~Handler() = default; virtual String *val_str(Item_handled_func *, String *) const= 0; virtual String *val_str_ascii(Item_handled_func *, String *) const= 0; virtual double val_real(Item_handled_func *) const= 0; @@ -3267,8 +3267,7 @@ public: Item_func_sp(THD *thd, Name_resolution_context *context_arg, sp_name *name, const Sp_handler *sph, List &list); - virtual ~Item_func_sp() - {} + virtual ~Item_func_sp() = default; void update_used_tables(); diff --git a/sql/item_geofunc.cc b/sql/item_geofunc.cc index 01040f0aa25..7f9286b10ec 100644 --- a/sql/item_geofunc.cc +++ b/sql/item_geofunc.cc @@ -1541,9 +1541,7 @@ exit: } -Item_func_spatial_operation::~Item_func_spatial_operation() -{ -} +Item_func_spatial_operation::~Item_func_spatial_operation() = default; String *Item_func_spatial_operation::val_str(String *str_value) diff --git a/sql/item_inetfunc.cc b/sql/item_inetfunc.cc index a2abbce6619..a4fc8d2fedd 100644 --- a/sql/item_inetfunc.cc +++ b/sql/item_inetfunc.cc @@ -174,7 +174,7 @@ protected: return false; } // Non-initializing constructor - Inet4() { } + Inet4() = default; public: void to_binary(char *dst, size_t dstsize) const { @@ -266,7 +266,7 @@ protected: return false; } // Non-initializing constructor - Inet6() { } + Inet6() = default; public: bool to_binary(String *to) const { diff --git a/sql/item_subselect.h b/sql/item_subselect.h index 458934b5f49..86c032dd1ce 100644 --- a/sql/item_subselect.h +++ b/sql/item_subselect.h @@ -824,7 +824,7 @@ public: item= si; maybe_null= 0; } - virtual ~subselect_engine() {}; // to satisfy compiler + virtual ~subselect_engine() = default;; // to satisfy compiler virtual void cleanup()= 0; /* diff --git a/sql/item_sum.h b/sql/item_sum.h index 38a59ccae82..11dcad9fc3d 100644 --- a/sql/item_sum.h +++ b/sql/item_sum.h @@ -59,7 +59,7 @@ protected: public: Aggregator (Item_sum *arg): item_sum(arg) {} - virtual ~Aggregator () {} /* Keep gcc happy */ + virtual ~Aggregator () = default; /* Keep gcc happy */ enum Aggregator_type { SIMPLE_AGGREGATOR, DISTINCT_AGGREGATOR }; virtual Aggregator_type Aggrtype() = 0; diff --git a/sql/log.cc b/sql/log.cc index 43f57afd39e..d2cbb49e280 100644 --- a/sql/log.cc +++ b/sql/log.cc @@ -205,7 +205,7 @@ public: m_message[0]= '\0'; } - virtual ~Silence_log_table_errors() {} + virtual ~Silence_log_table_errors() = default; virtual bool handle_condition(THD *thd, uint sql_errno, @@ -632,14 +632,10 @@ end: } -Log_to_csv_event_handler::Log_to_csv_event_handler() -{ -} +Log_to_csv_event_handler::Log_to_csv_event_handler() = default; -Log_to_csv_event_handler::~Log_to_csv_event_handler() -{ -} +Log_to_csv_event_handler::~Log_to_csv_event_handler() = default; void Log_to_csv_event_handler::cleanup() diff --git a/sql/log.h b/sql/log.h index 1707a8c8831..deeb5ca83ba 100644 --- a/sql/log.h +++ b/sql/log.h @@ -42,8 +42,8 @@ class TC_LOG { public: int using_heuristic_recover(); - TC_LOG() {} - virtual ~TC_LOG() {} + TC_LOG() = default; + virtual ~TC_LOG() = default; virtual int open(const char *opt_name)=0; virtual void close()=0; @@ -99,7 +99,7 @@ extern PSI_cond_key key_COND_prepare_ordered; class TC_LOG_DUMMY: public TC_LOG // use it to disable the logging { public: - TC_LOG_DUMMY() {} + TC_LOG_DUMMY() = default; int open(const char *opt_name) { return 0; } void close() { } /* @@ -293,7 +293,7 @@ class MYSQL_LOG { public: MYSQL_LOG(); - virtual ~MYSQL_LOG() {} + virtual ~MYSQL_LOG() = default; void init_pthread_objects(); void cleanup(); bool open( @@ -970,7 +970,7 @@ public: class Log_event_handler { public: - Log_event_handler() {} + Log_event_handler() = default; virtual bool init()= 0; virtual void cleanup()= 0; @@ -984,7 +984,7 @@ public: const char *command_type, size_t command_type_len, const char *sql_text, size_t sql_text_len, CHARSET_INFO *client_cs)= 0; - virtual ~Log_event_handler() {} + virtual ~Log_event_handler() = default; }; diff --git a/sql/log_event.cc b/sql/log_event.cc index 8b09a908cda..14cdf880d62 100644 --- a/sql/log_event.cc +++ b/sql/log_event.cc @@ -324,7 +324,7 @@ public: reinit_io_cache(m_cache, WRITE_CACHE, 0L, FALSE, TRUE); } - ~Write_on_release_cache() {} + ~Write_on_release_cache() = default; bool flush_data() { @@ -15046,9 +15046,7 @@ Ignorable_log_event::Ignorable_log_event(const char *buf, DBUG_VOID_RETURN; } -Ignorable_log_event::~Ignorable_log_event() -{ -} +Ignorable_log_event::~Ignorable_log_event() = default; #ifndef MYSQL_CLIENT /* Pack info for its unrecognized ignorable event */ diff --git a/sql/log_event.h b/sql/log_event.h index 5719bb99a68..b12ee07b0e2 100644 --- a/sql/log_event.h +++ b/sql/log_event.h @@ -2558,8 +2558,7 @@ public: */ Load_log_event(const char* buf, uint event_len, const Format_description_log_event* description_event); - ~Load_log_event() - {} + ~Load_log_event() = default; Log_event_type get_type_code() { return sql_ex.new_format() ? NEW_LOAD_EVENT: LOAD_EVENT; @@ -2643,13 +2642,13 @@ public: void pack_info(Protocol* protocol); #endif /* HAVE_REPLICATION */ #else - Start_log_event_v3() {} + Start_log_event_v3() = default; bool print(FILE* file, PRINT_EVENT_INFO* print_event_info); #endif Start_log_event_v3(const char* buf, uint event_len, const Format_description_log_event* description_event); - ~Start_log_event_v3() {} + ~Start_log_event_v3() = default; Log_event_type get_type_code() { return START_EVENT_V3;} my_off_t get_header_len(my_off_t l __attribute__((unused))) { return LOG_EVENT_MINIMAL_HEADER_LEN; } @@ -2937,7 +2936,7 @@ Intvar_log_event(THD* thd_arg,uchar type_arg, ulonglong val_arg, Intvar_log_event(const char* buf, const Format_description_log_event *description_event); - ~Intvar_log_event() {} + ~Intvar_log_event() = default; Log_event_type get_type_code() { return INTVAR_EVENT;} const char* get_var_type_name(); int get_data_size() { return 9; /* sizeof(type) + sizeof(val) */;} @@ -3018,7 +3017,7 @@ class Rand_log_event: public Log_event Rand_log_event(const char* buf, const Format_description_log_event *description_event); - ~Rand_log_event() {} + ~Rand_log_event() = default; Log_event_type get_type_code() { return RAND_EVENT;} int get_data_size() { return 16; /* sizeof(ulonglong) * 2*/ } #ifdef MYSQL_SERVER @@ -3068,7 +3067,7 @@ class Xid_log_event: public Log_event Xid_log_event(const char* buf, const Format_description_log_event *description_event); - ~Xid_log_event() {} + ~Xid_log_event() = default; Log_event_type get_type_code() { return XID_EVENT;} int get_data_size() { return sizeof(xid); } #ifdef MYSQL_SERVER @@ -3130,7 +3129,7 @@ public: User_var_log_event(const char* buf, uint event_len, const Format_description_log_event *description_event); - ~User_var_log_event() {} + ~User_var_log_event() = default; Log_event_type get_type_code() { return USER_VAR_EVENT;} #ifdef MYSQL_SERVER bool write(); @@ -3180,7 +3179,7 @@ public: const Format_description_log_event *description_event): Log_event(buf, description_event) {} - ~Stop_log_event() {} + ~Stop_log_event() = default; Log_event_type get_type_code() { return STOP_EVENT;} bool is_valid() const { return 1; } @@ -3438,7 +3437,7 @@ public: #endif Gtid_log_event(const char *buf, uint event_len, const Format_description_log_event *description_event); - ~Gtid_log_event() { } + ~Gtid_log_event() = default; Log_event_type get_type_code() { return GTID_EVENT; } enum_logged_status logged_status() { return LOGGED_NO_DATA; } int get_data_size() @@ -3691,7 +3690,7 @@ public: Append_block_log_event(const char* buf, uint event_len, const Format_description_log_event *description_event); - ~Append_block_log_event() {} + ~Append_block_log_event() = default; Log_event_type get_type_code() { return APPEND_BLOCK_EVENT;} int get_data_size() { return block_len + APPEND_BLOCK_HEADER_LEN ;} bool is_valid() const { return block != 0; } @@ -3732,7 +3731,7 @@ public: Delete_file_log_event(const char* buf, uint event_len, const Format_description_log_event* description_event); - ~Delete_file_log_event() {} + ~Delete_file_log_event() = default; Log_event_type get_type_code() { return DELETE_FILE_EVENT;} int get_data_size() { return DELETE_FILE_HEADER_LEN ;} bool is_valid() const { return file_id != 0; } @@ -3772,7 +3771,7 @@ public: Execute_load_log_event(const char* buf, uint event_len, const Format_description_log_event *description_event); - ~Execute_load_log_event() {} + ~Execute_load_log_event() = default; Log_event_type get_type_code() { return EXEC_LOAD_EVENT;} int get_data_size() { return EXEC_LOAD_HEADER_LEN ;} bool is_valid() const { return file_id != 0; } @@ -3812,7 +3811,7 @@ public: Begin_load_query_log_event(const char* buf, uint event_len, const Format_description_log_event *description_event); - ~Begin_load_query_log_event() {} + ~Begin_load_query_log_event() = default; Log_event_type get_type_code() { return BEGIN_LOAD_QUERY_EVENT; } private: #if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION) @@ -3870,7 +3869,7 @@ public: Execute_load_query_log_event(const char* buf, uint event_len, const Format_description_log_event *description_event); - ~Execute_load_query_log_event() {} + ~Execute_load_query_log_event() = default; Log_event_type get_type_code() { return EXECUTE_LOAD_QUERY_EVENT; } bool is_valid() const { return Query_log_event::is_valid() && file_id != 0; } @@ -3908,7 +3907,7 @@ public: {} /* constructor for hopelessly corrupted events */ Unknown_log_event(): Log_event(), what(ENCRYPTED) {} - ~Unknown_log_event() {} + ~Unknown_log_event() = default; bool print(FILE* file, PRINT_EVENT_INFO* print_event_info); Log_event_type get_type_code() { return UNKNOWN_EVENT;} bool is_valid() const { return 1; } diff --git a/sql/mdl.cc b/sql/mdl.cc index 3b553c5ce37..abb2d1372b8 100644 --- a/sql/mdl.cc +++ b/sql/mdl.cc @@ -406,7 +406,7 @@ public: virtual bool needs_notification(const MDL_ticket *ticket) const = 0; virtual bool conflicting_locks(const MDL_ticket *ticket) const = 0; virtual bitmap_t hog_lock_types_bitmap() const = 0; - virtual ~MDL_lock_strategy() {} + virtual ~MDL_lock_strategy() = default; }; @@ -417,7 +417,7 @@ public: */ struct MDL_scoped_lock : public MDL_lock_strategy { - MDL_scoped_lock() {} + MDL_scoped_lock() = default; virtual const bitmap_t *incompatible_granted_types_bitmap() const { return m_granted_incompatible; } virtual const bitmap_t *incompatible_waiting_types_bitmap() const @@ -454,7 +454,7 @@ public: */ struct MDL_object_lock : public MDL_lock_strategy { - MDL_object_lock() {} + MDL_object_lock() = default; virtual const bitmap_t *incompatible_granted_types_bitmap() const { return m_granted_incompatible; } virtual const bitmap_t *incompatible_waiting_types_bitmap() const @@ -498,7 +498,7 @@ public: struct MDL_backup_lock: public MDL_lock_strategy { - MDL_backup_lock() {} + MDL_backup_lock() = default; virtual const bitmap_t *incompatible_granted_types_bitmap() const { return m_granted_incompatible; } virtual const bitmap_t *incompatible_waiting_types_bitmap() const @@ -1895,13 +1895,11 @@ bool MDL_lock::has_pending_conflicting_lock(enum_mdl_type type) MDL_wait_for_graph_visitor::~MDL_wait_for_graph_visitor() -{ -} += default; MDL_wait_for_subgraph::~MDL_wait_for_subgraph() -{ -} += default; /** Check if ticket represents metadata lock of "stronger" or equal type diff --git a/sql/mdl.h b/sql/mdl.h index 55d6ddf845b..1f14188ec59 100644 --- a/sql/mdl.h +++ b/sql/mdl.h @@ -58,7 +58,7 @@ typedef unsigned short mdl_bitmap_t; class MDL_context_owner { public: - virtual ~MDL_context_owner() {} + virtual ~MDL_context_owner() = default; /** Enter a condition wait. @@ -469,7 +469,7 @@ public: { mdl_key_init(namespace_arg, db_arg, name_arg); } - MDL_key() {} /* To use when part of MDL_request. */ + MDL_key() = default; /* To use when part of MDL_request. */ /** Get thread state name to be used in case when we have to @@ -627,7 +627,7 @@ public: virtual bool inspect_edge(MDL_context *dest) = 0; virtual ~MDL_wait_for_graph_visitor(); - MDL_wait_for_graph_visitor() {} + MDL_wait_for_graph_visitor() = default; }; /** @@ -779,7 +779,7 @@ private: class MDL_savepoint { public: - MDL_savepoint() {}; + MDL_savepoint() = default;; private: MDL_savepoint(MDL_ticket *stmt_ticket, MDL_ticket *trans_ticket) diff --git a/sql/multi_range_read.h b/sql/multi_range_read.h index 37a00e3086f..57cfd21727f 100644 --- a/sql/multi_range_read.h +++ b/sql/multi_range_read.h @@ -204,7 +204,7 @@ class Mrr_reader public: virtual int get_next(range_id_t *range_info) = 0; virtual int refill_buffer(bool initial) = 0; - virtual ~Mrr_reader() {}; /* just to remove compiler warning */ + virtual ~Mrr_reader() = default; /* just to remove compiler warning */ }; diff --git a/sql/my_apc.h b/sql/my_apc.h index cc98e36bbe4..2c0a9ade314 100644 --- a/sql/my_apc.h +++ b/sql/my_apc.h @@ -92,7 +92,7 @@ public: public: /* This function will be called in the target thread */ virtual void call_in_target_thread()= 0; - virtual ~Apc_call() {} + virtual ~Apc_call() = default; }; /* Make a call in the target thread (see function definition for details) */ diff --git a/sql/my_json_writer.h b/sql/my_json_writer.h index 4b69ba70675..c353831655a 100644 --- a/sql/my_json_writer.h +++ b/sql/my_json_writer.h @@ -385,9 +385,7 @@ protected: public: - virtual ~Json_writer_struct() - { - } + virtual ~Json_writer_struct() = default; bool trace_started() const { diff --git a/sql/mysqld.cc b/sql/mysqld.cc index 3ace30dd81e..23494d8aff0 100644 --- a/sql/mysqld.cc +++ b/sql/mysqld.cc @@ -1217,8 +1217,7 @@ class Buffered_log : public Sql_alloc public: Buffered_log(enum loglevel level, const char *message); - ~Buffered_log() - {} + ~Buffered_log() = default; void print(void); @@ -1278,11 +1277,9 @@ void Buffered_log::print() class Buffered_logs { public: - Buffered_logs() - {} + Buffered_logs() = default; - ~Buffered_logs() - {} + ~Buffered_logs() = default; void init(); void cleanup(); diff --git a/sql/opt_range.cc b/sql/opt_range.cc index a2bbe1447e9..c34420181a2 100644 --- a/sql/opt_range.cc +++ b/sql/opt_range.cc @@ -2212,7 +2212,7 @@ public: { return (void*) alloc_root(mem_root, (uint) size); } static void operator delete(void *ptr,size_t size) { TRASH_FREE(ptr, size); } static void operator delete(void *ptr, MEM_ROOT *mem_root) { /* Never called */ } - virtual ~TABLE_READ_PLAN() {} /* Remove gcc warning */ + virtual ~TABLE_READ_PLAN() = default; /* Remove gcc warning */ /** Add basic info for this TABLE_READ_PLAN to the optimizer trace. @@ -2247,7 +2247,7 @@ public: TRP_RANGE(SEL_ARG *key_arg, uint idx_arg, uint mrr_flags_arg) : key(key_arg), key_idx(idx_arg), mrr_flags(mrr_flags_arg) {} - virtual ~TRP_RANGE() {} /* Remove gcc warning */ + virtual ~TRP_RANGE() = default; /* Remove gcc warning */ QUICK_SELECT_I *make_quick(PARAM *param, bool retrieve_full_rows, MEM_ROOT *parent_alloc) @@ -2294,8 +2294,8 @@ void TRP_RANGE::trace_basic_info(PARAM *param, class TRP_ROR_INTERSECT : public TABLE_READ_PLAN { public: - TRP_ROR_INTERSECT() {} /* Remove gcc warning */ - virtual ~TRP_ROR_INTERSECT() {} /* Remove gcc warning */ + TRP_ROR_INTERSECT() = default; /* Remove gcc warning */ + virtual ~TRP_ROR_INTERSECT() = default; /* Remove gcc warning */ QUICK_SELECT_I *make_quick(PARAM *param, bool retrieve_full_rows, MEM_ROOT *parent_alloc); @@ -2320,8 +2320,8 @@ public: class TRP_ROR_UNION : public TABLE_READ_PLAN { public: - TRP_ROR_UNION() {} /* Remove gcc warning */ - virtual ~TRP_ROR_UNION() {} /* Remove gcc warning */ + TRP_ROR_UNION() = default; /* Remove gcc warning */ + virtual ~TRP_ROR_UNION() = default; /* Remove gcc warning */ QUICK_SELECT_I *make_quick(PARAM *param, bool retrieve_full_rows, MEM_ROOT *parent_alloc); TABLE_READ_PLAN **first_ror; /* array of ptrs to plans for merged scans */ @@ -2353,8 +2353,8 @@ void TRP_ROR_UNION::trace_basic_info(PARAM *param, class TRP_INDEX_INTERSECT : public TABLE_READ_PLAN { public: - TRP_INDEX_INTERSECT() {} /* Remove gcc warning */ - virtual ~TRP_INDEX_INTERSECT() {} /* Remove gcc warning */ + TRP_INDEX_INTERSECT() = default; /* Remove gcc warning */ + virtual ~TRP_INDEX_INTERSECT() = default; /* Remove gcc warning */ QUICK_SELECT_I *make_quick(PARAM *param, bool retrieve_full_rows, MEM_ROOT *parent_alloc); TRP_RANGE **range_scans; /* array of ptrs to plans of intersected scans */ @@ -2390,8 +2390,8 @@ void TRP_INDEX_INTERSECT::trace_basic_info(PARAM *param, class TRP_INDEX_MERGE : public TABLE_READ_PLAN { public: - TRP_INDEX_MERGE() {} /* Remove gcc warning */ - virtual ~TRP_INDEX_MERGE() {} /* Remove gcc warning */ + TRP_INDEX_MERGE() = default; /* Remove gcc warning */ + virtual ~TRP_INDEX_MERGE() = default; /* Remove gcc warning */ QUICK_SELECT_I *make_quick(PARAM *param, bool retrieve_full_rows, MEM_ROOT *parent_alloc); TRP_RANGE **range_scans; /* array of ptrs to plans of merged scans */ @@ -2459,7 +2459,7 @@ public: if (key_infix_len) memcpy(this->key_infix, key_infix_arg, key_infix_len); } - virtual ~TRP_GROUP_MIN_MAX() {} /* Remove gcc warning */ + virtual ~TRP_GROUP_MIN_MAX() = default; /* Remove gcc warning */ QUICK_SELECT_I *make_quick(PARAM *param, bool retrieve_full_rows, MEM_ROOT *parent_alloc); @@ -9664,7 +9664,6 @@ tree_or(RANGE_OPT_PARAM *param,SEL_TREE *tree1,SEL_TREE *tree2) DBUG_RETURN(tree2); SEL_TREE *result= NULL; - key_map result_keys; key_map ored_keys; SEL_TREE *rtree[2]= {NULL,NULL}; SEL_IMERGE *imerge[2]= {NULL, NULL}; diff --git a/sql/opt_range.h b/sql/opt_range.h index 42cede28f20..3f9d29a4447 100644 --- a/sql/opt_range.h +++ b/sql/opt_range.h @@ -265,7 +265,7 @@ public: enum { MAX_SEL_ARGS = 16000 }; - SEL_ARG() {} + SEL_ARG() = default; SEL_ARG(SEL_ARG &); SEL_ARG(Field *,const uchar *, const uchar *); SEL_ARG(Field *field, uint8 part, uchar *min_value, uchar *max_value, @@ -871,7 +871,7 @@ public: uint used_key_parts; QUICK_SELECT_I(); - virtual ~QUICK_SELECT_I(){}; + virtual ~QUICK_SELECT_I() = default;; /* Do post-constructor initialization. diff --git a/sql/opt_table_elimination.cc b/sql/opt_table_elimination.cc index 3958797ec44..165dff5544f 100644 --- a/sql/opt_table_elimination.cc +++ b/sql/opt_table_elimination.cc @@ -218,7 +218,7 @@ class Dep_value : public Sql_alloc { public: Dep_value(): bound(FALSE) {} - virtual ~Dep_value(){} /* purecov: inspected */ /* stop compiler warnings */ + virtual ~Dep_value() = default; /* purecov: inspected */ bool is_bound() { return bound; } void make_bound() { bound= TRUE; } @@ -342,7 +342,7 @@ const size_t Dep_value::iterator_size= class Dep_module : public Sql_alloc { public: - virtual ~Dep_module(){} /* purecov: inspected */ /* stop compiler warnings */ + virtual ~Dep_module() = default; /* purecov: inspected */ /* Mark as bound. Currently is non-virtual and does nothing */ void make_bound() {}; diff --git a/sql/parse_file.h b/sql/parse_file.h index cbd41d16cbc..27fa0038d5b 100644 --- a/sql/parse_file.h +++ b/sql/parse_file.h @@ -55,8 +55,8 @@ struct File_option class Unknown_key_hook { public: - Unknown_key_hook() {} /* Remove gcc warning */ - virtual ~Unknown_key_hook() {} /* Remove gcc warning */ + Unknown_key_hook() = default; /* Remove gcc warning */ + virtual ~Unknown_key_hook() = default; /* Remove gcc warning */ virtual bool process_unknown_string(const char *&unknown_key, uchar* base, MEM_ROOT *mem_root, const char *end)= 0; }; @@ -67,7 +67,7 @@ public: class File_parser_dummy_hook: public Unknown_key_hook { public: - File_parser_dummy_hook() {} /* Remove gcc warning */ + File_parser_dummy_hook() = default; /* Remove gcc warning */ virtual bool process_unknown_string(const char *&unknown_key, uchar* base, MEM_ROOT *mem_root, const char *end); }; diff --git a/sql/partition_element.h b/sql/partition_element.h index e0a519065cc..c372625682f 100644 --- a/sql/partition_element.h +++ b/sql/partition_element.h @@ -159,7 +159,7 @@ public: empty(part_elem->empty), type(CONVENTIONAL) {} - ~partition_element() {} + ~partition_element() = default; part_column_list_val& get_col_val(uint idx) { diff --git a/sql/partition_info.h b/sql/partition_info.h index afdc7e9480e..81b88b263bc 100644 --- a/sql/partition_info.h +++ b/sql/partition_info.h @@ -325,7 +325,7 @@ public: part_field_list.empty(); subpart_field_list.empty(); } - ~partition_info() {} + ~partition_info() = default; partition_info *get_clone(THD *thd, bool empty_data_and_index_file= FALSE); bool set_named_partition_bitmap(const char *part_name, size_t length); diff --git a/sql/protocol.h b/sql/protocol.h index 3b2c905ed9e..464af7bbaa0 100644 --- a/sql/protocol.h +++ b/sql/protocol.h @@ -80,7 +80,7 @@ protected: public: THD *thd; Protocol(THD *thd_arg) { init(thd_arg); } - virtual ~Protocol() {} + virtual ~Protocol() = default; void init(THD* thd_arg); enum { SEND_NUM_ROWS= 1, SEND_EOF= 2 }; diff --git a/sql/rowid_filter.h b/sql/rowid_filter.h index b76b8b1e635..eabf1f05fec 100644 --- a/sql/rowid_filter.h +++ b/sql/rowid_filter.h @@ -195,7 +195,7 @@ public: /* True if the container does not contain any element */ virtual bool is_empty() = 0; - virtual ~Rowid_filter_container() {} + virtual ~Rowid_filter_container() = default; }; @@ -232,7 +232,7 @@ public: */ virtual bool check(char *elem) = 0; - virtual ~Rowid_filter() {} + virtual ~Rowid_filter() = default; bool is_empty() { return container->is_empty(); } diff --git a/sql/rpl_injector.cc b/sql/rpl_injector.cc index 442d28fceb3..d8eb6a5f6f1 100644 --- a/sql/rpl_injector.cc +++ b/sql/rpl_injector.cc @@ -129,9 +129,7 @@ injector::transaction::binlog_pos injector::transaction::start_pos() const */ /* This constructor is called below */ -inline injector::injector() -{ -} +inline injector::injector() = default; static injector *s_injector= 0; injector *injector::instance() diff --git a/sql/rpl_injector.h b/sql/rpl_injector.h index 6fff3fc2415..0bb37209f75 100644 --- a/sql/rpl_injector.h +++ b/sql/rpl_injector.h @@ -306,7 +306,7 @@ public: private: explicit injector(); - ~injector() { } /* Nothing needs to be done */ + ~injector() = default; /* Nothing needs to be done */ injector(injector const&); /* You're not allowed to copy injector instances. */ diff --git a/sql/select_handler.h b/sql/select_handler.h index e2ad13b7cdf..877dac60e12 100644 --- a/sql/select_handler.h +++ b/sql/select_handler.h @@ -45,7 +45,7 @@ class select_handler select_handler(THD *thd_arg, handlerton *ht_arg) : thd(thd_arg), ht(ht_arg), table(0) {} - virtual ~select_handler() {} + virtual ~select_handler() = default; /* Functions to scan the select result set. diff --git a/sql/semisync_master.h b/sql/semisync_master.h index 16cf8a91215..9848f818fc5 100644 --- a/sql/semisync_master.h +++ b/sql/semisync_master.h @@ -454,7 +454,7 @@ class Repl_semi_sync_master public: Repl_semi_sync_master(); - ~Repl_semi_sync_master() {} + ~Repl_semi_sync_master() = default; void cleanup(); diff --git a/sql/semisync_master_ack_receiver.h b/sql/semisync_master_ack_receiver.h index 138f7b5aeed..4341729b5cf 100644 --- a/sql/semisync_master_ack_receiver.h +++ b/sql/semisync_master_ack_receiver.h @@ -50,7 +50,7 @@ class Ack_receiver : public Repl_semi_sync_base { public: Ack_receiver(); - ~Ack_receiver() {} + ~Ack_receiver() = default; void cleanup(); /** Notify ack receiver to receive acks on the dump session. diff --git a/sql/semisync_slave.h b/sql/semisync_slave.h index 35f93476792..b14d531d13c 100644 --- a/sql/semisync_slave.h +++ b/sql/semisync_slave.h @@ -34,7 +34,7 @@ class Repl_semi_sync_slave :public Repl_semi_sync_base { public: Repl_semi_sync_slave() :m_slave_enabled(false) {} - ~Repl_semi_sync_slave() {} + ~Repl_semi_sync_slave() = default; void set_trace_level(unsigned long trace_level) { m_trace_level = trace_level; diff --git a/sql/session_tracker.h b/sql/session_tracker.h index 226b026d590..03744155e46 100644 --- a/sql/session_tracker.h +++ b/sql/session_tracker.h @@ -71,7 +71,7 @@ private: bool m_changed; public: - virtual ~State_tracker() {} + virtual ~State_tracker() = default; /** Getters */ bool is_enabled() const diff --git a/sql/set_var.h b/sql/set_var.h index 56de00221d8..705751b8296 100644 --- a/sql/set_var.h +++ b/sql/set_var.h @@ -99,7 +99,7 @@ public: on_check_function on_check_func, on_update_function on_update_func, const char *substitute); - virtual ~sys_var() {} + virtual ~sys_var() = default; /** All the cleanup procedures should be performed here @@ -269,8 +269,8 @@ protected: class set_var_base :public Sql_alloc { public: - set_var_base() {} - virtual ~set_var_base() {} + set_var_base() = default; + virtual ~set_var_base() = default; virtual int check(THD *thd)=0; /* To check privileges etc. */ virtual int update(THD *thd)=0; /* To set the value */ virtual int light_check(THD *thd) { return check(thd); } /* for PS */ diff --git a/sql/sp.h b/sql/sp.h index 49bf1eb93cf..56007a2fa72 100644 --- a/sql/sp.h +++ b/sql/sp.h @@ -118,7 +118,7 @@ public: // TODO: make it private or protected const; public: - virtual ~Sp_handler() {} + virtual ~Sp_handler() = default; static const Sp_handler *handler(enum enum_sql_command cmd); static const Sp_handler *handler(stored_procedure_type type); static const Sp_handler *handler(MDL_key::enum_mdl_namespace ns); diff --git a/sql/sp_head.h b/sql/sp_head.h index 69232da10c7..06f5d5234ae 100644 --- a/sql/sp_head.h +++ b/sql/sp_head.h @@ -116,8 +116,7 @@ public: /** Create temporary sp_name object from MDL key. Store in qname_buff */ sp_name(const MDL_key *key, char *qname_buff); - ~sp_name() - {} + ~sp_name() = default; }; @@ -1286,8 +1285,7 @@ public: m_query.length= 0; } - virtual ~sp_instr_stmt() - {}; + virtual ~sp_instr_stmt() = default; virtual int execute(THD *thd, uint *nextp); @@ -1318,8 +1316,7 @@ public: m_lex_keeper(lex, lex_resp) {} - virtual ~sp_instr_set() - {} + virtual ~sp_instr_set() = default; virtual int execute(THD *thd, uint *nextp); @@ -1358,8 +1355,7 @@ public: m_field_offset(field_offset) {} - virtual ~sp_instr_set_row_field() - {} + virtual ~sp_instr_set_row_field() = default; virtual int exec_core(THD *thd, uint *nextp); @@ -1401,8 +1397,7 @@ public: m_field_name(field_name) {} - virtual ~sp_instr_set_row_field_by_name() - {} + virtual ~sp_instr_set_row_field_by_name() = default; virtual int exec_core(THD *thd, uint *nextp); @@ -1428,8 +1423,7 @@ public: value(val), m_lex_keeper(lex, TRUE) {} - virtual ~sp_instr_set_trigger_field() - {} + virtual ~sp_instr_set_trigger_field() = default; virtual int execute(THD *thd, uint *nextp); @@ -1468,8 +1462,7 @@ public: m_dest(dest), m_cont_dest(0), m_optdest(0), m_cont_optdest(0) {} - virtual ~sp_instr_opt_meta() - {} + virtual ~sp_instr_opt_meta() = default; virtual void set_destination(uint old_dest, uint new_dest) = 0; @@ -1498,8 +1491,7 @@ public: : sp_instr_opt_meta(ip, ctx, dest) {} - virtual ~sp_instr_jump() - {} + virtual ~sp_instr_jump() = default; virtual int execute(THD *thd, uint *nextp); @@ -1547,8 +1539,7 @@ public: m_lex_keeper(lex, TRUE) {} - virtual ~sp_instr_jump_if_not() - {} + virtual ~sp_instr_jump_if_not() = default; virtual int execute(THD *thd, uint *nextp); @@ -1592,8 +1583,7 @@ public: : sp_instr(ip, ctx) {} - virtual ~sp_instr_preturn() - {} + virtual ~sp_instr_preturn() = default; virtual int execute(THD *thd, uint *nextp) { @@ -1629,8 +1619,7 @@ public: m_lex_keeper(lex, TRUE) {} - virtual ~sp_instr_freturn() - {} + virtual ~sp_instr_freturn() = default; virtual int execute(THD *thd, uint *nextp); @@ -1729,8 +1718,7 @@ public: : sp_instr(ip, ctx), m_count(count) {} - virtual ~sp_instr_hpop() - {} + virtual ~sp_instr_hpop() = default; void update_count(uint count) { @@ -1760,8 +1748,7 @@ public: m_frame(ctx->current_var_count()) {} - virtual ~sp_instr_hreturn() - {} + virtual ~sp_instr_hreturn() = default; virtual int execute(THD *thd, uint *nextp); @@ -1795,8 +1782,7 @@ public: : sp_instr(ip, ctx), m_lex_keeper(lex, TRUE), m_cursor(offset) {} - virtual ~sp_instr_cpush() - {} + virtual ~sp_instr_cpush() = default; virtual int execute(THD *thd, uint *nextp); @@ -1827,8 +1813,7 @@ public: : sp_instr(ip, ctx), m_count(count) {} - virtual ~sp_instr_cpop() - {} + virtual ~sp_instr_cpop() = default; void update_count(uint count) { @@ -1857,8 +1842,7 @@ public: : sp_instr(ip, ctx), m_cursor(c) {} - virtual ~sp_instr_copen() - {} + virtual ~sp_instr_copen() = default; virtual int execute(THD *thd, uint *nextp); @@ -1892,8 +1876,7 @@ public: m_cursor(coffs), m_var(voffs) {} - virtual ~sp_instr_cursor_copy_struct() - {} + virtual ~sp_instr_cursor_copy_struct() = default; virtual int execute(THD *thd, uint *nextp); virtual int exec_core(THD *thd, uint *nextp); virtual void print(String *str); @@ -1911,8 +1894,7 @@ public: : sp_instr(ip, ctx), m_cursor(c) {} - virtual ~sp_instr_cclose() - {} + virtual ~sp_instr_cclose() = default; virtual int execute(THD *thd, uint *nextp); @@ -1938,8 +1920,7 @@ public: m_varlist.empty(); } - virtual ~sp_instr_cfetch() - {} + virtual ~sp_instr_cfetch() = default; virtual int execute(THD *thd, uint *nextp); @@ -1974,8 +1955,7 @@ public: sp_instr_agg_cfetch(uint ip, sp_pcontext *ctx) : sp_instr(ip, ctx){} - virtual ~sp_instr_agg_cfetch() - {} + virtual ~sp_instr_agg_cfetch() = default; virtual int execute(THD *thd, uint *nextp); @@ -1996,8 +1976,7 @@ public: : sp_instr(ip, ctx), m_errcode(errcode) {} - virtual ~sp_instr_error() - {} + virtual ~sp_instr_error() = default; virtual int execute(THD *thd, uint *nextp); @@ -2027,8 +2006,7 @@ public: m_lex_keeper(lex, TRUE) {} - virtual ~sp_instr_set_case_expr() - {} + virtual ~sp_instr_set_case_expr() = default; virtual int execute(THD *thd, uint *nextp); diff --git a/sql/spatial.h b/sql/spatial.h index 1a69b32bb1c..bfac0f4c5f6 100644 --- a/sql/spatial.h +++ b/sql/spatial.h @@ -214,8 +214,8 @@ struct Geometry_buffer; class Geometry { public: - Geometry() {} /* Remove gcc warning */ - virtual ~Geometry() {} /* Remove gcc warning */ + Geometry() = default; /* Remove gcc warning */ + virtual ~Geometry() = default; /* Remove gcc warning */ static void *operator new(size_t size, void *buffer) { return buffer; @@ -396,8 +396,8 @@ protected: class Gis_point: public Geometry { public: - Gis_point() {} /* Remove gcc warning */ - virtual ~Gis_point() {} /* Remove gcc warning */ + Gis_point() = default; /* Remove gcc warning */ + virtual ~Gis_point() = default; /* Remove gcc warning */ uint32 get_data_size() const; bool init_from_wkt(Gis_read_stream *trs, String *wkb); uint init_from_wkb(const char *wkb, uint len, wkbByteOrder bo, String *res); @@ -466,8 +466,8 @@ public: class Gis_line_string: public Geometry { public: - Gis_line_string() {} /* Remove gcc warning */ - virtual ~Gis_line_string() {} /* Remove gcc warning */ + Gis_line_string() = default; /* Remove gcc warning */ + virtual ~Gis_line_string() = default; /* Remove gcc warning */ uint32 get_data_size() const; bool init_from_wkt(Gis_read_stream *trs, String *wkb); uint init_from_wkb(const char *wkb, uint len, wkbByteOrder bo, String *res); @@ -499,8 +499,8 @@ public: class Gis_polygon: public Geometry { public: - Gis_polygon() {} /* Remove gcc warning */ - virtual ~Gis_polygon() {} /* Remove gcc warning */ + Gis_polygon() = default; /* Remove gcc warning */ + virtual ~Gis_polygon() = default; /* Remove gcc warning */ uint32 get_data_size() const; bool init_from_wkt(Gis_read_stream *trs, String *wkb); uint init_from_wkb(const char *wkb, uint len, wkbByteOrder bo, String *res); @@ -536,8 +536,8 @@ class Gis_multi_point: public Geometry (uint32) (UINT_MAX32 - WKB_HEADER_SIZE - 4 /* n_points */) / (WKB_HEADER_SIZE + POINT_DATA_SIZE); public: - Gis_multi_point() {} /* Remove gcc warning */ - virtual ~Gis_multi_point() {} /* Remove gcc warning */ + Gis_multi_point() = default; /* Remove gcc warning */ + virtual ~Gis_multi_point() = default; /* Remove gcc warning */ uint32 get_data_size() const; bool init_from_wkt(Gis_read_stream *trs, String *wkb); uint init_from_wkb(const char *wkb, uint len, wkbByteOrder bo, String *res); @@ -567,8 +567,8 @@ public: class Gis_multi_line_string: public Geometry { public: - Gis_multi_line_string() {} /* Remove gcc warning */ - virtual ~Gis_multi_line_string() {} /* Remove gcc warning */ + Gis_multi_line_string() = default; /* Remove gcc warning */ + virtual ~Gis_multi_line_string() = default; /* Remove gcc warning */ uint32 get_data_size() const; bool init_from_wkt(Gis_read_stream *trs, String *wkb); uint init_from_wkb(const char *wkb, uint len, wkbByteOrder bo, String *res); @@ -598,8 +598,8 @@ public: class Gis_multi_polygon: public Geometry { public: - Gis_multi_polygon() {} /* Remove gcc warning */ - virtual ~Gis_multi_polygon() {} /* Remove gcc warning */ + Gis_multi_polygon() = default; /* Remove gcc warning */ + virtual ~Gis_multi_polygon() = default; /* Remove gcc warning */ uint32 get_data_size() const; bool init_from_wkt(Gis_read_stream *trs, String *wkb); uint init_from_wkb(const char *wkb, uint len, wkbByteOrder bo, String *res); @@ -629,8 +629,8 @@ public: class Gis_geometry_collection: public Geometry { public: - Gis_geometry_collection() {} /* Remove gcc warning */ - virtual ~Gis_geometry_collection() {} /* Remove gcc warning */ + Gis_geometry_collection() = default; /* Remove gcc warning */ + virtual ~Gis_geometry_collection() = default; /* Remove gcc warning */ uint32 get_data_size() const; bool init_from_wkt(Gis_read_stream *trs, String *wkb); uint init_from_wkb(const char *wkb, uint len, wkbByteOrder bo, String *res); diff --git a/sql/sql_acl.cc b/sql/sql_acl.cc index 211114f0d19..c6b1631523c 100644 --- a/sql/sql_acl.cc +++ b/sql/sql_acl.cc @@ -191,7 +191,7 @@ class ACL_USER :public ACL_USER_BASE, { public: - ACL_USER() { } + ACL_USER() = default; ACL_USER(THD *thd, const LEX_USER &combo, const Account_options &options, const ulong privileges); @@ -328,7 +328,7 @@ class ACL_PROXY_USER :public ACL_ACCESS MYSQL_PROXIES_PRIV_GRANTOR, MYSQL_PROXIES_PRIV_TIMESTAMP } proxy_table_fields; public: - ACL_PROXY_USER () {}; + ACL_PROXY_USER () = default; void init(const char *host_arg, const char *user_arg, const char *proxied_host_arg, const char *proxied_user_arg, @@ -919,7 +919,7 @@ class User_table: public Grant_table_base virtual longlong get_password_lifetime () const = 0; virtual int set_password_lifetime (longlong x) const = 0; - virtual ~User_table() {} + virtual ~User_table() = default; private: friend class Grant_tables; virtual int setup_sysvars() const = 0; @@ -1250,7 +1250,7 @@ class User_table_tabular: public User_table return 1; } - virtual ~User_table_tabular() {} + virtual ~User_table_tabular() = default; private: friend class Grant_tables; @@ -1566,7 +1566,7 @@ class User_table_json: public User_table int set_password_expired (bool x) const { return x ? set_password_last_changed(0) : 0; } - ~User_table_json() {} + ~User_table_json() = default; private: friend class Grant_tables; static const uint JSON_SIZE=1024; @@ -5181,7 +5181,7 @@ public: GRANT_NAME(const char *h, const char *d,const char *u, const char *t, ulong p, bool is_routine); GRANT_NAME (TABLE *form, bool is_routine); - virtual ~GRANT_NAME() {}; + virtual ~GRANT_NAME() = default; virtual bool ok() { return privs != 0; } void set_user_details(const char *h, const char *d, const char *u, const char *t, @@ -11446,8 +11446,7 @@ public: : is_grave(FALSE) {} - virtual ~Silence_routine_definer_errors() - {} + virtual ~Silence_routine_definer_errors() = default; virtual bool handle_condition(THD *thd, uint sql_errno, diff --git a/sql/sql_acl.h b/sql/sql_acl.h index 3d415051f28..bf4d100d136 100644 --- a/sql/sql_acl.h +++ b/sql/sql_acl.h @@ -321,11 +321,9 @@ enum ACL_internal_access_result class ACL_internal_table_access { public: - ACL_internal_table_access() - {} + ACL_internal_table_access() = default; - virtual ~ACL_internal_table_access() - {} + virtual ~ACL_internal_table_access() = default; /** Check access to an internal table. @@ -360,11 +358,9 @@ public: class ACL_internal_schema_access { public: - ACL_internal_schema_access() - {} + ACL_internal_schema_access() = default; - virtual ~ACL_internal_schema_access() - {} + virtual ~ACL_internal_schema_access() = default; /** Check access to an internal schema. diff --git a/sql/sql_admin.h b/sql/sql_admin.h index d31726d32a4..ac20653dc63 100644 --- a/sql/sql_admin.h +++ b/sql/sql_admin.h @@ -34,11 +34,9 @@ public: /** Constructor, used to represent a ANALYZE TABLE statement. */ - Sql_cmd_analyze_table() - {} + Sql_cmd_analyze_table() = default; - ~Sql_cmd_analyze_table() - {} + ~Sql_cmd_analyze_table() = default; bool execute(THD *thd); @@ -59,11 +57,9 @@ public: /** Constructor, used to represent a CHECK TABLE statement. */ - Sql_cmd_check_table() - {} + Sql_cmd_check_table() = default; - ~Sql_cmd_check_table() - {} + ~Sql_cmd_check_table() = default; bool execute(THD *thd); @@ -83,11 +79,9 @@ public: /** Constructor, used to represent a OPTIMIZE TABLE statement. */ - Sql_cmd_optimize_table() - {} + Sql_cmd_optimize_table() = default; - ~Sql_cmd_optimize_table() - {} + ~Sql_cmd_optimize_table() = default; bool execute(THD *thd); @@ -108,11 +102,9 @@ public: /** Constructor, used to represent a REPAIR TABLE statement. */ - Sql_cmd_repair_table() - {} + Sql_cmd_repair_table() = default; - ~Sql_cmd_repair_table() - {} + ~Sql_cmd_repair_table() = default; bool execute(THD *thd); diff --git a/sql/sql_alter.h b/sql/sql_alter.h index d9749592a4f..8dd25524440 100644 --- a/sql/sql_alter.h +++ b/sql/sql_alter.h @@ -355,11 +355,9 @@ protected: /** Constructor. */ - Sql_cmd_common_alter_table() - {} + Sql_cmd_common_alter_table() = default; - virtual ~Sql_cmd_common_alter_table() - {} + virtual ~Sql_cmd_common_alter_table() = default; virtual enum_sql_command sql_command_code() const { @@ -378,11 +376,9 @@ public: /** Constructor, used to represent a ALTER TABLE statement. */ - Sql_cmd_alter_table() - {} + Sql_cmd_alter_table() = default; - ~Sql_cmd_alter_table() - {} + ~Sql_cmd_alter_table() = default; Storage_engine_name *option_storage_engine_name() { return this; } @@ -404,8 +400,7 @@ public: :DDL_options(options) {} - ~Sql_cmd_alter_sequence() - {} + ~Sql_cmd_alter_sequence() = default; enum_sql_command sql_command_code() const { diff --git a/sql/sql_base.cc b/sql/sql_base.cc index 77c86972964..d1ee15fb085 100644 --- a/sql/sql_base.cc +++ b/sql/sql_base.cc @@ -1491,7 +1491,7 @@ public: : m_ot_ctx(ot_ctx_arg), m_is_active(FALSE) {} - virtual ~MDL_deadlock_handler() {} + virtual ~MDL_deadlock_handler() = default; virtual bool handle_condition(THD *thd, uint sql_errno, diff --git a/sql/sql_base.h b/sql/sql_base.h index 5d30c3611dc..56c6c82907a 100644 --- a/sql/sql_base.h +++ b/sql/sql_base.h @@ -388,7 +388,7 @@ inline bool setup_fields_with_no_wrap(THD *thd, Ref_ptr_array ref_pointer_array, class Prelocking_strategy { public: - virtual ~Prelocking_strategy() { } + virtual ~Prelocking_strategy() = default; virtual void reset(THD *thd) { }; virtual bool handle_routine(THD *thd, Query_tables_list *prelocking_ctx, diff --git a/sql/sql_bitmap.h b/sql/sql_bitmap.h index 765e4ee2725..a04f07605e7 100644 --- a/sql/sql_bitmap.h +++ b/sql/sql_bitmap.h @@ -99,7 +99,7 @@ public: or to call set_all()/clear_all()/set_prefix() to initialize bitmap. */ - Bitmap() { } + Bitmap() = default; explicit Bitmap(uint prefix) { diff --git a/sql/sql_cache.h b/sql/sql_cache.h index d89bcda2491..a7c5c62996e 100644 --- a/sql/sql_cache.h +++ b/sql/sql_cache.h @@ -91,7 +91,7 @@ typedef my_bool (*qc_engine_callback)(THD *thd, const char *table_key, */ struct Query_cache_block_table { - Query_cache_block_table() {} /* Remove gcc warning */ + Query_cache_block_table() = default; /* Remove gcc warning */ /** This node holds a position in a static table list belonging @@ -122,7 +122,7 @@ struct Query_cache_block_table struct Query_cache_block { - Query_cache_block() {} /* Remove gcc warning */ + Query_cache_block() = default; /* Remove gcc warning */ enum block_type {FREE, QUERY, RESULT, RES_CONT, RES_BEG, RES_INCOMPLETE, TABLE, INCOMPLETE}; @@ -161,7 +161,7 @@ struct Query_cache_query uint8 ready; ulonglong hit_count; - Query_cache_query() {} /* Remove gcc warning */ + Query_cache_query() = default; /* Remove gcc warning */ inline void init_n_lock(); void unlock_n_destroy(); inline ulonglong found_rows() { return limit_found_rows; } @@ -197,7 +197,7 @@ struct Query_cache_query struct Query_cache_table { - Query_cache_table() {} /* Remove gcc warning */ + Query_cache_table() = default; /* Remove gcc warning */ char *tbl; uint32 key_len; uint8 suffix_len; /* For partitioned tables */ @@ -240,7 +240,7 @@ struct Query_cache_table struct Query_cache_result { - Query_cache_result() {} /* Remove gcc warning */ + Query_cache_result() = default; /* Remove gcc warning */ Query_cache_block *query; inline uchar* data() @@ -266,7 +266,7 @@ extern "C" void query_cache_invalidate_by_MyISAM_filename(const char* filename); struct Query_cache_memory_bin { - Query_cache_memory_bin() {} /* Remove gcc warning */ + Query_cache_memory_bin() = default; /* Remove gcc warning */ #ifndef DBUG_OFF size_t size; #endif @@ -285,7 +285,7 @@ struct Query_cache_memory_bin struct Query_cache_memory_bin_step { - Query_cache_memory_bin_step() {} /* Remove gcc warning */ + Query_cache_memory_bin_step() = default; /* Remove gcc warning */ size_t size; size_t increment; size_t idx; diff --git a/sql/sql_class.cc b/sql/sql_class.cc index 300ed902b38..73bb654080a 100644 --- a/sql/sql_class.cc +++ b/sql/sql_class.cc @@ -4072,9 +4072,7 @@ void THD::restore_active_arena(Query_arena *set, Query_arena *backup) DBUG_VOID_RETURN; } -Statement::~Statement() -{ -} +Statement::~Statement() = default; C_MODE_START diff --git a/sql/sql_class.h b/sql/sql_class.h index 42e6aea2aa8..6fa8d696b53 100644 --- a/sql/sql_class.h +++ b/sql/sql_class.h @@ -396,7 +396,7 @@ public: invisible(false) {} Key(const Key &rhs, MEM_ROOT *mem_root); - virtual ~Key() {} + virtual ~Key() = default; /* Equality comparison of keys (ignoring name) */ friend bool foreign_key_prefix(Key *a, Key *b); /** @@ -1096,7 +1096,7 @@ public: Query_arena() { INIT_ARENA_DBUG_INFO; } virtual Type type() const; - virtual ~Query_arena() {}; + virtual ~Query_arena() = default; inline bool is_stmt_prepare() const { return state == STMT_INITIALIZED; } inline bool is_stmt_prepare_or_first_sp_execute() const @@ -1147,7 +1147,7 @@ public: Query_arena_memroot() : Query_arena() {} - virtual ~Query_arena_memroot() {} + virtual ~Query_arena_memroot() = default; }; @@ -1263,7 +1263,7 @@ public: my_bool query_cache_is_applicable; /* This constructor is called for backup statements */ - Statement() {} + Statement() = default; Statement(LEX *lex_arg, MEM_ROOT *mem_root_arg, enum enum_state state_arg, ulong id_arg); @@ -1349,7 +1349,7 @@ struct st_savepoint { class Security_context { public: - Security_context() {} /* Remove gcc warning */ + Security_context() = default; /* Remove gcc warning */ /* host - host of the client user - user of the client, set to NULL until the user has been read from @@ -1768,7 +1768,7 @@ protected: m_prev_internal_handler(NULL) {} - virtual ~Internal_error_handler() {} + virtual ~Internal_error_handler() = default; public: /** @@ -1826,7 +1826,7 @@ public: /* Ignore error */ return TRUE; } - Dummy_error_handler() {} /* Remove gcc warning */ + Dummy_error_handler() = default; /* Remove gcc warning */ }; @@ -1863,7 +1863,7 @@ public: class Drop_table_error_handler : public Internal_error_handler { public: - Drop_table_error_handler() {} + Drop_table_error_handler() = default; public: bool handle_condition(THD *thd, @@ -5232,7 +5232,7 @@ public: example for a duplicate row entry written to a temp table. */ virtual int send_data(List &items)=0; - virtual ~select_result_sink() {}; + virtual ~select_result_sink() = default; void reset(THD *thd_arg) { thd= thd_arg; } }; @@ -5264,7 +5264,7 @@ public: ha_rows est_records; /* estimated number of records in the result */ select_result(THD *thd_arg): select_result_sink(thd_arg), est_records(0) {} void set_unit(SELECT_LEX_UNIT *unit_arg) { unit= unit_arg; } - virtual ~select_result() {}; + virtual ~select_result() = default; /** Change wrapped select_result. @@ -6313,7 +6313,7 @@ class user_var_entry { CHARSET_INFO *m_charset; public: - user_var_entry() {} /* Remove gcc warning */ + user_var_entry() = default; /* Remove gcc warning */ LEX_CSTRING name; char *value; size_t length; @@ -6434,7 +6434,7 @@ public: enum type { SESSION_VAR, LOCAL_VAR, PARAM_VAR }; type scope; my_var(const LEX_CSTRING *j, enum type s) : name(*j), scope(s) { } - virtual ~my_var() {} + virtual ~my_var() = default; virtual bool set(THD *thd, Item *val) = 0; virtual my_var_sp *get_my_var_sp() { return NULL; } }; @@ -6455,7 +6455,7 @@ public: : my_var(j, LOCAL_VAR), m_rcontext_handler(rcontext_handler), m_type_handler(type_handler), offset(o), sp(s) { } - ~my_var_sp() { } + ~my_var_sp() = default; bool set(THD *thd, Item *val); my_var_sp *get_my_var_sp() { return this; } const Type_handler *type_handler() const { return m_type_handler; } @@ -6484,7 +6484,7 @@ class my_var_user: public my_var { public: my_var_user(const LEX_CSTRING *j) : my_var(j, SESSION_VAR) { } - ~my_var_user() { } + ~my_var_user() = default; bool set(THD *thd, Item *val); }; @@ -6497,7 +6497,7 @@ public: select_dumpvar(THD *thd_arg) :select_result_interceptor(thd_arg), row_count(0), m_var_sp_row(NULL) { var_list.empty(); } - ~select_dumpvar() {} + ~select_dumpvar() = default; int prepare(List &list, SELECT_LEX_UNIT *u); int send_data(List &items); bool send_eof(); diff --git a/sql/sql_cmd.h b/sql/sql_cmd.h index 7f1fd06aa46..2aaa88946ee 100644 --- a/sql/sql_cmd.h +++ b/sql/sql_cmd.h @@ -193,8 +193,7 @@ public: } protected: - Sql_cmd() - {} + Sql_cmd() = default; virtual ~Sql_cmd() { @@ -242,8 +241,7 @@ public: m_handler(handler) {} - virtual ~Sql_cmd_call() - {} + virtual ~Sql_cmd_call() = default; /** Execute a CALL statement at runtime. diff --git a/sql/sql_crypt.h b/sql/sql_crypt.h index 3c90550c944..aab97501b48 100644 --- a/sql/sql_crypt.h +++ b/sql/sql_crypt.h @@ -30,12 +30,12 @@ class SQL_CRYPT :public Sql_alloc char decode_buff[256],encode_buff[256]; uint shift; public: - SQL_CRYPT() {} + SQL_CRYPT() = default; SQL_CRYPT(ulong *seed) { init(seed); } - ~SQL_CRYPT() {} + ~SQL_CRYPT() = default; void init(ulong *seed); void reinit() { shift=0; rand=org_rand; } void encode(char *str, uint length); diff --git a/sql/sql_cursor.cc b/sql/sql_cursor.cc index 7d66bd69228..d73d2a36fd5 100644 --- a/sql/sql_cursor.cc +++ b/sql/sql_cursor.cc @@ -197,9 +197,7 @@ end: Server_side_cursor ****************************************************************************/ -Server_side_cursor::~Server_side_cursor() -{ -} +Server_side_cursor::~Server_side_cursor() = default; void Server_side_cursor::operator delete(void *ptr, size_t size) diff --git a/sql/sql_debug.h b/sql/sql_debug.h index c5aa3b5f94e..0d40c0b565c 100644 --- a/sql/sql_debug.h +++ b/sql/sql_debug.h @@ -22,7 +22,7 @@ class Debug_key: public String { public: - Debug_key() { }; + Debug_key() = default; void print(THD *thd) const { push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE, diff --git a/sql/sql_error.h b/sql/sql_error.h index 12926d7209f..5f52aea7dd6 100644 --- a/sql/sql_error.h +++ b/sql/sql_error.h @@ -245,8 +245,7 @@ class Sql_condition_identity: public Sql_state_errno_level, public Sql_user_condition_identity { public: - Sql_condition_identity() - { } + Sql_condition_identity() = default; Sql_condition_identity(const Sql_state_errno_level &st, const Sql_user_condition_identity &ucid) :Sql_state_errno_level(st), @@ -447,8 +446,7 @@ private: } /** Destructor. */ - ~Sql_condition() - {} + ~Sql_condition() = default; /** Copy optional condition items attributes. @@ -863,8 +861,8 @@ public: class ErrConv: public ErrBuff { public: - ErrConv() {} - virtual ~ErrConv() {} + ErrConv() = default; + virtual ~ErrConv() = default; virtual const char *ptr() const = 0; }; diff --git a/sql/sql_explain.h b/sql/sql_explain.h index 6575511bd52..7b5042b9ccf 100644 --- a/sql/sql_explain.h +++ b/sql/sql_explain.h @@ -143,7 +143,7 @@ public: void print_explain_json_for_children(Explain_query *query, Json_writer *writer, bool is_analyze); bool print_explain_json_cache(Json_writer *writer, bool is_analyze); - virtual ~Explain_node(){} + virtual ~Explain_node() = default; }; @@ -290,7 +290,7 @@ class Explain_aggr_node : public Sql_alloc { public: virtual enum_explain_aggr_node_type get_type()= 0; - virtual ~Explain_aggr_node() {} + virtual ~Explain_aggr_node() = default; Explain_aggr_node *child; }; diff --git a/sql/sql_expression_cache.h b/sql/sql_expression_cache.h index d4bb252dccb..79371f22833 100644 --- a/sql/sql_expression_cache.h +++ b/sql/sql_expression_cache.h @@ -36,8 +36,8 @@ class Expression_cache :public Sql_alloc public: enum result {ERROR, HIT, MISS}; - Expression_cache(){}; - virtual ~Expression_cache() {}; + Expression_cache()= default; + virtual ~Expression_cache() = default; /** Shall check the presence of expression value in the cache for a given set of values of the expression parameters. Return the result of the diff --git a/sql/sql_join_cache.h b/sql/sql_join_cache.h index d0bf4761f65..f75e9fd380f 100644 --- a/sql/sql_join_cache.h +++ b/sql/sql_join_cache.h @@ -675,7 +675,7 @@ public: THD *thd(); - virtual ~JOIN_CACHE() {} + virtual ~JOIN_CACHE() = default; void reset_join(JOIN *j) { join= j; } void free() { @@ -1072,7 +1072,7 @@ public: cache= join_tab->cache; } - virtual ~JOIN_TAB_SCAN() {} + virtual ~JOIN_TAB_SCAN() = default; /* Shall calculate the increment of the auxiliary buffer for a record diff --git a/sql/sql_lex.h b/sql/sql_lex.h index 7545a9c4ead..3545a4e8d74 100644 --- a/sql/sql_lex.h +++ b/sql/sql_lex.h @@ -1705,8 +1705,8 @@ public: These constructor and destructor serve for creation/destruction of Query_tables_list instances which are used as backup storage. */ - Query_tables_list() {} - ~Query_tables_list() {} + Query_tables_list() = default; + ~Query_tables_list() = default; /* Initializes (or resets) Query_tables_list object for "real" use. */ void reset_query_tables_list(bool init); @@ -2364,13 +2364,9 @@ class Lex_input_stream const char *str, const char *end, int sep); my_charset_conv_wc_mb get_escape_func(THD *thd, my_wc_t sep) const; public: - Lex_input_stream() - { - } + Lex_input_stream() = default; - ~Lex_input_stream() - { - } + ~Lex_input_stream() = default; /** Object initializer. Must be called before usage. @@ -2962,7 +2958,7 @@ public: protected: bool save_explain_data_intern(MEM_ROOT *mem_root, Explain_update *eu, bool is_analyze); public: - virtual ~Update_plan() {} + virtual ~Update_plan() = default; Update_plan(MEM_ROOT *mem_root_arg) : impossible_where(false), no_partitions(false), @@ -3016,7 +3012,7 @@ enum password_exp_type struct Account_options: public USER_RESOURCES { - Account_options() { } + Account_options() = default; void reset() { @@ -4653,14 +4649,13 @@ class Set_signal_information { public: /** Empty default constructor, use clear() */ - Set_signal_information() {} + Set_signal_information() = default; /** Copy constructor. */ Set_signal_information(const Set_signal_information& set); /** Destructor. */ - ~Set_signal_information() - {} + ~Set_signal_information() = default; /** Clear all items. */ void clear(); @@ -4783,8 +4778,7 @@ public: return m_lip.init(thd, buff, length); } - ~Parser_state() - {} + ~Parser_state() = default; Lex_input_stream m_lip; Yacc_state m_yacc; diff --git a/sql/sql_lifo_buffer.h b/sql/sql_lifo_buffer.h index 0347030e4c6..2d648271898 100644 --- a/sql/sql_lifo_buffer.h +++ b/sql/sql_lifo_buffer.h @@ -138,7 +138,7 @@ public: virtual void remove_unused_space(uchar **unused_start, uchar **unused_end)=0; virtual uchar *used_area() = 0; - virtual ~Lifo_buffer() {}; + virtual ~Lifo_buffer() = default; }; diff --git a/sql/sql_partition_admin.h b/sql/sql_partition_admin.h index 4be9e56e359..b50c3555bcb 100644 --- a/sql/sql_partition_admin.h +++ b/sql/sql_partition_admin.h @@ -127,8 +127,7 @@ public: : Sql_cmd_common_alter_table() {} - ~Sql_cmd_alter_table_exchange_partition() - {} + ~Sql_cmd_alter_table_exchange_partition() = default; bool execute(THD *thd); @@ -150,8 +149,7 @@ public: : Sql_cmd_analyze_table() {} - ~Sql_cmd_alter_table_analyze_partition() - {} + ~Sql_cmd_alter_table_analyze_partition() = default; bool execute(THD *thd); @@ -176,8 +174,7 @@ public: : Sql_cmd_check_table() {} - ~Sql_cmd_alter_table_check_partition() - {} + ~Sql_cmd_alter_table_check_partition() = default; bool execute(THD *thd); @@ -202,8 +199,7 @@ public: : Sql_cmd_optimize_table() {} - ~Sql_cmd_alter_table_optimize_partition() - {} + ~Sql_cmd_alter_table_optimize_partition() = default; bool execute(THD *thd); @@ -228,8 +224,7 @@ public: : Sql_cmd_repair_table() {} - ~Sql_cmd_alter_table_repair_partition() - {} + ~Sql_cmd_alter_table_repair_partition() = default; bool execute(THD *thd); @@ -250,11 +245,9 @@ public: /** Constructor, used to represent a ALTER TABLE TRUNCATE PARTITION statement. */ - Sql_cmd_alter_table_truncate_partition() - {} + Sql_cmd_alter_table_truncate_partition() = default; - virtual ~Sql_cmd_alter_table_truncate_partition() - {} + virtual ~Sql_cmd_alter_table_truncate_partition() = default; bool execute(THD *thd); diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc index 347cb186da2..9c52aea2931 100644 --- a/sql/sql_prepare.cc +++ b/sql/sql_prepare.cc @@ -3922,9 +3922,7 @@ Reprepare_observer::report_error(THD *thd) * Server_runnable *******************************************************************/ -Server_runnable::~Server_runnable() -{ -} +Server_runnable::~Server_runnable() = default; /////////////////////////////////////////////////////////////////////////// diff --git a/sql/sql_prepare.h b/sql/sql_prepare.h index acdaa9a67a7..48910a197d9 100644 --- a/sql/sql_prepare.h +++ b/sql/sql_prepare.h @@ -125,7 +125,7 @@ public: MEM_ROOT *mem_root_arg); /** We don't call member destructors, they all are POD types. */ - ~Ed_result_set() {} + ~Ed_result_set() = default; size_t get_field_count() const { return m_column_count; } diff --git a/sql/sql_schema.h b/sql/sql_schema.h index 7c8f284d526..27ee0c10dce 100644 --- a/sql/sql_schema.h +++ b/sql/sql_schema.h @@ -26,7 +26,7 @@ public: Schema(const LEX_CSTRING &name) :m_name(name) { } - virtual ~Schema() { } + virtual ~Schema() = default; const LEX_CSTRING &name() const { return m_name; } virtual const Type_handler *map_data_type(THD *thd, const Type_handler *src) const diff --git a/sql/sql_select.h b/sql/sql_select.h index 85451eb1ae0..0dfecc98a48 100644 --- a/sql/sql_select.h +++ b/sql/sql_select.h @@ -728,7 +728,7 @@ public: virtual void mark_used() = 0; - virtual ~Semi_join_strategy_picker() {} + virtual ~Semi_join_strategy_picker() = default; }; @@ -1918,7 +1918,7 @@ public: null_ptr(arg.null_ptr), err(arg.err) {} - virtual ~store_key() {} /** Not actually needed */ + virtual ~store_key() = default; /** Not actually needed */ virtual enum Type type() const=0; virtual const char *name() const=0; virtual bool store_key_is_const() { return false; } diff --git a/sql/sql_show.cc b/sql/sql_show.cc index f780ed9c23a..9fee8ce5a6c 100644 --- a/sql/sql_show.cc +++ b/sql/sql_show.cc @@ -10529,11 +10529,9 @@ exit: class IS_internal_schema_access : public ACL_internal_schema_access { public: - IS_internal_schema_access() - {} + IS_internal_schema_access() = default; - ~IS_internal_schema_access() - {} + ~IS_internal_schema_access() = default; ACL_internal_access_result check(ulong want_access, ulong *save_priv) const; diff --git a/sql/sql_signal.h b/sql/sql_signal.h index bf42cdb5f07..9ba4c451580 100644 --- a/sql/sql_signal.h +++ b/sql/sql_signal.h @@ -36,8 +36,7 @@ protected: m_set_signal_information(set) {} - virtual ~Sql_cmd_common_signal() - {} + virtual ~Sql_cmd_common_signal() = default; /** Evaluate each signal condition items for this statement. @@ -84,8 +83,7 @@ public: : Sql_cmd_common_signal(cond, set) {} - virtual ~Sql_cmd_signal() - {} + virtual ~Sql_cmd_signal() = default; virtual enum_sql_command sql_command_code() const { @@ -111,8 +109,7 @@ public: : Sql_cmd_common_signal(cond, set) {} - virtual ~Sql_cmd_resignal() - {} + virtual ~Sql_cmd_resignal() = default; virtual enum_sql_command sql_command_code() const { diff --git a/sql/sql_statistics.cc b/sql/sql_statistics.cc index e3b461167bb..c7f6d2ff489 100644 --- a/sql/sql_statistics.cc +++ b/sql/sql_statistics.cc @@ -513,7 +513,7 @@ public: } - virtual ~Stat_table() {} + virtual ~Stat_table() = default; /** @brief @@ -1633,7 +1633,7 @@ protected: public: - Count_distinct_field() {} + Count_distinct_field() = default; /** @param diff --git a/sql/sql_string.h b/sql/sql_string.h index 8020e3cf7b5..33efd783d73 100644 --- a/sql/sql_string.h +++ b/sql/sql_string.h @@ -739,7 +739,7 @@ public: class String: public Charset, public Binary_string { public: - String() { } + String() = default; String(size_t length_arg) :Binary_string(length_arg) { } @@ -760,10 +760,7 @@ public: :Charset(cs), Binary_string(str, len) { } - String(const String &str) - :Charset(str), - Binary_string(str) - { } + String(const String &str) = default; void set(String &str,size_t offset,size_t arg_length) { diff --git a/sql/sql_truncate.h b/sql/sql_truncate.h index 7d2ff4b6050..5704da1dd7b 100644 --- a/sql/sql_truncate.h +++ b/sql/sql_truncate.h @@ -31,11 +31,9 @@ public: /** Constructor, used to represent a TRUNCATE statement. */ - Sql_cmd_truncate_table() - {} + Sql_cmd_truncate_table() = default; - virtual ~Sql_cmd_truncate_table() - {} + virtual ~Sql_cmd_truncate_table() = default; /** Execute a TRUNCATE statement at runtime. diff --git a/sql/sql_type.h b/sql/sql_type.h index 73e7de79cd8..1e44be37d52 100644 --- a/sql/sql_type.h +++ b/sql/sql_type.h @@ -252,7 +252,7 @@ class Dec_ptr { protected: my_decimal *m_ptr; - Dec_ptr() { } + Dec_ptr() = default; public: Dec_ptr(my_decimal *ptr) :m_ptr(ptr) { } bool is_null() const { return m_ptr == NULL; } @@ -395,7 +395,7 @@ protected: { m_sec= m_usec= m_neg= m_truncated= 0; } - Sec6() { } + Sec6() = default; bool add_nanoseconds(uint nanoseconds) { DBUG_ASSERT(nanoseconds <= 1000000000); @@ -555,7 +555,7 @@ protected: Sec6::make_from_int(nr); m_nsec= 0; } - Sec9() { } + Sec9() = default; public: Sec9(const my_decimal *d) { @@ -2707,7 +2707,7 @@ class Timestamp_or_zero_datetime_native: public NativeBuffer { public: - Timestamp_or_zero_datetime_native() { } + Timestamp_or_zero_datetime_native() = default; Timestamp_or_zero_datetime_native(const Timestamp_or_zero_datetime &ts, uint decimals) { @@ -3168,7 +3168,7 @@ public: Type_all_attributes(const Type_all_attributes *other) :Type_std_attributes(other) { } - virtual ~Type_all_attributes() {} + virtual ~Type_all_attributes() = default; virtual void set_maybe_null(bool maybe_null_arg)= 0; // Returns total number of decimal digits virtual uint decimal_precision() const= 0; @@ -3188,7 +3188,7 @@ public: class Type_cmp_attributes { public: - virtual ~Type_cmp_attributes() { } + virtual ~Type_cmp_attributes() = default; virtual CHARSET_INFO *compare_collation() const= 0; }; @@ -3579,7 +3579,7 @@ public: { return false; } - virtual ~Type_handler() {} + virtual ~Type_handler() = default; /** Determines MariaDB traditional data types that always present in the server. @@ -4025,7 +4025,7 @@ class Type_handler_row: public Type_handler { static const Name m_name_row; public: - virtual ~Type_handler_row() {} + virtual ~Type_handler_row() = default; const Name name() const override { return m_name_row; } bool is_scalar_type() const override { return false; } bool can_return_int() const override { return false; } @@ -4401,7 +4401,7 @@ public: bool Item_func_min_max_get_date(THD *thd, Item_func_min_max*, MYSQL_TIME *, date_mode_t fuzzydate) const override; - virtual ~Type_handler_numeric() { } + virtual ~Type_handler_numeric() = default; bool can_change_cond_ref_to_const(Item_bool_func2 *target, Item *target_expr, Item *target_value, Item_bool_func2 *source, @@ -4421,7 +4421,7 @@ class Type_handler_real_result: public Type_handler_numeric public: Item_result result_type() const { return REAL_RESULT; } Item_result cmp_type() const { return REAL_RESULT; } - virtual ~Type_handler_real_result() {} + virtual ~Type_handler_real_result() = default; const Type_handler *type_handler_for_comparison() const; void Column_definition_reuse_fix_attributes(THD *thd, Column_definition *c, @@ -4507,7 +4507,7 @@ public: } Item_result result_type() const { return DECIMAL_RESULT; } Item_result cmp_type() const { return DECIMAL_RESULT; } - virtual ~Type_handler_decimal_result() {}; + virtual ~Type_handler_decimal_result() = default; const Type_handler *type_handler_for_comparison() const; int stored_field_cmp_to_item(THD *thd, Field *field, Item *item) const { @@ -4737,7 +4737,7 @@ public: Item_result cmp_type() const { return INT_RESULT; } bool is_order_clause_position_type() const { return true; } bool is_limit_clause_valid_type() const { return true; } - virtual ~Type_handler_int_result() {} + virtual ~Type_handler_int_result() = default; const Type_handler *type_handler_for_comparison() const; int stored_field_cmp_to_item(THD *thd, Field *field, Item *item) const; bool subquery_type_allows_materialization(const Item *inner, @@ -4832,7 +4832,7 @@ protected: public: Item_result result_type() const { return STRING_RESULT; } Item_result cmp_type() const { return TIME_RESULT; } - virtual ~Type_handler_temporal_result() {} + virtual ~Type_handler_temporal_result() = default; void make_sort_key(uchar *to, Item *item, const SORT_FIELD_ATTR *sort_field, Sort_param *param) const; void sortlength(THD *thd, @@ -4914,7 +4914,7 @@ public: Item_result result_type() const { return STRING_RESULT; } Item_result cmp_type() const { return STRING_RESULT; } CHARSET_INFO *charset_for_protocol(const Item *item) const; - virtual ~Type_handler_string_result() {} + virtual ~Type_handler_string_result() = default; const Type_handler *type_handler_for_comparison() const; int stored_field_cmp_to_item(THD *thd, Field *field, Item *item) const; const Type_handler * @@ -5084,7 +5084,7 @@ class Type_handler_tiny: public Type_handler_general_purpose_int static const Type_limits_int m_limits_sint8; static const Type_limits_int m_limits_uint8; public: - virtual ~Type_handler_tiny() {} + virtual ~Type_handler_tiny() = default; const Name name() const { return m_name_tiny; } enum_field_types field_type() const { return MYSQL_TYPE_TINY; } protocol_send_type_t protocol_send_type() const @@ -5129,7 +5129,7 @@ class Type_handler_short: public Type_handler_general_purpose_int static const Type_limits_int m_limits_sint16; static const Type_limits_int m_limits_uint16; public: - virtual ~Type_handler_short() {} + virtual ~Type_handler_short() = default; const Name name() const { return m_name_short; } enum_field_types field_type() const { return MYSQL_TYPE_SHORT; } protocol_send_type_t protocol_send_type() const @@ -5174,7 +5174,7 @@ class Type_handler_long: public Type_handler_general_purpose_int static const Type_limits_int m_limits_sint32; static const Type_limits_int m_limits_uint32; public: - virtual ~Type_handler_long() {} + virtual ~Type_handler_long() = default; const Name name() const { return m_name_int; } enum_field_types field_type() const { return MYSQL_TYPE_LONG; } protocol_send_type_t protocol_send_type() const @@ -5230,7 +5230,7 @@ class Type_handler_longlong: public Type_handler_general_purpose_int static const Type_limits_int m_limits_sint64; static const Type_limits_int m_limits_uint64; public: - virtual ~Type_handler_longlong() {} + virtual ~Type_handler_longlong() = default; const Name name() const { return m_name_longlong; } enum_field_types field_type() const { return MYSQL_TYPE_LONGLONG; } protocol_send_type_t protocol_send_type() const @@ -5276,7 +5276,7 @@ public: class Type_handler_vers_trx_id: public Type_handler_longlong { public: - virtual ~Type_handler_vers_trx_id() {} + virtual ~Type_handler_vers_trx_id() = default; Field *make_table_field(const LEX_CSTRING *name, const Record_addr &addr, const Type_all_attributes &attr, @@ -5290,7 +5290,7 @@ class Type_handler_int24: public Type_handler_general_purpose_int static const Type_limits_int m_limits_sint24; static const Type_limits_int m_limits_uint24; public: - virtual ~Type_handler_int24() {} + virtual ~Type_handler_int24() = default; const Name name() const { return m_name_mediumint; } enum_field_types field_type() const { return MYSQL_TYPE_INT24; } protocol_send_type_t protocol_send_type() const @@ -5331,7 +5331,7 @@ class Type_handler_year: public Type_handler_int_result { static const Name m_name_year; public: - virtual ~Type_handler_year() {} + virtual ~Type_handler_year() = default; const Name name() const { return m_name_year; } enum_field_types field_type() const { return MYSQL_TYPE_YEAR; } protocol_send_type_t protocol_send_type() const @@ -5383,7 +5383,7 @@ class Type_handler_bit: public Type_handler_int_result { static const Name m_name_bit; public: - virtual ~Type_handler_bit() {} + virtual ~Type_handler_bit() = default; const Name name() const { return m_name_bit; } enum_field_types field_type() const { return MYSQL_TYPE_BIT; } protocol_send_type_t protocol_send_type() const @@ -5441,7 +5441,7 @@ class Type_handler_float: public Type_handler_real_result { static const Name m_name_float; public: - virtual ~Type_handler_float() {} + virtual ~Type_handler_float() = default; const Name name() const { return m_name_float; } enum_field_types field_type() const { return MYSQL_TYPE_FLOAT; } protocol_send_type_t protocol_send_type() const @@ -5491,7 +5491,7 @@ class Type_handler_double: public Type_handler_real_result { static const Name m_name_double; public: - virtual ~Type_handler_double() {} + virtual ~Type_handler_double() = default; const Name name() const { return m_name_double; } enum_field_types field_type() const { return MYSQL_TYPE_DOUBLE; } protocol_send_type_t protocol_send_type() const @@ -5540,7 +5540,7 @@ class Type_handler_time_common: public Type_handler_temporal_result { static const Name m_name_time; public: - virtual ~Type_handler_time_common() { } + virtual ~Type_handler_time_common() = default; const Name name() const { return m_name_time; } enum_field_types field_type() const { return MYSQL_TYPE_TIME; } protocol_send_type_t protocol_send_type() const @@ -5630,7 +5630,7 @@ class Type_handler_time: public Type_handler_time_common static uint m_hires_bytes[MAX_DATETIME_PRECISION+1]; public: static uint hires_bytes(uint dec) { return m_hires_bytes[dec]; } - virtual ~Type_handler_time() {} + virtual ~Type_handler_time() = default; const Name version() const { return m_version_mariadb53; } uint32 calc_pack_length(uint32 length) const; Field *make_conversion_table_field(TABLE *, uint metadata, @@ -5656,7 +5656,7 @@ public: class Type_handler_time2: public Type_handler_time_common { public: - virtual ~Type_handler_time2() {} + virtual ~Type_handler_time2() = default; const Name version() const { return m_version_mysql56; } enum_field_types real_field_type() const { return MYSQL_TYPE_TIME2; } uint32 calc_pack_length(uint32 length) const; @@ -5683,7 +5683,7 @@ public: class Type_handler_temporal_with_date: public Type_handler_temporal_result { public: - virtual ~Type_handler_temporal_with_date() {} + virtual ~Type_handler_temporal_with_date() = default; Item_literal *create_literal_item(THD *thd, const char *str, size_t length, CHARSET_INFO *cs, bool send_error) const; bool Item_eq_value(THD *thd, const Type_cmp_attributes *attr, @@ -5708,7 +5708,7 @@ class Type_handler_date_common: public Type_handler_temporal_with_date { static const Name m_name_date; public: - virtual ~Type_handler_date_common() {} + virtual ~Type_handler_date_common() = default; const Name name() const { return m_name_date; } const Type_handler *type_handler_for_comparison() const; enum_field_types field_type() const { return MYSQL_TYPE_DATE; } @@ -5753,7 +5753,7 @@ public: class Type_handler_date: public Type_handler_date_common { public: - virtual ~Type_handler_date() {} + virtual ~Type_handler_date() = default; uint32 calc_pack_length(uint32 length) const { return 4; } Field *make_conversion_table_field(TABLE *, uint metadata, const Field *target) const; @@ -5778,7 +5778,7 @@ public: class Type_handler_newdate: public Type_handler_date_common { public: - virtual ~Type_handler_newdate() {} + virtual ~Type_handler_newdate() = default; enum_field_types real_field_type() const { return MYSQL_TYPE_NEWDATE; } uint32 calc_pack_length(uint32 length) const { return 3; } Field *make_conversion_table_field(TABLE *, uint metadata, @@ -5805,7 +5805,7 @@ class Type_handler_datetime_common: public Type_handler_temporal_with_date { static const Name m_name_datetime; public: - virtual ~Type_handler_datetime_common() {} + virtual ~Type_handler_datetime_common() = default; const Name name() const { return m_name_datetime; } const Type_handler *type_handler_for_comparison() const; enum_field_types field_type() const { return MYSQL_TYPE_DATETIME; } @@ -5863,7 +5863,7 @@ class Type_handler_datetime: public Type_handler_datetime_common static uint m_hires_bytes[MAX_DATETIME_PRECISION + 1]; public: static uint hires_bytes(uint dec) { return m_hires_bytes[dec]; } - virtual ~Type_handler_datetime() {} + virtual ~Type_handler_datetime() = default; const Name version() const { return m_version_mariadb53; } uint32 calc_pack_length(uint32 length) const; Field *make_conversion_table_field(TABLE *, uint metadata, @@ -5889,7 +5889,7 @@ public: class Type_handler_datetime2: public Type_handler_datetime_common { public: - virtual ~Type_handler_datetime2() {} + virtual ~Type_handler_datetime2() = default; const Name version() const { return m_version_mysql56; } enum_field_types real_field_type() const { return MYSQL_TYPE_DATETIME2; } uint32 calc_pack_length(uint32 length) const; @@ -5919,7 +5919,7 @@ class Type_handler_timestamp_common: public Type_handler_temporal_with_date protected: bool TIME_to_native(THD *, const MYSQL_TIME *from, Native *to, uint dec) const; public: - virtual ~Type_handler_timestamp_common() {} + virtual ~Type_handler_timestamp_common() = default; const Name name() const { return m_name_timestamp; } const Type_handler *type_handler_for_comparison() const; const Type_handler *type_handler_for_native_format() const; @@ -5999,7 +5999,7 @@ class Type_handler_timestamp: public Type_handler_timestamp_common static uint m_sec_part_bytes[MAX_DATETIME_PRECISION + 1]; public: static uint sec_part_bytes(uint dec) { return m_sec_part_bytes[dec]; } - virtual ~Type_handler_timestamp() {} + virtual ~Type_handler_timestamp() = default; const Name version() const { return m_version_mariadb53; } uint32 calc_pack_length(uint32 length) const; Field *make_conversion_table_field(TABLE *, uint metadata, @@ -6025,7 +6025,7 @@ public: class Type_handler_timestamp2: public Type_handler_timestamp_common { public: - virtual ~Type_handler_timestamp2() {} + virtual ~Type_handler_timestamp2() = default; const Name version() const { return m_version_mysql56; } enum_field_types real_field_type() const { return MYSQL_TYPE_TIMESTAMP2; } uint32 calc_pack_length(uint32 length) const; @@ -6055,7 +6055,7 @@ class Type_handler_olddecimal: public Type_handler_decimal_result { static const Name m_name_decimal; public: - virtual ~Type_handler_olddecimal() {} + virtual ~Type_handler_olddecimal() = default; const Name name() const { return m_name_decimal; } enum_field_types field_type() const { return MYSQL_TYPE_DECIMAL; } uint32 calc_pack_length(uint32 length) const { return length; } @@ -6086,7 +6086,7 @@ class Type_handler_newdecimal: public Type_handler_decimal_result { static const Name m_name_decimal; public: - virtual ~Type_handler_newdecimal() {} + virtual ~Type_handler_newdecimal() = default; const Name name() const { return m_name_decimal; } enum_field_types field_type() const { return MYSQL_TYPE_NEWDECIMAL; } uint32 calc_pack_length(uint32 length) const; @@ -6126,7 +6126,7 @@ class Type_handler_null: public Type_handler_general_purpose_string { static const Name m_name_null; public: - virtual ~Type_handler_null() {} + virtual ~Type_handler_null() = default; const Name name() const { return m_name_null; } enum_field_types field_type() const { return MYSQL_TYPE_NULL; } const Type_handler *type_handler_for_comparison() const; @@ -6186,7 +6186,7 @@ class Type_handler_string: public Type_handler_longstr { static const Name m_name_char; public: - virtual ~Type_handler_string() {} + virtual ~Type_handler_string() = default; const Name name() const override { return m_name_char; } enum_field_types field_type() const override { return MYSQL_TYPE_STRING; } ulong KEY_pack_flags(uint column_nr) const override @@ -6225,7 +6225,7 @@ class Type_handler_var_string: public Type_handler_string { static const Name m_name_var_string; public: - virtual ~Type_handler_var_string() {} + virtual ~Type_handler_var_string() = default; const Name name() const { return m_name_var_string; } enum_field_types field_type() const { return MYSQL_TYPE_VAR_STRING; } enum_field_types real_field_type() const { return MYSQL_TYPE_STRING; } @@ -6254,7 +6254,7 @@ class Type_handler_varchar: public Type_handler_longstr { static const Name m_name_varchar; public: - virtual ~Type_handler_varchar() {} + virtual ~Type_handler_varchar() = default; const Name name() const override { return m_name_varchar; } enum_field_types field_type() const override { return MYSQL_TYPE_VARCHAR; } ulong KEY_pack_flags(uint column_nr) const override @@ -6310,7 +6310,7 @@ class Type_handler_hex_hybrid: public Type_handler_varchar { static const Name m_name_hex_hybrid; public: - virtual ~Type_handler_hex_hybrid() {} + virtual ~Type_handler_hex_hybrid() = default; const Name name() const override { return m_name_hex_hybrid; } const Type_handler *cast_to_int_type_handler() const override; const Type_handler *type_handler_for_system_time() const override; @@ -6336,7 +6336,7 @@ public: class Type_handler_blob_common: public Type_handler_longstr { public: - virtual ~Type_handler_blob_common() { } + virtual ~Type_handler_blob_common() = default; Field *make_conversion_table_field(TABLE *, uint metadata, const Field *target) const override; ulong KEY_pack_flags(uint column_nr) const override @@ -6390,7 +6390,7 @@ class Type_handler_tiny_blob: public Type_handler_blob_common { static const Name m_name_tinyblob; public: - virtual ~Type_handler_tiny_blob() {} + virtual ~Type_handler_tiny_blob() = default; const Name name() const override { return m_name_tinyblob; } enum_field_types field_type() const override { return MYSQL_TYPE_TINY_BLOB; } uint32 calc_pack_length(uint32 length) const override; @@ -6406,7 +6406,7 @@ class Type_handler_medium_blob: public Type_handler_blob_common { static const Name m_name_mediumblob; public: - virtual ~Type_handler_medium_blob() {} + virtual ~Type_handler_medium_blob() = default; const Name name() const override { return m_name_mediumblob; } enum_field_types field_type() const override { return MYSQL_TYPE_MEDIUM_BLOB; } @@ -6423,7 +6423,7 @@ class Type_handler_long_blob: public Type_handler_blob_common { static const Name m_name_longblob; public: - virtual ~Type_handler_long_blob() {} + virtual ~Type_handler_long_blob() = default; const Name name() const { return m_name_longblob; } enum_field_types field_type() const { return MYSQL_TYPE_LONG_BLOB; } uint32 calc_pack_length(uint32 length) const; @@ -6441,7 +6441,7 @@ class Type_handler_blob: public Type_handler_blob_common { static const Name m_name_blob; public: - virtual ~Type_handler_blob() {} + virtual ~Type_handler_blob() = default; const Name name() const { return m_name_blob; } enum_field_types field_type() const { return MYSQL_TYPE_BLOB; } uint32 calc_pack_length(uint32 length) const; @@ -6471,7 +6471,7 @@ class Type_handler_geometry: public Type_handler_string_result { static const Name m_name_geometry; public: - virtual ~Type_handler_geometry() {} + virtual ~Type_handler_geometry() = default; const Name name() const { return m_name_geometry; } enum_field_types field_type() const { return MYSQL_TYPE_GEOMETRY; } bool is_param_long_data_type() const { return true; } @@ -6572,7 +6572,7 @@ extern MYSQL_PLUGIN_IMPORT Type_handler_geometry type_handler_geometry; class Type_handler_typelib: public Type_handler_general_purpose_string { public: - virtual ~Type_handler_typelib() { } + virtual ~Type_handler_typelib() = default; enum_field_types field_type() const { return MYSQL_TYPE_STRING; } const Type_handler *type_handler_for_item_field() const; const Type_handler *cast_to_int_type_handler() const; @@ -6608,7 +6608,7 @@ class Type_handler_enum: public Type_handler_typelib { static const Name m_name_enum; public: - virtual ~Type_handler_enum() {} + virtual ~Type_handler_enum() = default; const Name name() const { return m_name_enum; } enum_field_types real_field_type() const { return MYSQL_TYPE_ENUM; } enum_field_types traditional_merge_field_type() const @@ -6640,7 +6640,7 @@ class Type_handler_set: public Type_handler_typelib { static const Name m_name_set; public: - virtual ~Type_handler_set() {} + virtual ~Type_handler_set() = default; const Name name() const { return m_name_set; } enum_field_types real_field_type() const { return MYSQL_TYPE_SET; } enum_field_types traditional_merge_field_type() const @@ -6813,7 +6813,7 @@ class Type_aggregator const Type_handler *m_handler1; const Type_handler *m_handler2; const Type_handler *m_result; - Pair() { } + Pair() = default; Pair(const Type_handler *handler1, const Type_handler *handler2, const Type_handler *result) diff --git a/sql/sql_type_json.h b/sql/sql_type_json.h index 6c4ee8cb2eb..c5d84907616 100644 --- a/sql/sql_type_json.h +++ b/sql/sql_type_json.h @@ -27,7 +27,7 @@ class Type_handler_json_longtext: public Type_handler_long_blob const LEX_CSTRING *field_name) const; public: - virtual ~Type_handler_json_longtext() {} + virtual ~Type_handler_json_longtext() = default; bool Column_definition_validate_check_constraint(THD *thd, Column_definition *c) const; }; diff --git a/sql/sql_window.cc b/sql/sql_window.cc index bf36b592d96..ff7554b0cd7 100644 --- a/sql/sql_window.cc +++ b/sql/sql_window.cc @@ -948,7 +948,7 @@ protected: class Table_read_cursor : public Rowid_seq_cursor { public: - virtual ~Table_read_cursor() {} + virtual ~Table_read_cursor() = default; void init(READ_RECORD *info) { @@ -1132,7 +1132,7 @@ public: virtual bool is_outside_computation_bounds() const { return false; }; - virtual ~Frame_cursor() {} + virtual ~Frame_cursor() = default; /* Regular frame cursors add or remove values from the sum functions they diff --git a/sql/sql_window.h b/sql/sql_window.h index 66ea8c7dd4d..1c02740e769 100644 --- a/sql/sql_window.h +++ b/sql/sql_window.h @@ -106,7 +106,7 @@ class Window_spec : public Sql_alloc { bool window_names_are_checked; public: - virtual ~Window_spec() {} + virtual ~Window_spec() = default; LEX_CSTRING *window_ref; diff --git a/sql/structs.h b/sql/structs.h index bd5013d221c..31601fee154 100644 --- a/sql/structs.h +++ b/sql/structs.h @@ -852,7 +852,7 @@ public: class Load_data_outvar { public: - virtual ~Load_data_outvar() {} + virtual ~Load_data_outvar() = default; virtual bool load_data_set_null(THD *thd, const Load_data_param *param)= 0; virtual bool load_data_set_value(THD *thd, const char *pos, uint length, const Load_data_param *param)= 0; @@ -866,7 +866,7 @@ public: class Timeval: public timeval { protected: - Timeval() { } + Timeval() = default; public: Timeval(my_time_t sec, ulong usec) { diff --git a/sql/sys_vars_shared.h b/sql/sys_vars_shared.h index bc48d1f7fff..508a0a70c8f 100644 --- a/sql/sys_vars_shared.h +++ b/sql/sys_vars_shared.h @@ -44,7 +44,7 @@ public: virtual void rdlock()= 0; virtual void wrlock()= 0; virtual void unlock()= 0; - virtual ~PolyLock() {} + virtual ~PolyLock() = default; }; class PolyLock_mutex: public PolyLock diff --git a/sql/table.cc b/sql/table.cc index 2b5787d1511..141b2e48880 100644 --- a/sql/table.cc +++ b/sql/table.cc @@ -8463,7 +8463,7 @@ bool is_simple_order(ORDER *order) class Turn_errors_to_warnings_handler : public Internal_error_handler { public: - Turn_errors_to_warnings_handler() {} + Turn_errors_to_warnings_handler() = default; bool handle_condition(THD *thd, uint sql_errno, const char* sqlstate, diff --git a/sql/table.h b/sql/table.h index 799675ac775..3adcc887a2c 100644 --- a/sql/table.h +++ b/sql/table.h @@ -132,14 +132,13 @@ public: void restore_env(THD *thd, Object_creation_ctx *backup_ctx); protected: - Object_creation_ctx() {} + Object_creation_ctx() = default; virtual Object_creation_ctx *create_backup_ctx(THD *thd) const = 0; virtual void change_env(THD *thd) const = 0; public: - virtual ~Object_creation_ctx() - { } + virtual ~Object_creation_ctx() = default; }; /*************************************************************************/ @@ -540,7 +539,7 @@ protected: public: Table_check_intact(bool keys= false) : has_keys(keys) {} - virtual ~Table_check_intact() {} + virtual ~Table_check_intact() = default; /** Checks whether a table is intact. */ bool check(TABLE *table, const TABLE_FIELD_DEF *table_def); @@ -712,7 +711,7 @@ public: struct TABLE_SHARE { - TABLE_SHARE() {} /* Remove gcc warning */ + TABLE_SHARE() = default; /* Remove gcc warning */ /** Category of this table. */ TABLE_CATEGORY table_category; @@ -1229,7 +1228,7 @@ struct vers_select_conds_t; struct TABLE { - TABLE() {} /* Remove gcc warning */ + TABLE() = default; /* Remove gcc warning */ TABLE_SHARE *s; handler *file; @@ -2191,7 +2190,7 @@ class Index_hint; struct TABLE_CHAIN { - TABLE_CHAIN() {} + TABLE_CHAIN() = default; TABLE_LIST **start_pos; TABLE_LIST ** end_pos; @@ -2202,7 +2201,7 @@ struct TABLE_CHAIN struct TABLE_LIST { - TABLE_LIST() {} /* Remove gcc warning */ + TABLE_LIST() = default; /* Remove gcc warning */ enum prelocking_types { @@ -2981,8 +2980,8 @@ class Item; class Field_iterator: public Sql_alloc { public: - Field_iterator() {} /* Remove gcc warning */ - virtual ~Field_iterator() {} + Field_iterator() = default; /* Remove gcc warning */ + virtual ~Field_iterator() = default; virtual void set(TABLE_LIST *)= 0; virtual void next()= 0; virtual bool end_of_fields()= 0; /* Return 1 at end of list */ @@ -3043,7 +3042,7 @@ class Field_iterator_natural_join: public Field_iterator Natural_join_column *cur_column_ref; public: Field_iterator_natural_join() :cur_column_ref(NULL) {} - ~Field_iterator_natural_join() {} + ~Field_iterator_natural_join() = default; void set(TABLE_LIST *table); void next(); bool end_of_fields() { return !cur_column_ref; } diff --git a/sql/threadpool.h b/sql/threadpool.h index 817681e174f..ea6c93b4a65 100644 --- a/sql/threadpool.h +++ b/sql/threadpool.h @@ -102,8 +102,7 @@ struct TP_connection priority(TP_PRIORITY_HIGH) {} - virtual ~TP_connection() - {}; + virtual ~TP_connection() = default; /* Initialize io structures windows threadpool, epoll etc */ virtual int init() = 0; @@ -121,7 +120,7 @@ struct TP_connection struct TP_pool { - virtual ~TP_pool(){}; + virtual ~TP_pool() = default; virtual int init()= 0; virtual TP_connection *new_connection(CONNECT *)= 0; virtual void add(TP_connection *c)= 0; diff --git a/sql/threadpool_generic.cc b/sql/threadpool_generic.cc index c129f518674..58d734aa7af 100644 --- a/sql/threadpool_generic.cc +++ b/sql/threadpool_generic.cc @@ -1628,8 +1628,7 @@ static void *worker_main(void *param) } -TP_pool_generic::TP_pool_generic() -{} +TP_pool_generic::TP_pool_generic() = default; int TP_pool_generic::init() { diff --git a/sql/tztime.cc b/sql/tztime.cc index 3db97ad97d6..a40581ca33c 100644 --- a/sql/tztime.cc +++ b/sql/tztime.cc @@ -1027,7 +1027,7 @@ static const String tz_SYSTEM_name("SYSTEM", 6, &my_charset_latin1); class Time_zone_system : public Time_zone { public: - Time_zone_system() {} /* Remove gcc warning */ + Time_zone_system() = default; /* Remove gcc warning */ virtual my_time_t TIME_to_gmt_sec(const MYSQL_TIME *t, uint *error_code) const; virtual void gmt_sec_to_TIME(MYSQL_TIME *tmp, my_time_t t) const; virtual const String * get_name() const; @@ -1123,7 +1123,7 @@ Time_zone_system::get_name() const class Time_zone_utc : public Time_zone { public: - Time_zone_utc() {} /* Remove gcc warning */ + Time_zone_utc() = default; /* Remove gcc warning */ virtual my_time_t TIME_to_gmt_sec(const MYSQL_TIME *t, uint *error_code) const; virtual void gmt_sec_to_TIME(MYSQL_TIME *tmp, my_time_t t) const; diff --git a/sql/tztime.h b/sql/tztime.h index d24a379e634..4ccee11ad9b 100644 --- a/sql/tztime.h +++ b/sql/tztime.h @@ -41,7 +41,7 @@ class THD; class Time_zone: public Sql_alloc { public: - Time_zone() {} /* Remove gcc warning */ + Time_zone() = default; /* Remove gcc warning */ /** Converts local time in broken down MYSQL_TIME representation to my_time_t (UTC seconds since Epoch) represenation. @@ -66,7 +66,7 @@ public: We need this only for surpressing warnings, objects of this type are allocated on MEM_ROOT and should not require destruction. */ - virtual ~Time_zone() {}; + virtual ~Time_zone() = default; protected: static inline void adjust_leap_second(MYSQL_TIME *t); diff --git a/sql/vers_string.h b/sql/vers_string.h index cfadc890dcd..13b6ee0a3a7 100644 --- a/sql/vers_string.h +++ b/sql/vers_string.h @@ -77,7 +77,7 @@ template struct Lex_cstring_with_compare : public Lex_cstring { public: - Lex_cstring_with_compare() {} + Lex_cstring_with_compare() = default; Lex_cstring_with_compare(const char *_str, size_t _len) : Lex_cstring(_str, _len) { } diff --git a/sql/wsrep_condition_variable.h b/sql/wsrep_condition_variable.h index c97b47378f7..d9798bb9548 100644 --- a/sql/wsrep_condition_variable.h +++ b/sql/wsrep_condition_variable.h @@ -29,8 +29,7 @@ public: Wsrep_condition_variable(mysql_cond_t* cond) : m_cond(cond) { } - ~Wsrep_condition_variable() - { } + ~Wsrep_condition_variable() = default; void notify_one() { diff --git a/sql/wsrep_schema.cc b/sql/wsrep_schema.cc index 7a49aef43b3..40cdd6496b2 100644 --- a/sql/wsrep_schema.cc +++ b/sql/wsrep_schema.cc @@ -629,12 +629,9 @@ static void make_key(TABLE* table, uchar** key, key_part_map* map, int parts) { } /* namespace Wsrep_schema_impl */ -Wsrep_schema::Wsrep_schema() -{ -} +Wsrep_schema::Wsrep_schema() = default; -Wsrep_schema::~Wsrep_schema() -{ } +Wsrep_schema::~Wsrep_schema() = default; static void wsrep_init_thd_for_schema(THD *thd) { diff --git a/sql/wsrep_server_state.cc b/sql/wsrep_server_state.cc index 973850871b1..6bc4eaf4d86 100644 --- a/sql/wsrep_server_state.cc +++ b/sql/wsrep_server_state.cc @@ -48,8 +48,7 @@ Wsrep_server_state::Wsrep_server_state(const std::string& name, , m_service(*this) { } -Wsrep_server_state::~Wsrep_server_state() -{ } +Wsrep_server_state::~Wsrep_server_state() = default; void Wsrep_server_state::init_once(const std::string& name, const std::string& incoming_address, diff --git a/storage/archive/ha_archive.h b/storage/archive/ha_archive.h index 35291e469cd..358280815a6 100644 --- a/storage/archive/ha_archive.h +++ b/storage/archive/ha_archive.h @@ -87,9 +87,7 @@ class ha_archive: public handler public: ha_archive(handlerton *hton, TABLE_SHARE *table_arg); - ~ha_archive() - { - } + ~ha_archive() = default; const char *index_type(uint inx) { return "NONE"; } ulonglong table_flags() const { diff --git a/storage/blackhole/ha_blackhole.h b/storage/blackhole/ha_blackhole.h index e827cd25bfc..10316d482c1 100644 --- a/storage/blackhole/ha_blackhole.h +++ b/storage/blackhole/ha_blackhole.h @@ -44,9 +44,7 @@ class ha_blackhole: public handler public: ha_blackhole(handlerton *hton, TABLE_SHARE *table_arg); - ~ha_blackhole() - { - } + ~ha_blackhole() = default; /* The name of the index type that will be used for display don't implement this method unless you really have indexes diff --git a/storage/connect/blkfil.h b/storage/connect/blkfil.h index 61b02c53c14..27e6fd4b166 100644 --- a/storage/connect/blkfil.h +++ b/storage/connect/blkfil.h @@ -31,7 +31,7 @@ class DllExport BLOCKFILTER : public BLOCK { /* Block Filter */ virtual void Prints(PGLOBAL g, char *ps, uint z); protected: - BLOCKFILTER(void) {} // Standard constructor not to be used + BLOCKFILTER(void) = default; // Standard constructor not to be used // Members PTDBDOS Tdbp; // Owner TDB @@ -54,7 +54,7 @@ class DllExport BLKFILLOG : public BLOCKFILTER { /* Logical Op Block Filter */ virtual int BlockEval(PGLOBAL g); protected: - BLKFILLOG(void) {} // Standard constructor not to be used + BLKFILLOG(void) = default; // Standard constructor not to be used // Members PBF *Fil; // Points to Block filter args @@ -75,7 +75,7 @@ class DllExport BLKFILARI : public BLOCKFILTER { /* Arithm. Op Block Filter */ virtual void MakeValueBitmap(void) {} protected: - BLKFILARI(void) {} // Standard constructor not to be used + BLKFILARI(void) = default; // Standard constructor not to be used // Members PDOSCOL Colp; // Points to column argument @@ -97,7 +97,7 @@ class DllExport BLKFILAR2 : public BLKFILARI { /* Arithm. Op Block Filter */ virtual void MakeValueBitmap(void); protected: - BLKFILAR2(void) {} // Standard constructor not to be used + BLKFILAR2(void) = default; // Standard constructor not to be used // Members uint Bmp; // The value bitmap used to test blocks @@ -118,7 +118,7 @@ class DllExport BLKFILMR2 : public BLKFILARI { /* Arithm. Op Block Filter */ virtual void MakeValueBitmap(void); protected: - BLKFILMR2(void) {} // Standard constructor not to be used + BLKFILMR2(void) = default; // Standard constructor not to be used // Members int Nbm; // The number of ULONG bitmaps @@ -141,7 +141,7 @@ class DllExport BLKSPCARI : public BLOCKFILTER { /* Arithm. Op Block Filter */ virtual int BlockEval(PGLOBAL g); protected: - BLKSPCARI(void) {} // Standard constructor not to be used + BLKSPCARI(void) = default; // Standard constructor not to be used // Members PCOL Cpx; // Point to subquery "constant" column diff --git a/storage/connect/block.h b/storage/connect/block.h index e8871277d48..5351c2e6354 100644 --- a/storage/connect/block.h +++ b/storage/connect/block.h @@ -55,7 +55,7 @@ class DllExport BLOCK { void operator delete(void*, long long) {} void operator delete(void*) {} - virtual ~BLOCK() {} + virtual ~BLOCK() = default; }; // end of class BLOCK #endif // !BLOCK_DEFINED diff --git a/storage/connect/bson.h b/storage/connect/bson.h index acc36e8e0ed..e3a15a41952 100644 --- a/storage/connect/bson.h +++ b/storage/connect/bson.h @@ -165,7 +165,7 @@ public: protected: // Default constructor not to be used - BJSON(void) {} + BJSON(void) = default; }; // end of class BJSON /***********************************************************************/ @@ -203,5 +203,5 @@ protected: bool comma; // True if Pretty = 1 // Default constructor not to be used - BDOC(void) {} + BDOC(void) = default; }; // end of class BDOC diff --git a/storage/connect/bsonudf.h b/storage/connect/bsonudf.h index 0fe3715617e..e355fe7b48e 100644 --- a/storage/connect/bsonudf.h +++ b/storage/connect/bsonudf.h @@ -143,7 +143,7 @@ protected: my_bool AddPath(void); // Default constructor not to be used - BJNX(void) {} + BJNX(void) = default; // Members PBVAL Row; diff --git a/storage/connect/catalog.h b/storage/connect/catalog.h index 48347d7519e..2649a50cf76 100644 --- a/storage/connect/catalog.h +++ b/storage/connect/catalog.h @@ -61,7 +61,7 @@ class DllExport CATALOG { friend class OEMDEF; public: CATALOG(void); // Constructor - virtual ~CATALOG() { } // Make -Wdelete-non-virtual-dtor happy + virtual ~CATALOG() = default; // Make -Wdelete-non-virtual-dtor happy // Implementation int GetCblen(void) {return Cblen;} diff --git a/storage/connect/colblk.h b/storage/connect/colblk.h index c9712f516b5..e67ba3ba3f9 100644 --- a/storage/connect/colblk.h +++ b/storage/connect/colblk.h @@ -177,7 +177,7 @@ class DllExport TIDBLK : public SPCBLK { protected: // Default constructor not to be used - TIDBLK(void) {} + TIDBLK(void) = default; // Members PCSZ Tname; // The current table name @@ -200,7 +200,7 @@ class DllExport PRTBLK : public SPCBLK { protected: // Default constructor not to be used - PRTBLK(void) {} + PRTBLK(void) = default; // Members PCSZ Pname; // The current partition name @@ -223,7 +223,7 @@ class DllExport SIDBLK : public SPCBLK { protected: // Default constructor not to be used - SIDBLK(void) {} + SIDBLK(void) = default; // Members PCSZ Sname; // The current server name diff --git a/storage/connect/csort.h b/storage/connect/csort.h index 6e700059881..cce01df4199 100644 --- a/storage/connect/csort.h +++ b/storage/connect/csort.h @@ -33,7 +33,7 @@ class DllExport CSORT { public: // Constructor CSORT(bool cns, int th = THRESH, int mth = MTHRESH); - virtual ~CSORT() {} + virtual ~CSORT() = default; protected: // Implementation /*********************************************************************/ diff --git a/storage/connect/filamdbf.h b/storage/connect/filamdbf.h index dfe5cb5cfc4..6cf6331abd4 100644 --- a/storage/connect/filamdbf.h +++ b/storage/connect/filamdbf.h @@ -35,7 +35,7 @@ class DllExport DBFBASE { protected: // Default constructor, not to be used - DBFBASE(void) {} + DBFBASE(void) = default; // Members int Records; /* records in the file */ diff --git a/storage/connect/filter.h b/storage/connect/filter.h index 12ac3a169c1..0c3fa41046a 100644 --- a/storage/connect/filter.h +++ b/storage/connect/filter.h @@ -77,7 +77,7 @@ class DllExport FILTER : public XOBJECT { /* Filter description block */ // PFIL Copy(PTABS t); protected: - FILTER(void) {} // Standard constructor not to be used + FILTER(void) = default; // Standard constructor not to be used void Constr(PGLOBAL g, OPVAL opc, int opm, PPARM *tp); // Members diff --git a/storage/connect/jsonudf.h b/storage/connect/jsonudf.h index ada0dbcd96b..4378bddf9ba 100644 --- a/storage/connect/jsonudf.h +++ b/storage/connect/jsonudf.h @@ -349,7 +349,7 @@ protected: my_bool AddPath(void); // Default constructor not to be used - JSNX(void) {} + JSNX(void) = default; // Members PJSON Row; diff --git a/storage/connect/tabbson.h b/storage/connect/tabbson.h index 1696f4dfdbc..9d5a8b7daf5 100644 --- a/storage/connect/tabbson.h +++ b/storage/connect/tabbson.h @@ -257,7 +257,7 @@ protected: bool SetArrayOptions(PGLOBAL g, char* p, int i, PSZ nm); // Default constructor not to be used - BSONCOL(void) {} + BSONCOL(void) = default; // Members TDBBSN *Tbp; // To the JSN table block diff --git a/storage/connect/tabdos.h b/storage/connect/tabdos.h index 80dfe63845d..22bb5c63ce3 100644 --- a/storage/connect/tabdos.h +++ b/storage/connect/tabdos.h @@ -245,7 +245,7 @@ class DllExport DOSCOL : public COLBLK { bool AddDistinctValue(PGLOBAL g); // Default constructor not to be used - DOSCOL(void) {} + DOSCOL(void) = default; // Members PVBLK Min; // Array of block min values diff --git a/storage/connect/tabfix.h b/storage/connect/tabfix.h index 5f859a2bffe..1a0d756bfcf 100644 --- a/storage/connect/tabfix.h +++ b/storage/connect/tabfix.h @@ -82,7 +82,7 @@ class DllExport BINCOL : public DOSCOL { static void SetEndian(void); protected: - BINCOL(void) {} // Default constructor not to be used + BINCOL(void) = default; // Default constructor not to be used // Members static char Endian; // The host endian setting (L or B) diff --git a/storage/connect/tabfmt.h b/storage/connect/tabfmt.h index c46b5a3074e..268d00b1724 100644 --- a/storage/connect/tabfmt.h +++ b/storage/connect/tabfmt.h @@ -121,7 +121,7 @@ class DllExport CSVCOL : public DOSCOL { protected: // Default constructor not to be used - CSVCOL(void) {} + CSVCOL(void) = default; // Members int Fldnum; // Field ordinal number (0 based) diff --git a/storage/connect/tabjmg.h b/storage/connect/tabjmg.h index cf7cff83b68..06c1462d103 100644 --- a/storage/connect/tabjmg.h +++ b/storage/connect/tabjmg.h @@ -118,7 +118,7 @@ public: protected: // Default constructor not to be used - JMGCOL(void) {} + JMGCOL(void) = default; //char *GetProjPath(PGLOBAL g); //char *Mini(PGLOBAL g, const bson_t *bson, bool b); diff --git a/storage/connect/tabjson.h b/storage/connect/tabjson.h index 623e5b6d509..dcf40620dae 100644 --- a/storage/connect/tabjson.h +++ b/storage/connect/tabjson.h @@ -238,7 +238,7 @@ public: PJSON GetRow(PGLOBAL g); // Default constructor not to be used - JSONCOL(void) {} + JSONCOL(void) = default; // Members PGLOBAL G; // Support of parse memory diff --git a/storage/connect/tabmul.h b/storage/connect/tabmul.h index a9d3f88cc44..a01e4e7fdf2 100644 --- a/storage/connect/tabmul.h +++ b/storage/connect/tabmul.h @@ -237,7 +237,7 @@ class DIRCOL : public COLBLK { protected: // Default constructor not to be used - DIRCOL(void) {} + DIRCOL(void) = default; #if defined(_WIN32) void SetTimeValue(PGLOBAL g, FILETIME& ftime); #endif // _WIN32 diff --git a/storage/connect/taboccur.h b/storage/connect/taboccur.h index 4538d3d71f2..2a6503a2353 100644 --- a/storage/connect/taboccur.h +++ b/storage/connect/taboccur.h @@ -99,7 +99,7 @@ class OCCURCOL : public COLBLK { protected: // Default constructor not to be used - OCCURCOL(void) {} + OCCURCOL(void) = default; // Members int I; @@ -121,7 +121,7 @@ class RANKCOL : public COLBLK { protected: // Default constructor not to be used - RANKCOL(void) {} + RANKCOL(void) = default; // Members }; // end of class RANKCOL diff --git a/storage/connect/tabpivot.h b/storage/connect/tabpivot.h index 6c2d53e9527..b96da05bb08 100644 --- a/storage/connect/tabpivot.h +++ b/storage/connect/tabpivot.h @@ -188,7 +188,7 @@ class SRCCOL : public PRXCOL { protected: // Default constructor not to be used - SRCCOL(void) {} + SRCCOL(void) = default; // Members }; // end of class SRCCOL diff --git a/storage/connect/tabsys.h b/storage/connect/tabsys.h index 0c6017af177..0a427b12dae 100644 --- a/storage/connect/tabsys.h +++ b/storage/connect/tabsys.h @@ -108,7 +108,7 @@ class INICOL : public COLBLK { protected: // Default constructor not to be used - INICOL(void) {} + INICOL(void) = default; // Members char *Valbuf; // To the key value buffer @@ -176,7 +176,7 @@ class XINCOL : public INICOL { protected: // Default constructor not to be used - XINCOL(void) {} + XINCOL(void) = default; // Members }; // end of class XINICOL diff --git a/storage/connect/tabutil.h b/storage/connect/tabutil.h index c8e7e75106f..6cf2b11632b 100644 --- a/storage/connect/tabutil.h +++ b/storage/connect/tabutil.h @@ -122,7 +122,7 @@ class DllExport PRXCOL : public COLBLK { char *Decode(PGLOBAL g, const char *cnm); // Default constructor not to be used - PRXCOL(void) {} + PRXCOL(void) = default; // Members PCOL Colp; // Points to matching table column diff --git a/storage/connect/tabvct.h b/storage/connect/tabvct.h index 189a9ae2221..06ccde71bcb 100644 --- a/storage/connect/tabvct.h +++ b/storage/connect/tabvct.h @@ -110,7 +110,7 @@ class DllExport VCTCOL : public DOSCOL { virtual void ReadBlock(PGLOBAL g); virtual void WriteBlock(PGLOBAL g); - VCTCOL(void) {} // Default constructor not to be used + VCTCOL(void) = default; // Default constructor not to be used // Members PVBLK Blk; // Block buffer diff --git a/storage/connect/tabvir.h b/storage/connect/tabvir.h index e7313bbae67..b92ca0c50f8 100644 --- a/storage/connect/tabvir.h +++ b/storage/connect/tabvir.h @@ -21,7 +21,7 @@ PQRYRES VirColumns(PGLOBAL g, bool info); class DllExport VIRDEF : public TABDEF { /* Logical table description */ public: // Constructor - VIRDEF(void) {} + VIRDEF(void) = default; // Implementation virtual const char *GetType(void) {return "VIRTUAL";} @@ -86,7 +86,7 @@ class VIRCOL : public COLBLK { protected: // Default constructor not to be used - VIRCOL(void) {} + VIRCOL(void) = default; // No additional members }; // end of class VIRCOL diff --git a/storage/connect/tabxcl.h b/storage/connect/tabxcl.h index fde000ee709..4782f1bad49 100644 --- a/storage/connect/tabxcl.h +++ b/storage/connect/tabxcl.h @@ -95,7 +95,7 @@ class XCLCOL : public PRXCOL { protected: // Default constructor not to be used - XCLCOL(void) {} + XCLCOL(void) = default; // Members char *Cbuf; // The column buffer diff --git a/storage/connect/tabzip.h b/storage/connect/tabzip.h index d36e4dc01d0..3c16fae99bc 100644 --- a/storage/connect/tabzip.h +++ b/storage/connect/tabzip.h @@ -23,7 +23,7 @@ class DllExport ZIPDEF : public DOSDEF { /* Table description */ friend class UNZFAM; public: // Constructor - ZIPDEF(void) {} + ZIPDEF(void) = default; // Implementation virtual const char *GetType(void) {return "ZIP";} @@ -94,7 +94,7 @@ public: protected: // Default constructor not to be used - ZIPCOL(void) {} + ZIPCOL(void) = default; // Members TDBZIP *Tdbz; diff --git a/storage/connect/xtable.h b/storage/connect/xtable.h index 1b499e09047..58acf550a0b 100644 --- a/storage/connect/xtable.h +++ b/storage/connect/xtable.h @@ -264,7 +264,7 @@ class DllExport CATCOL : public COLBLK { virtual void ReadColumn(PGLOBAL g); protected: - CATCOL(void) {} // Default constructor not to be used + CATCOL(void) = default; // Default constructor not to be used // Members PTDBCAT Tdbp; // Points to ODBC table block diff --git a/storage/example/ha_example.h b/storage/example/ha_example.h index 0a08e871461..400b59bdda7 100644 --- a/storage/example/ha_example.h +++ b/storage/example/ha_example.h @@ -68,9 +68,7 @@ class ha_example: public handler public: ha_example(handlerton *hton, TABLE_SHARE *table_arg); - ~ha_example() - { - } + ~ha_example() = default; /** @brief The name of the index type that will be used for display. diff --git a/storage/federated/ha_federated.cc b/storage/federated/ha_federated.cc index 00407730c31..c6997d10893 100644 --- a/storage/federated/ha_federated.cc +++ b/storage/federated/ha_federated.cc @@ -1651,7 +1651,7 @@ int ha_federated::open(const char *name, int mode, uint test_if_locked) class Net_error_handler : public Internal_error_handler { public: - Net_error_handler() {} + Net_error_handler() = default; public: bool handle_condition(THD *thd, uint sql_errno, const char* sqlstate, diff --git a/storage/federated/ha_federated.h b/storage/federated/ha_federated.h index 8d6c28556c4..d72a073d469 100644 --- a/storage/federated/ha_federated.h +++ b/storage/federated/ha_federated.h @@ -121,7 +121,7 @@ private: int real_connect(); public: ha_federated(handlerton *hton, TABLE_SHARE *table_arg); - ~ha_federated() {} + ~ha_federated() = default; /* Next pointer used in transaction */ diff --git a/storage/federatedx/federatedx_io_null.cc b/storage/federatedx/federatedx_io_null.cc index b1058dbd2f5..8a2394f2150 100644 --- a/storage/federatedx/federatedx_io_null.cc +++ b/storage/federatedx/federatedx_io_null.cc @@ -118,9 +118,7 @@ federatedx_io_null::federatedx_io_null(FEDERATEDX_SERVER *aserver) } -federatedx_io_null::~federatedx_io_null() -{ -} +federatedx_io_null::~federatedx_io_null() = default; void federatedx_io_null::reset() diff --git a/storage/federatedx/federatedx_pushdown.cc b/storage/federatedx/federatedx_pushdown.cc index 430bc961167..3b7261428f8 100644 --- a/storage/federatedx/federatedx_pushdown.cc +++ b/storage/federatedx/federatedx_pushdown.cc @@ -144,7 +144,7 @@ ha_federatedx_derived_handler::ha_federatedx_derived_handler(THD *thd, derived= dt; } -ha_federatedx_derived_handler::~ha_federatedx_derived_handler() {} +ha_federatedx_derived_handler::~ha_federatedx_derived_handler() = default; int ha_federatedx_derived_handler::init_scan() { @@ -281,7 +281,7 @@ ha_federatedx_select_handler::ha_federatedx_select_handler(THD *thd, select= sel; } -ha_federatedx_select_handler::~ha_federatedx_select_handler() {} +ha_federatedx_select_handler::~ha_federatedx_select_handler() = default; int ha_federatedx_select_handler::init_scan() { diff --git a/storage/federatedx/ha_federatedx.cc b/storage/federatedx/ha_federatedx.cc index 39a9156a6c8..085edadc6ef 100644 --- a/storage/federatedx/ha_federatedx.cc +++ b/storage/federatedx/ha_federatedx.cc @@ -1809,7 +1809,7 @@ int ha_federatedx::open(const char *name, int mode, uint test_if_locked) class Net_error_handler : public Internal_error_handler { public: - Net_error_handler() {} + Net_error_handler() = default; public: bool handle_condition(THD *thd, uint sql_errno, const char* sqlstate, diff --git a/storage/federatedx/ha_federatedx.h b/storage/federatedx/ha_federatedx.h index ce09fb2253b..7e6a1756a3c 100644 --- a/storage/federatedx/ha_federatedx.h +++ b/storage/federatedx/ha_federatedx.h @@ -319,7 +319,7 @@ private: int real_connect(FEDERATEDX_SHARE *my_share, uint create_flag); public: ha_federatedx(handlerton *hton, TABLE_SHARE *table_arg); - ~ha_federatedx() {} + ~ha_federatedx() = default; /* The name of the index type that will be used for display don't implement this method unless you really have indexes diff --git a/storage/heap/ha_heap.h b/storage/heap/ha_heap.h index 370906bd1f6..7ef47d0e6da 100644 --- a/storage/heap/ha_heap.h +++ b/storage/heap/ha_heap.h @@ -36,7 +36,7 @@ class ha_heap: public handler my_bool internal_table; public: ha_heap(handlerton *hton, TABLE_SHARE *table); - ~ha_heap() {} + ~ha_heap() = default; handler *clone(const char *name, MEM_ROOT *mem_root); const char *index_type(uint inx) { diff --git a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc index b8e2aea204b..485e525aed8 100644 --- a/storage/innobase/handler/ha_innodb.cc +++ b/storage/innobase/handler/ha_innodb.cc @@ -2957,10 +2957,8 @@ ha_innobase::ha_innobase( /*********************************************************************//** Destruct ha_innobase handler. */ -ha_innobase::~ha_innobase() +ha_innobase::~ha_innobase() = default; /*======================*/ -{ -} /*********************************************************************//** Updates the user_thd field in a handle and also allocates a new InnoDB @@ -16061,7 +16059,7 @@ struct ShowStatus { }; /** Constructor */ - ShowStatus() { } + ShowStatus() = default; /** Callback for collecting the stats @param[in] latch_meta Latch meta data diff --git a/storage/innobase/include/buf0buf.h b/storage/innobase/include/buf0buf.h index e61e3e4c283..27fb673a01f 100644 --- a/storage/innobase/include/buf0buf.h +++ b/storage/innobase/include/buf0buf.h @@ -1868,7 +1868,7 @@ public: , m_hp() {} /** Destructor */ - virtual ~HazardPointer() {} + virtual ~HazardPointer() = default; /** Get current value */ buf_page_t* get() const @@ -1922,7 +1922,7 @@ public: HazardPointer(buf_pool, mutex) {} /** Destructor */ - ~FlushHp() override {} + ~FlushHp() override = default; /** Adjust the value of hp. This happens when some other thread working on the same list attempts to @@ -1943,7 +1943,7 @@ public: HazardPointer(buf_pool, mutex) {} /** Destructor */ - ~LRUHp() override {} + ~LRUHp() override = default; /** Adjust the value of hp. This happens when some other thread working on the same list attempts to @@ -1967,7 +1967,7 @@ public: LRUHp(buf_pool, mutex) {} /** Destructor */ - ~LRUItr() override {} + ~LRUItr() override = default; /** Selects from where to start a scan. If we have scanned too deep into the LRU list it resets the value to the tail diff --git a/storage/innobase/include/dict0types.h b/storage/innobase/include/dict0types.h index 76ffef236a1..5c4aaf8c87a 100644 --- a/storage/innobase/include/dict0types.h +++ b/storage/innobase/include/dict0types.h @@ -109,7 +109,7 @@ struct table_name_t char* m_name; /** Default constructor */ - table_name_t() {} + table_name_t() = default; /** Constructor */ table_name_t(char* name) : m_name(name) {} diff --git a/storage/innobase/include/ib0mutex.h b/storage/innobase/include/ib0mutex.h index de1d208fff4..fa493f4f4a1 100644 --- a/storage/innobase/include/ib0mutex.h +++ b/storage/innobase/include/ib0mutex.h @@ -542,7 +542,7 @@ struct PolicyMutex #endif /* UNIV_PFS_MUTEX */ } - ~PolicyMutex() { } + ~PolicyMutex() = default; /** @return non-const version of the policy */ Policy& policy() UNIV_NOTHROW diff --git a/storage/innobase/include/os0file.h b/storage/innobase/include/os0file.h index 646f964df7f..be363b8eea5 100644 --- a/storage/innobase/include/os0file.h +++ b/storage/innobase/include/os0file.h @@ -264,7 +264,7 @@ public: } /** Destructor */ - ~IORequest() { } + ~IORequest() = default; /** @return true if ignore missing flag is set */ static bool ignore_missing(ulint type) diff --git a/storage/innobase/include/rem0rec.h b/storage/innobase/include/rem0rec.h index 23956dcb068..0f749470d1d 100644 --- a/storage/innobase/include/rem0rec.h +++ b/storage/innobase/include/rem0rec.h @@ -1343,7 +1343,7 @@ public: } /** Destructor */ - ~rec_printer() override {} + ~rec_printer() override = default; private: /** Copy constructor */ diff --git a/storage/innobase/include/row0mysql.h b/storage/innobase/include/row0mysql.h index a2a03b549ab..fc40efd945d 100644 --- a/storage/innobase/include/row0mysql.h +++ b/storage/innobase/include/row0mysql.h @@ -824,7 +824,7 @@ struct row_prebuilt_t { /** Callback for row_mysql_sys_index_iterate() */ struct SysIndexCallback { - virtual ~SysIndexCallback() { } + virtual ~SysIndexCallback() = default; /** Callback method @param mtr current mini transaction diff --git a/storage/innobase/include/sync0types.h b/storage/innobase/include/sync0types.h index b0510e82524..25e37f9da17 100644 --- a/storage/innobase/include/sync0types.h +++ b/storage/innobase/include/sync0types.h @@ -392,7 +392,7 @@ struct OSMutex { } /** Destructor */ - ~OSMutex() { } + ~OSMutex() = default; /** Destroy the mutex */ void destroy() @@ -743,7 +743,7 @@ public: } /** Destructor */ - ~LatchMeta() { } + ~LatchMeta() = default; /** Constructor @param[in] id Latch id diff --git a/storage/innobase/include/trx0purge.h b/storage/innobase/include/trx0purge.h index a5a27555f5d..74c9a8f8b8d 100644 --- a/storage/innobase/include/trx0purge.h +++ b/storage/innobase/include/trx0purge.h @@ -78,7 +78,7 @@ public: typedef trx_rsegs_t::iterator iterator; typedef trx_rsegs_t::const_iterator const_iterator; - TrxUndoRsegs() {} + TrxUndoRsegs() = default; /** Constructor */ TrxUndoRsegs(trx_rseg_t& rseg) diff --git a/storage/innobase/include/ut0mutex.h b/storage/innobase/include/ut0mutex.h index abdd5729d43..2ae4657e2a0 100644 --- a/storage/innobase/include/ut0mutex.h +++ b/storage/innobase/include/ut0mutex.h @@ -111,10 +111,10 @@ in the debug version. */ class MutexMonitor { public: /** Constructor */ - MutexMonitor() { } + MutexMonitor() = default; /** Destructor */ - ~MutexMonitor() { } + ~MutexMonitor() = default; /** Enable the mutex monitoring */ void enable(); diff --git a/storage/innobase/include/ut0new.h b/storage/innobase/include/ut0new.h index a190b872549..3d25cb3029a 100644 --- a/storage/innobase/include/ut0new.h +++ b/storage/innobase/include/ut0new.h @@ -299,7 +299,7 @@ public: { } #else - ut_allocator() {} + ut_allocator() = default; ut_allocator(PSI_memory_key) {} #endif /* UNIV_PFS_MEMORY */ diff --git a/storage/innobase/include/ut0ut.h b/storage/innobase/include/ut0ut.h index 7031fc47f6a..4af67160251 100644 --- a/storage/innobase/include/ut0ut.h +++ b/storage/innobase/include/ut0ut.h @@ -340,7 +340,7 @@ class logger { protected: /* This class must not be used directly */ - ATTRIBUTE_COLD ATTRIBUTE_NOINLINE logger() {} + ATTRIBUTE_COLD ATTRIBUTE_NOINLINE logger() = default; public: template ATTRIBUTE_COLD ATTRIBUTE_NOINLINE logger& operator<<(const T& rhs) diff --git a/storage/innobase/row/row0import.cc b/storage/innobase/row/row0import.cc index 186661f1625..2afe7661e20 100644 --- a/storage/innobase/row/row0import.cc +++ b/storage/innobase/row/row0import.cc @@ -325,8 +325,8 @@ public: << index->name; } - /** Descructor */ - ~IndexPurge() UNIV_NOTHROW { } + /** Destructor */ + ~IndexPurge() UNIV_NOTHROW = default; /** Purge delete marked records. @return DB_SUCCESS or error code. */ @@ -675,7 +675,7 @@ struct FetchIndexRootPages : public AbstractCallback { m_table(table), m_index(0, 0) UNIV_NOTHROW { } /** Destructor */ - ~FetchIndexRootPages() UNIV_NOTHROW override { } + ~FetchIndexRootPages() UNIV_NOTHROW override = default; /** Fetch the clustered index root page in the tablespace @param iter Tablespace iterator diff --git a/storage/innobase/trx/trx0trx.cc b/storage/innobase/trx/trx0trx.cc index 770bbd961f2..7cd95878b0c 100644 --- a/storage/innobase/trx/trx0trx.cc +++ b/storage/innobase/trx/trx0trx.cc @@ -260,7 +260,7 @@ struct TrxFactory { /** The lock strategy for TrxPool */ struct TrxPoolLock { - TrxPoolLock() { } + TrxPoolLock() = default; /** Create the mutex */ void create() @@ -283,7 +283,7 @@ struct TrxPoolLock { /** The lock strategy for the TrxPoolManager */ struct TrxPoolManagerLock { - TrxPoolManagerLock() { } + TrxPoolManagerLock() = default; /** Create the mutex */ void create() diff --git a/storage/maria/ha_maria.h b/storage/maria/ha_maria.h index 73f3576a34e..576f3fbd1c7 100644 --- a/storage/maria/ha_maria.h +++ b/storage/maria/ha_maria.h @@ -56,7 +56,7 @@ class ha_maria :public handler public: ha_maria(handlerton *hton, TABLE_SHARE * table_arg); - ~ha_maria() {} + ~ha_maria() = default; handler *clone(const char *name, MEM_ROOT *mem_root); const char *index_type(uint key_number); ulonglong table_flags() const diff --git a/storage/mroonga/lib/mrn_count_skip_checker.cpp b/storage/mroonga/lib/mrn_count_skip_checker.cpp index dfa1a11d2b8..cd22be31ef2 100644 --- a/storage/mroonga/lib/mrn_count_skip_checker.cpp +++ b/storage/mroonga/lib/mrn_count_skip_checker.cpp @@ -40,8 +40,7 @@ namespace mrn { is_storage_mode_(is_storage_mode) { } - CountSkipChecker::~CountSkipChecker() { - } + CountSkipChecker::~CountSkipChecker() = default; bool CountSkipChecker::check() { MRN_DBUG_ENTER_METHOD(); diff --git a/storage/mroonga/lib/mrn_database_repairer.cpp b/storage/mroonga/lib/mrn_database_repairer.cpp index c0c4a90e8f7..08ddd84943e 100644 --- a/storage/mroonga/lib/mrn_database_repairer.cpp +++ b/storage/mroonga/lib/mrn_database_repairer.cpp @@ -57,8 +57,7 @@ namespace mrn { mrn_db_file_suffix_length_(strlen(MRN_DB_FILE_SUFFIX)) { } - DatabaseRepairer::~DatabaseRepairer() { - } + DatabaseRepairer::~DatabaseRepairer() = default; bool DatabaseRepairer::is_crashed(void) { MRN_DBUG_ENTER_METHOD(); diff --git a/storage/mroonga/lib/mrn_field_normalizer.cpp b/storage/mroonga/lib/mrn_field_normalizer.cpp index bb9982f0f84..72011b5eecc 100644 --- a/storage/mroonga/lib/mrn_field_normalizer.cpp +++ b/storage/mroonga/lib/mrn_field_normalizer.cpp @@ -30,8 +30,7 @@ namespace mrn { field_(field) { } - FieldNormalizer::~FieldNormalizer() { - } + FieldNormalizer::~FieldNormalizer() = default; bool FieldNormalizer::should_normalize() { MRN_DBUG_ENTER_METHOD(); diff --git a/storage/mroonga/lib/mrn_multiple_column_key_codec.cpp b/storage/mroonga/lib/mrn_multiple_column_key_codec.cpp index 73639685d0e..dd3165cdadf 100644 --- a/storage/mroonga/lib/mrn_multiple_column_key_codec.cpp +++ b/storage/mroonga/lib/mrn_multiple_column_key_codec.cpp @@ -70,8 +70,7 @@ namespace mrn { key_info_(key_info) { } - MultipleColumnKeyCodec::~MultipleColumnKeyCodec() { - } + MultipleColumnKeyCodec::~MultipleColumnKeyCodec() = default; int MultipleColumnKeyCodec::encode(const uchar *mysql_key, uint mysql_key_length, diff --git a/storage/mroonga/lib/mrn_query_parser.cpp b/storage/mroonga/lib/mrn_query_parser.cpp index 92387e259a8..b32ebd2c443 100644 --- a/storage/mroonga/lib/mrn_query_parser.cpp +++ b/storage/mroonga/lib/mrn_query_parser.cpp @@ -44,8 +44,7 @@ namespace mrn { match_columns_(match_columns) { } - QueryParser::~QueryParser() { - } + QueryParser::~QueryParser() = default; grn_rc QueryParser::parse(const char *query, size_t query_length) { MRN_DBUG_ENTER_METHOD(); diff --git a/storage/mroonga/lib/mrn_time_converter.cpp b/storage/mroonga/lib/mrn_time_converter.cpp index 9bb8d89a082..7d7555bb47a 100644 --- a/storage/mroonga/lib/mrn_time_converter.cpp +++ b/storage/mroonga/lib/mrn_time_converter.cpp @@ -33,11 +33,9 @@ #define MRN_CLASS_NAME "mrn::TimeConverter" namespace mrn { - TimeConverter::TimeConverter() { - } + TimeConverter::TimeConverter() = default; - TimeConverter::~TimeConverter() { - } + TimeConverter::~TimeConverter() = default; time_t TimeConverter::tm_to_time_gm(struct tm *time, bool *truncated) { MRN_DBUG_ENTER_METHOD(); diff --git a/storage/mroonga/vendor/groonga/lib/dat/array.hpp b/storage/mroonga/vendor/groonga/lib/dat/array.hpp index de60e3bd590..58186ff4127 100644 --- a/storage/mroonga/vendor/groonga/lib/dat/array.hpp +++ b/storage/mroonga/vendor/groonga/lib/dat/array.hpp @@ -33,7 +33,7 @@ class GRN_DAT_API Array { } template explicit Array(T (&array)[U]) : ptr_(array), size_(U) {} - ~Array() {} + ~Array() = default; const T &operator[](UInt32 i) const { GRN_DAT_DEBUG_THROW_IF(i >= size_); diff --git a/storage/mroonga/vendor/groonga/lib/dat/cursor.hpp b/storage/mroonga/vendor/groonga/lib/dat/cursor.hpp index 357b5250e99..740a56edfde 100644 --- a/storage/mroonga/vendor/groonga/lib/dat/cursor.hpp +++ b/storage/mroonga/vendor/groonga/lib/dat/cursor.hpp @@ -25,8 +25,8 @@ namespace dat { class GRN_DAT_API Cursor { public: - Cursor() {} - virtual ~Cursor() {} + Cursor() = default; + virtual ~Cursor() = default; virtual void close() = 0; diff --git a/storage/mroonga/vendor/groonga/lib/dat/dat.hpp b/storage/mroonga/vendor/groonga/lib/dat/dat.hpp index 1afbd0955bc..b6e2893ad07 100644 --- a/storage/mroonga/vendor/groonga/lib/dat/dat.hpp +++ b/storage/mroonga/vendor/groonga/lib/dat/dat.hpp @@ -175,12 +175,8 @@ class Exception : public std::exception { file_(file), line_(line), what_((what != NULL) ? what : "") {} - Exception(const Exception &ex) throw() - : std::exception(ex), - file_(ex.file_), - line_(ex.line_), - what_(ex.what_) {} - virtual ~Exception() throw() {} + Exception(const Exception &ex) throw() = default; + virtual ~Exception() throw() = default; virtual ErrorCode code() const throw() = 0; virtual const char *file() const throw() { @@ -208,7 +204,7 @@ class Error : public Exception { : Exception(file, line, what) {} Error(const Error &ex) throw() : Exception(ex) {} - virtual ~Error() throw() {} + virtual ~Error() throw() = default; virtual ErrorCode code() const throw() { return T; diff --git a/storage/mroonga/vendor/groonga/lib/dat/id-cursor.cpp b/storage/mroonga/vendor/groonga/lib/dat/id-cursor.cpp index de969839586..d3caf510dcd 100644 --- a/storage/mroonga/vendor/groonga/lib/dat/id-cursor.cpp +++ b/storage/mroonga/vendor/groonga/lib/dat/id-cursor.cpp @@ -33,7 +33,7 @@ IdCursor::IdCursor() end_(INVALID_KEY_ID), count_(0) {} -IdCursor::~IdCursor() {} +IdCursor::~IdCursor() = default; void IdCursor::open(const Trie &trie, const String &min_str, diff --git a/storage/mroonga/vendor/groonga/lib/dat/key.hpp b/storage/mroonga/vendor/groonga/lib/dat/key.hpp index eb0324cd8d3..717ad90a715 100644 --- a/storage/mroonga/vendor/groonga/lib/dat/key.hpp +++ b/storage/mroonga/vendor/groonga/lib/dat/key.hpp @@ -99,7 +99,7 @@ class GRN_DAT_API Key { // Disallows instantiation. Key() : id_and_length_low_(INVALID_KEY_ID << 4), length_high_(0) {} - ~Key() {} + ~Key() = default; // Disallows copy and assignment. Key(const Key &); diff --git a/storage/mroonga/vendor/groonga/lib/dat/predictive-cursor.cpp b/storage/mroonga/vendor/groonga/lib/dat/predictive-cursor.cpp index 67520305703..d9fd995beae 100644 --- a/storage/mroonga/vendor/groonga/lib/dat/predictive-cursor.cpp +++ b/storage/mroonga/vendor/groonga/lib/dat/predictive-cursor.cpp @@ -35,7 +35,7 @@ PredictiveCursor::PredictiveCursor() end_(0), min_length_(0) {} -PredictiveCursor::~PredictiveCursor() {} +PredictiveCursor::~PredictiveCursor() = default; void PredictiveCursor::open(const Trie &trie, const String &str, diff --git a/storage/mroonga/vendor/groonga/lib/dat/prefix-cursor.cpp b/storage/mroonga/vendor/groonga/lib/dat/prefix-cursor.cpp index 83adeb3731e..5f491c6644f 100644 --- a/storage/mroonga/vendor/groonga/lib/dat/prefix-cursor.cpp +++ b/storage/mroonga/vendor/groonga/lib/dat/prefix-cursor.cpp @@ -33,7 +33,7 @@ PrefixCursor::PrefixCursor() cur_(0), end_(0) {} -PrefixCursor::~PrefixCursor() {} +PrefixCursor::~PrefixCursor() = default; void PrefixCursor::open(const Trie &trie, const String &str, diff --git a/storage/mroonga/vendor/groonga/lib/dat/string.hpp b/storage/mroonga/vendor/groonga/lib/dat/string.hpp index aead21cac18..281333ee18f 100644 --- a/storage/mroonga/vendor/groonga/lib/dat/string.hpp +++ b/storage/mroonga/vendor/groonga/lib/dat/string.hpp @@ -35,9 +35,7 @@ class GRN_DAT_API String { explicit String(const char (&str)[T]) : ptr_(reinterpret_cast(str)), length_(T - 1) {} - String(const String &rhs) - : ptr_(rhs.ptr_), - length_(rhs.length_) {} + String(const String &rhs) = default; String &operator=(const String &rhs) { set_ptr(rhs.ptr()); diff --git a/storage/mroonga/vendor/groonga/lib/dat/trie.cpp b/storage/mroonga/vendor/groonga/lib/dat/trie.cpp index b2c6a84ffa7..47d53209953 100644 --- a/storage/mroonga/vendor/groonga/lib/dat/trie.cpp +++ b/storage/mroonga/vendor/groonga/lib/dat/trie.cpp @@ -55,7 +55,7 @@ Trie::Trie() entries_(), key_buf_() {} -Trie::~Trie() {} +Trie::~Trie() = default; void Trie::create(const char *file_name, UInt64 file_size, diff --git a/storage/myisam/ha_myisam.h b/storage/myisam/ha_myisam.h index 70c99a617f6..afdce1185fc 100644 --- a/storage/myisam/ha_myisam.h +++ b/storage/myisam/ha_myisam.h @@ -53,7 +53,7 @@ class ha_myisam: public handler public: ha_myisam(handlerton *hton, TABLE_SHARE *table_arg); - ~ha_myisam() {} + ~ha_myisam() = default; handler *clone(const char *name, MEM_ROOT *mem_root); const char *index_type(uint key_number); ulonglong table_flags() const { return int_table_flags; } diff --git a/storage/perfschema/cursor_by_account.h b/storage/perfschema/cursor_by_account.h index c14a563b712..fa6aa95fb04 100644 --- a/storage/perfschema/cursor_by_account.h +++ b/storage/perfschema/cursor_by_account.h @@ -49,8 +49,7 @@ protected: cursor_by_account(const PFS_engine_table_share *share); public: - ~cursor_by_account() - {} + ~cursor_by_account() = default; protected: virtual void make_row(PFS_account *account)= 0; diff --git a/storage/perfschema/cursor_by_host.h b/storage/perfschema/cursor_by_host.h index ac68acf3945..ad81b2b2045 100644 --- a/storage/perfschema/cursor_by_host.h +++ b/storage/perfschema/cursor_by_host.h @@ -49,8 +49,7 @@ protected: cursor_by_host(const PFS_engine_table_share *share); public: - ~cursor_by_host() - {} + ~cursor_by_host() = default; protected: virtual void make_row(PFS_host *host)= 0; diff --git a/storage/perfschema/cursor_by_thread.h b/storage/perfschema/cursor_by_thread.h index db130088920..83fbbf4f56a 100644 --- a/storage/perfschema/cursor_by_thread.h +++ b/storage/perfschema/cursor_by_thread.h @@ -49,8 +49,7 @@ protected: cursor_by_thread(const PFS_engine_table_share *share); public: - ~cursor_by_thread() - {} + ~cursor_by_thread() = default; protected: virtual void make_row(PFS_thread *thread)= 0; diff --git a/storage/perfschema/cursor_by_thread_connect_attr.h b/storage/perfschema/cursor_by_thread_connect_attr.h index 69d1b5ec0c0..925ab3bdcc6 100644 --- a/storage/perfschema/cursor_by_thread_connect_attr.h +++ b/storage/perfschema/cursor_by_thread_connect_attr.h @@ -69,8 +69,7 @@ protected: cursor_by_thread_connect_attr(const PFS_engine_table_share *share); public: - ~cursor_by_thread_connect_attr() - {} + ~cursor_by_thread_connect_attr() = default; protected: virtual void make_row(PFS_thread *thread, uint ordinal)= 0; diff --git a/storage/perfschema/cursor_by_user.h b/storage/perfschema/cursor_by_user.h index 06554ebb228..849f55147a0 100644 --- a/storage/perfschema/cursor_by_user.h +++ b/storage/perfschema/cursor_by_user.h @@ -49,8 +49,7 @@ protected: cursor_by_user(const PFS_engine_table_share *share); public: - ~cursor_by_user() - {} + ~cursor_by_user() = default; protected: virtual void make_row(PFS_user *user)= 0; diff --git a/storage/perfschema/ha_perfschema.cc b/storage/perfschema/ha_perfschema.cc index 8860046fa26..509d4a26e82 100644 --- a/storage/perfschema/ha_perfschema.cc +++ b/storage/perfschema/ha_perfschema.cc @@ -229,8 +229,7 @@ ha_perfschema::ha_perfschema(handlerton *hton, TABLE_SHARE *share) : handler(hton, share), m_table_share(NULL), m_table(NULL) {} -ha_perfschema::~ha_perfschema() -{} +ha_perfschema::~ha_perfschema() = default; int ha_perfschema::open(const char *name, int mode, uint test_if_locked) { diff --git a/storage/perfschema/pfs_engine_table.cc b/storage/perfschema/pfs_engine_table.cc index acab0e73a3d..62ed8b2c312 100644 --- a/storage/perfschema/pfs_engine_table.cc +++ b/storage/perfschema/pfs_engine_table.cc @@ -438,11 +438,9 @@ int PFS_engine_table::update_row_values(TABLE *, class PFS_internal_schema_access : public ACL_internal_schema_access { public: - PFS_internal_schema_access() - {} + PFS_internal_schema_access() = default; - ~PFS_internal_schema_access() - {} + ~PFS_internal_schema_access() = default; ACL_internal_access_result check(ulong want_access, ulong *save_priv) const; diff --git a/storage/perfschema/pfs_engine_table.h b/storage/perfschema/pfs_engine_table.h index 03a2b6a9d28..428c0e49e17 100644 --- a/storage/perfschema/pfs_engine_table.h +++ b/storage/perfschema/pfs_engine_table.h @@ -84,8 +84,7 @@ public: void get_normalizer(PFS_instr_class *instr_class); /** Destructor. */ - virtual ~PFS_engine_table() - {} + virtual ~PFS_engine_table() = default; /** Helper, assign a value to a ulong field. @@ -260,11 +259,9 @@ struct PFS_engine_table_share class PFS_readonly_acl : public ACL_internal_table_access { public: - PFS_readonly_acl() - {} + PFS_readonly_acl() = default; - ~PFS_readonly_acl() - {} + ~PFS_readonly_acl() = default; virtual ACL_internal_access_result check(ulong want_access, ulong *save_priv) const; }; @@ -279,11 +276,9 @@ extern PFS_readonly_acl pfs_readonly_acl; class PFS_truncatable_acl : public ACL_internal_table_access { public: - PFS_truncatable_acl() - {} + PFS_truncatable_acl() = default; - ~PFS_truncatable_acl() - {} + ~PFS_truncatable_acl() = default; ACL_internal_access_result check(ulong want_access, ulong *save_priv) const; }; @@ -298,11 +293,9 @@ extern PFS_truncatable_acl pfs_truncatable_acl; class PFS_updatable_acl : public ACL_internal_table_access { public: - PFS_updatable_acl() - {} + PFS_updatable_acl() = default; - ~PFS_updatable_acl() - {} + ~PFS_updatable_acl() = default; ACL_internal_access_result check(ulong want_access, ulong *save_priv) const; }; @@ -317,11 +310,9 @@ extern PFS_updatable_acl pfs_updatable_acl; class PFS_editable_acl : public ACL_internal_table_access { public: - PFS_editable_acl() - {} + PFS_editable_acl() = default; - ~PFS_editable_acl() - {} + ~PFS_editable_acl() = default; ACL_internal_access_result check(ulong want_access, ulong *save_priv) const; }; @@ -335,11 +326,9 @@ extern PFS_editable_acl pfs_editable_acl; class PFS_unknown_acl : public ACL_internal_table_access { public: - PFS_unknown_acl() - {} + PFS_unknown_acl() = default; - ~PFS_unknown_acl() - {} + ~PFS_unknown_acl() = default; ACL_internal_access_result check(ulong want_access, ulong *save_priv) const; }; diff --git a/storage/perfschema/pfs_visitor.cc b/storage/perfschema/pfs_visitor.cc index 097965fde17..e845ddbeb1e 100644 --- a/storage/perfschema/pfs_visitor.cc +++ b/storage/perfschema/pfs_visitor.cc @@ -662,8 +662,7 @@ PFS_connection_wait_visitor m_index= klass->m_event_name_index; } -PFS_connection_wait_visitor::~PFS_connection_wait_visitor() -{} +PFS_connection_wait_visitor::~PFS_connection_wait_visitor() = default; void PFS_connection_wait_visitor::visit_global() { @@ -696,12 +695,9 @@ void PFS_connection_wait_visitor::visit_thread(PFS_thread *pfs) m_stat.aggregate(& pfs->m_instr_class_waits_stats[m_index]); } -PFS_connection_all_wait_visitor -::PFS_connection_all_wait_visitor() -{} +PFS_connection_all_wait_visitor::PFS_connection_all_wait_visitor() = default; -PFS_connection_all_wait_visitor::~PFS_connection_all_wait_visitor() -{} +PFS_connection_all_wait_visitor::~PFS_connection_all_wait_visitor() = default; void PFS_connection_all_wait_visitor::visit_global() { @@ -744,8 +740,7 @@ PFS_connection_stage_visitor::PFS_connection_stage_visitor(PFS_stage_class *klas m_index= klass->m_event_name_index; } -PFS_connection_stage_visitor::~PFS_connection_stage_visitor() -{} +PFS_connection_stage_visitor::~PFS_connection_stage_visitor() = default; void PFS_connection_stage_visitor::visit_global() { @@ -778,8 +773,7 @@ PFS_connection_statement_visitor m_index= klass->m_event_name_index; } -PFS_connection_statement_visitor::~PFS_connection_statement_visitor() -{} +PFS_connection_statement_visitor::~PFS_connection_statement_visitor() = default; void PFS_connection_statement_visitor::visit_global() { @@ -808,11 +802,10 @@ void PFS_connection_statement_visitor::visit_thread(PFS_thread *pfs) /** Instance wait visitor */ PFS_connection_all_statement_visitor -::PFS_connection_all_statement_visitor() -{} +::PFS_connection_all_statement_visitor() = default; -PFS_connection_all_statement_visitor::~PFS_connection_all_statement_visitor() -{} +PFS_connection_all_statement_visitor +::~PFS_connection_all_statement_visitor() = default; void PFS_connection_all_statement_visitor::visit_global() { @@ -854,11 +847,9 @@ void PFS_connection_all_statement_visitor::visit_thread(PFS_thread *pfs) visit_connection_slice(pfs); } -PFS_connection_stat_visitor::PFS_connection_stat_visitor() -{} +PFS_connection_stat_visitor::PFS_connection_stat_visitor() = default; -PFS_connection_stat_visitor::~PFS_connection_stat_visitor() -{} +PFS_connection_stat_visitor::~PFS_connection_stat_visitor() = default; void PFS_connection_stat_visitor::visit_global() {} @@ -883,12 +874,9 @@ void PFS_connection_stat_visitor::visit_thread(PFS_thread *) m_stat.aggregate_active(1); } -PFS_instance_wait_visitor::PFS_instance_wait_visitor() -{ -} +PFS_instance_wait_visitor::PFS_instance_wait_visitor() = default; -PFS_instance_wait_visitor::~PFS_instance_wait_visitor() -{} +PFS_instance_wait_visitor::~PFS_instance_wait_visitor() = default; void PFS_instance_wait_visitor::visit_mutex_class(PFS_mutex_class *pfs) { @@ -948,11 +936,9 @@ void PFS_instance_wait_visitor::visit_socket(PFS_socket *pfs) /** Table IO wait visitor */ -PFS_object_wait_visitor::PFS_object_wait_visitor() -{} +PFS_object_wait_visitor::PFS_object_wait_visitor() = default; -PFS_object_wait_visitor::~PFS_object_wait_visitor() -{} +PFS_object_wait_visitor::~PFS_object_wait_visitor() = default; void PFS_object_wait_visitor::visit_global() { @@ -976,11 +962,9 @@ void PFS_object_wait_visitor::visit_table(PFS_table *pfs) } } -PFS_table_io_wait_visitor::PFS_table_io_wait_visitor() -{} +PFS_table_io_wait_visitor::PFS_table_io_wait_visitor() = default; -PFS_table_io_wait_visitor::~PFS_table_io_wait_visitor() -{} +PFS_table_io_wait_visitor::~PFS_table_io_wait_visitor() = default; void PFS_table_io_wait_visitor::visit_global() { @@ -1026,11 +1010,9 @@ void PFS_table_io_wait_visitor::visit_table(PFS_table *pfs) /** Table IO stat visitor */ -PFS_table_io_stat_visitor::PFS_table_io_stat_visitor() -{} +PFS_table_io_stat_visitor::PFS_table_io_stat_visitor() = default; -PFS_table_io_stat_visitor::~PFS_table_io_stat_visitor() -{} +PFS_table_io_stat_visitor::~PFS_table_io_stat_visitor() = default; void PFS_table_io_stat_visitor::visit_table_share(PFS_table_share *pfs) { @@ -1065,11 +1047,9 @@ void PFS_table_io_stat_visitor::visit_table(PFS_table *pfs) /** Index IO stat visitor */ -PFS_index_io_stat_visitor::PFS_index_io_stat_visitor() -{} +PFS_index_io_stat_visitor::PFS_index_io_stat_visitor() = default; -PFS_index_io_stat_visitor::~PFS_index_io_stat_visitor() -{} +PFS_index_io_stat_visitor::~PFS_index_io_stat_visitor() = default; void PFS_index_io_stat_visitor::visit_table_share_index(PFS_table_share *pfs, uint index) { @@ -1083,11 +1063,9 @@ void PFS_index_io_stat_visitor::visit_table_index(PFS_table *pfs, uint index) /** Table lock wait visitor */ -PFS_table_lock_wait_visitor::PFS_table_lock_wait_visitor() -{} +PFS_table_lock_wait_visitor::PFS_table_lock_wait_visitor() = default; -PFS_table_lock_wait_visitor::~PFS_table_lock_wait_visitor() -{} +PFS_table_lock_wait_visitor::~PFS_table_lock_wait_visitor() = default; void PFS_table_lock_wait_visitor::visit_global() { @@ -1106,11 +1084,9 @@ void PFS_table_lock_wait_visitor::visit_table(PFS_table *pfs) /** Table lock stat visitor */ -PFS_table_lock_stat_visitor::PFS_table_lock_stat_visitor() -{} +PFS_table_lock_stat_visitor::PFS_table_lock_stat_visitor() = default; -PFS_table_lock_stat_visitor::~PFS_table_lock_stat_visitor() -{} +PFS_table_lock_stat_visitor::~PFS_table_lock_stat_visitor() = default; void PFS_table_lock_stat_visitor::visit_table_share(PFS_table_share *pfs) { @@ -1122,11 +1098,11 @@ void PFS_table_lock_stat_visitor::visit_table(PFS_table *pfs) m_stat.aggregate(& pfs->m_table_stat.m_lock_stat); } -PFS_instance_socket_io_stat_visitor::PFS_instance_socket_io_stat_visitor() -{} +PFS_instance_socket_io_stat_visitor +::PFS_instance_socket_io_stat_visitor() = default; -PFS_instance_socket_io_stat_visitor::~PFS_instance_socket_io_stat_visitor() -{} +PFS_instance_socket_io_stat_visitor +::~PFS_instance_socket_io_stat_visitor() = default; void PFS_instance_socket_io_stat_visitor::visit_socket_class(PFS_socket_class *pfs) { @@ -1141,11 +1117,11 @@ void PFS_instance_socket_io_stat_visitor::visit_socket(PFS_socket *pfs) } -PFS_instance_file_io_stat_visitor::PFS_instance_file_io_stat_visitor() -{} +PFS_instance_file_io_stat_visitor +::PFS_instance_file_io_stat_visitor() = default; -PFS_instance_file_io_stat_visitor::~PFS_instance_file_io_stat_visitor() -{} +PFS_instance_file_io_stat_visitor +::~PFS_instance_file_io_stat_visitor() = default; void PFS_instance_file_io_stat_visitor::visit_file_class(PFS_file_class *pfs) { diff --git a/storage/perfschema/pfs_visitor.h b/storage/perfschema/pfs_visitor.h index 120b5928045..b6e3569b518 100644 --- a/storage/perfschema/pfs_visitor.h +++ b/storage/perfschema/pfs_visitor.h @@ -63,8 +63,8 @@ struct PFS_connection_slice; class PFS_connection_visitor { public: - PFS_connection_visitor() {} - virtual ~PFS_connection_visitor() {} + PFS_connection_visitor() = default; + virtual ~PFS_connection_visitor() = default; /** Visit all connections. */ virtual void visit_global() {} /** Visit all connections of a host. */ @@ -138,8 +138,8 @@ public: class PFS_instance_visitor { public: - PFS_instance_visitor() {} - virtual ~PFS_instance_visitor() {} + PFS_instance_visitor() = default; + virtual ~PFS_instance_visitor() = default; /** Visit a mutex class. */ virtual void visit_mutex_class(PFS_mutex_class *pfs) {} /** Visit a rwlock class. */ @@ -249,8 +249,8 @@ public: class PFS_object_visitor { public: - PFS_object_visitor() {} - virtual ~PFS_object_visitor() {} + PFS_object_visitor() = default; + virtual ~PFS_object_visitor() = default; /** Visit global data. */ virtual void visit_global() {} /** Visit a table share. */ diff --git a/storage/perfschema/table_accounts.h b/storage/perfschema/table_accounts.h index dfc2cc322e0..7bdcf2ce164 100644 --- a/storage/perfschema/table_accounts.h +++ b/storage/perfschema/table_accounts.h @@ -66,8 +66,7 @@ protected: table_accounts(); public: - ~table_accounts() - {} + ~table_accounts() = default; private: virtual void make_row(PFS_account *pfs); diff --git a/storage/perfschema/table_all_instr.h b/storage/perfschema/table_all_instr.h index 072221ba86e..0c2f3d28cf6 100644 --- a/storage/perfschema/table_all_instr.h +++ b/storage/perfschema/table_all_instr.h @@ -82,8 +82,7 @@ protected: table_all_instr(const PFS_engine_table_share *share); public: - ~table_all_instr() - {} + ~table_all_instr() = default; protected: /** diff --git a/storage/perfschema/table_esgs_by_account_by_event_name.h b/storage/perfschema/table_esgs_by_account_by_event_name.h index ee855d42818..fcd4a5e33f4 100644 --- a/storage/perfschema/table_esgs_by_account_by_event_name.h +++ b/storage/perfschema/table_esgs_by_account_by_event_name.h @@ -106,8 +106,7 @@ protected: table_esgs_by_account_by_event_name(); public: - ~table_esgs_by_account_by_event_name() - {} + ~table_esgs_by_account_by_event_name() = default; protected: void make_row(PFS_account *account, PFS_stage_class *klass); diff --git a/storage/perfschema/table_esgs_by_host_by_event_name.h b/storage/perfschema/table_esgs_by_host_by_event_name.h index 6042e6396af..006f789b15f 100644 --- a/storage/perfschema/table_esgs_by_host_by_event_name.h +++ b/storage/perfschema/table_esgs_by_host_by_event_name.h @@ -106,8 +106,7 @@ protected: table_esgs_by_host_by_event_name(); public: - ~table_esgs_by_host_by_event_name() - {} + ~table_esgs_by_host_by_event_name() = default; protected: void make_row(PFS_host *host, PFS_stage_class *klass); diff --git a/storage/perfschema/table_esgs_by_thread_by_event_name.h b/storage/perfschema/table_esgs_by_thread_by_event_name.h index 6ff677a95e2..9b0105345e5 100644 --- a/storage/perfschema/table_esgs_by_thread_by_event_name.h +++ b/storage/perfschema/table_esgs_by_thread_by_event_name.h @@ -110,8 +110,7 @@ protected: table_esgs_by_thread_by_event_name(); public: - ~table_esgs_by_thread_by_event_name() - {} + ~table_esgs_by_thread_by_event_name() = default; protected: void make_row(PFS_thread *thread, PFS_stage_class *klass); diff --git a/storage/perfschema/table_esgs_by_user_by_event_name.h b/storage/perfschema/table_esgs_by_user_by_event_name.h index bc545c2438a..22e94c3de58 100644 --- a/storage/perfschema/table_esgs_by_user_by_event_name.h +++ b/storage/perfschema/table_esgs_by_user_by_event_name.h @@ -111,8 +111,7 @@ protected: table_esgs_by_user_by_event_name(); public: - ~table_esgs_by_user_by_event_name() - {} + ~table_esgs_by_user_by_event_name() = default; protected: void make_row(PFS_user *user, PFS_stage_class *klass); diff --git a/storage/perfschema/table_esgs_global_by_event_name.h b/storage/perfschema/table_esgs_global_by_event_name.h index b8884355676..92f75f15048 100644 --- a/storage/perfschema/table_esgs_global_by_event_name.h +++ b/storage/perfschema/table_esgs_global_by_event_name.h @@ -74,8 +74,7 @@ protected: table_esgs_global_by_event_name(); public: - ~table_esgs_global_by_event_name() - {} + ~table_esgs_global_by_event_name() = default; protected: void make_row(PFS_stage_class *klass); diff --git a/storage/perfschema/table_esms_by_account_by_event_name.h b/storage/perfschema/table_esms_by_account_by_event_name.h index 64f2053cff6..a3b7266c074 100644 --- a/storage/perfschema/table_esms_by_account_by_event_name.h +++ b/storage/perfschema/table_esms_by_account_by_event_name.h @@ -106,8 +106,7 @@ protected: table_esms_by_account_by_event_name(); public: - ~table_esms_by_account_by_event_name() - {} + ~table_esms_by_account_by_event_name() = default; protected: void make_row(PFS_account *account, PFS_statement_class *klass); diff --git a/storage/perfschema/table_esms_by_digest.h b/storage/perfschema/table_esms_by_digest.h index 903b86110f6..f1de170d3ef 100644 --- a/storage/perfschema/table_esms_by_digest.h +++ b/storage/perfschema/table_esms_by_digest.h @@ -76,8 +76,7 @@ protected: table_esms_by_digest(); public: - ~table_esms_by_digest() - {} + ~table_esms_by_digest() = default; protected: void make_row(PFS_statements_digest_stat*); diff --git a/storage/perfschema/table_esms_by_host_by_event_name.h b/storage/perfschema/table_esms_by_host_by_event_name.h index a6985b48149..1373d8058dd 100644 --- a/storage/perfschema/table_esms_by_host_by_event_name.h +++ b/storage/perfschema/table_esms_by_host_by_event_name.h @@ -106,8 +106,7 @@ protected: table_esms_by_host_by_event_name(); public: - ~table_esms_by_host_by_event_name() - {} + ~table_esms_by_host_by_event_name() = default; protected: void make_row(PFS_host *host, PFS_statement_class *klass); diff --git a/storage/perfschema/table_esms_by_thread_by_event_name.h b/storage/perfschema/table_esms_by_thread_by_event_name.h index 72645d03389..d7111b9bc05 100644 --- a/storage/perfschema/table_esms_by_thread_by_event_name.h +++ b/storage/perfschema/table_esms_by_thread_by_event_name.h @@ -110,8 +110,7 @@ protected: table_esms_by_thread_by_event_name(); public: - ~table_esms_by_thread_by_event_name() - {} + ~table_esms_by_thread_by_event_name() = default; protected: void make_row(PFS_thread *thread, PFS_statement_class *klass); diff --git a/storage/perfschema/table_esms_by_user_by_event_name.h b/storage/perfschema/table_esms_by_user_by_event_name.h index d1d1e5df85d..8b395ce9829 100644 --- a/storage/perfschema/table_esms_by_user_by_event_name.h +++ b/storage/perfschema/table_esms_by_user_by_event_name.h @@ -106,8 +106,7 @@ protected: table_esms_by_user_by_event_name(); public: - ~table_esms_by_user_by_event_name() - {} + ~table_esms_by_user_by_event_name() = default; protected: void make_row(PFS_user *user, PFS_statement_class *klass); diff --git a/storage/perfschema/table_esms_global_by_event_name.h b/storage/perfschema/table_esms_global_by_event_name.h index b90c14c0c0f..60a298721d8 100644 --- a/storage/perfschema/table_esms_global_by_event_name.h +++ b/storage/perfschema/table_esms_global_by_event_name.h @@ -74,8 +74,7 @@ protected: table_esms_global_by_event_name(); public: - ~table_esms_global_by_event_name() - {} + ~table_esms_global_by_event_name() = default; protected: void make_row(PFS_statement_class *klass); diff --git a/storage/perfschema/table_events_stages.h b/storage/perfschema/table_events_stages.h index ae8760cd953..b0a8d399090 100644 --- a/storage/perfschema/table_events_stages.h +++ b/storage/perfschema/table_events_stages.h @@ -102,8 +102,7 @@ protected: table_events_stages_common(const PFS_engine_table_share *share, void *pos); - ~table_events_stages_common() - {} + ~table_events_stages_common() = default; void make_row(PFS_events_stages *stage); @@ -131,8 +130,7 @@ protected: table_events_stages_current(); public: - ~table_events_stages_current() - {} + ~table_events_stages_current() = default; private: friend class table_events_stages_history; @@ -165,8 +163,7 @@ protected: table_events_stages_history(); public: - ~table_events_stages_history() - {} + ~table_events_stages_history() = default; private: /** Table share lock. */ @@ -196,8 +193,7 @@ protected: table_events_stages_history_long(); public: - ~table_events_stages_history_long() - {} + ~table_events_stages_history_long() = default; private: /** Table share lock. */ diff --git a/storage/perfschema/table_events_statements.h b/storage/perfschema/table_events_statements.h index cec28628f3e..8e4aafd8719 100644 --- a/storage/perfschema/table_events_statements.h +++ b/storage/perfschema/table_events_statements.h @@ -176,8 +176,7 @@ protected: table_events_statements_common(const PFS_engine_table_share *share, void *pos); - ~table_events_statements_common() - {} + ~table_events_statements_common() = default; void make_row_part_1(PFS_events_statements *statement, sql_digest_storage *digest); @@ -209,8 +208,7 @@ protected: table_events_statements_current(); public: - ~table_events_statements_current() - {} + ~table_events_statements_current() = default; private: friend class table_events_statements_history; @@ -245,8 +243,7 @@ protected: table_events_statements_history(); public: - ~table_events_statements_history() - {} + ~table_events_statements_history() = default; private: /** Table share lock. */ @@ -278,8 +275,7 @@ protected: table_events_statements_history_long(); public: - ~table_events_statements_history_long() - {} + ~table_events_statements_history_long() = default; private: /** Table share lock. */ diff --git a/storage/perfschema/table_events_waits.h b/storage/perfschema/table_events_waits.h index 90c1d341e5d..94d8c9ff5bd 100644 --- a/storage/perfschema/table_events_waits.h +++ b/storage/perfschema/table_events_waits.h @@ -146,8 +146,7 @@ protected: table_events_waits_common(const PFS_engine_table_share *share, void *pos); - ~table_events_waits_common() - {} + ~table_events_waits_common() = default; void clear_object_columns(); int make_table_object_columns(volatile PFS_events_waits *wait); @@ -180,8 +179,7 @@ protected: table_events_waits_current(); public: - ~table_events_waits_current() - {} + ~table_events_waits_current() = default; private: friend class table_events_waits_history; @@ -213,8 +211,7 @@ protected: table_events_waits_history(); public: - ~table_events_waits_history() - {} + ~table_events_waits_history() = default; private: /** Table share lock. */ @@ -243,8 +240,7 @@ protected: table_events_waits_history_long(); public: - ~table_events_waits_history_long() - {} + ~table_events_waits_history_long() = default; private: /** Table share lock. */ diff --git a/storage/perfschema/table_events_waits_summary.h b/storage/perfschema/table_events_waits_summary.h index 53f1bed7987..b38660fa439 100644 --- a/storage/perfschema/table_events_waits_summary.h +++ b/storage/perfschema/table_events_waits_summary.h @@ -80,8 +80,7 @@ protected: table_events_waits_summary_by_instance(); public: - ~table_events_waits_summary_by_instance() - {} + ~table_events_waits_summary_by_instance() = default; private: /** Table share lock. */ diff --git a/storage/perfschema/table_ews_by_account_by_event_name.h b/storage/perfschema/table_ews_by_account_by_event_name.h index 7cde09183e3..d4b4593a261 100644 --- a/storage/perfschema/table_ews_by_account_by_event_name.h +++ b/storage/perfschema/table_ews_by_account_by_event_name.h @@ -117,8 +117,7 @@ protected: table_ews_by_account_by_event_name(); public: - ~table_ews_by_account_by_event_name() - {} + ~table_ews_by_account_by_event_name() = default; protected: void make_row(PFS_account *account, PFS_instr_class *klass); diff --git a/storage/perfschema/table_ews_by_host_by_event_name.h b/storage/perfschema/table_ews_by_host_by_event_name.h index 8ce44a96617..c9c96115855 100644 --- a/storage/perfschema/table_ews_by_host_by_event_name.h +++ b/storage/perfschema/table_ews_by_host_by_event_name.h @@ -117,8 +117,7 @@ protected: table_ews_by_host_by_event_name(); public: - ~table_ews_by_host_by_event_name() - {} + ~table_ews_by_host_by_event_name() = default; protected: void make_row(PFS_host *host, PFS_instr_class *klass); diff --git a/storage/perfschema/table_ews_by_thread_by_event_name.h b/storage/perfschema/table_ews_by_thread_by_event_name.h index b67664bfced..3aabb78c5e2 100644 --- a/storage/perfschema/table_ews_by_thread_by_event_name.h +++ b/storage/perfschema/table_ews_by_thread_by_event_name.h @@ -116,8 +116,7 @@ protected: table_ews_by_thread_by_event_name(); public: - ~table_ews_by_thread_by_event_name() - {} + ~table_ews_by_thread_by_event_name() = default; protected: void make_row(PFS_thread *thread, PFS_instr_class *klass); diff --git a/storage/perfschema/table_ews_by_user_by_event_name.h b/storage/perfschema/table_ews_by_user_by_event_name.h index f4f29534be4..7083cd5788d 100644 --- a/storage/perfschema/table_ews_by_user_by_event_name.h +++ b/storage/perfschema/table_ews_by_user_by_event_name.h @@ -117,8 +117,7 @@ protected: table_ews_by_user_by_event_name(); public: - ~table_ews_by_user_by_event_name() - {} + ~table_ews_by_user_by_event_name() = default; protected: void make_row(PFS_user *user, PFS_instr_class *klass); diff --git a/storage/perfschema/table_ews_global_by_event_name.h b/storage/perfschema/table_ews_global_by_event_name.h index 8157d274112..62c5eefe46a 100644 --- a/storage/perfschema/table_ews_global_by_event_name.h +++ b/storage/perfschema/table_ews_global_by_event_name.h @@ -102,8 +102,7 @@ protected: table_ews_global_by_event_name(); public: - ~table_ews_global_by_event_name() - {} + ~table_ews_global_by_event_name() = default; protected: void make_mutex_row(PFS_mutex_class *klass); diff --git a/storage/perfschema/table_file_instances.h b/storage/perfschema/table_file_instances.h index 5b44e63028e..6a62e1c4d73 100644 --- a/storage/perfschema/table_file_instances.h +++ b/storage/perfschema/table_file_instances.h @@ -72,8 +72,7 @@ private: table_file_instances(); public: - ~table_file_instances() - {} + ~table_file_instances() = default; private: void make_row(PFS_file *pfs); diff --git a/storage/perfschema/table_file_summary_by_event_name.h b/storage/perfschema/table_file_summary_by_event_name.h index b8cb293cb07..17cc81e6686 100644 --- a/storage/perfschema/table_file_summary_by_event_name.h +++ b/storage/perfschema/table_file_summary_by_event_name.h @@ -73,8 +73,7 @@ private: table_file_summary_by_event_name(); public: - ~table_file_summary_by_event_name() - {} + ~table_file_summary_by_event_name() = default; private: void make_row(PFS_file_class *klass); diff --git a/storage/perfschema/table_file_summary_by_instance.h b/storage/perfschema/table_file_summary_by_instance.h index 0e7ce6958b2..e49f966191b 100644 --- a/storage/perfschema/table_file_summary_by_instance.h +++ b/storage/perfschema/table_file_summary_by_instance.h @@ -81,8 +81,7 @@ private: table_file_summary_by_instance(); public: - ~table_file_summary_by_instance() - {} + ~table_file_summary_by_instance() = default; private: void make_row(PFS_file *pfs); diff --git a/storage/perfschema/table_host_cache.h b/storage/perfschema/table_host_cache.h index 8add0b5049c..4b54865c7f5 100644 --- a/storage/perfschema/table_host_cache.h +++ b/storage/perfschema/table_host_cache.h @@ -125,8 +125,7 @@ protected: table_host_cache(); public: - ~table_host_cache() - {} + ~table_host_cache() = default; private: void materialize(THD *thd); diff --git a/storage/perfschema/table_hosts.h b/storage/perfschema/table_hosts.h index 422b6449b25..57c5be31c6a 100644 --- a/storage/perfschema/table_hosts.h +++ b/storage/perfschema/table_hosts.h @@ -66,8 +66,7 @@ protected: table_hosts(); public: - ~table_hosts() - {} + ~table_hosts() = default; private: virtual void make_row(PFS_host *pfs); diff --git a/storage/perfschema/table_os_global_by_type.h b/storage/perfschema/table_os_global_by_type.h index 2b9293ece06..6f6f1da5d17 100644 --- a/storage/perfschema/table_os_global_by_type.h +++ b/storage/perfschema/table_os_global_by_type.h @@ -110,8 +110,7 @@ protected: table_os_global_by_type(); public: - ~table_os_global_by_type() - {} + ~table_os_global_by_type() = default; protected: void make_row(PFS_table_share *table_share); diff --git a/storage/perfschema/table_performance_timers.h b/storage/perfschema/table_performance_timers.h index 93210ac9882..ed583e33358 100644 --- a/storage/perfschema/table_performance_timers.h +++ b/storage/perfschema/table_performance_timers.h @@ -71,8 +71,7 @@ protected: table_performance_timers(); public: - ~table_performance_timers() - {} + ~table_performance_timers() = default; private: /** Table share lock. */ diff --git a/storage/perfschema/table_session_account_connect_attrs.h b/storage/perfschema/table_session_account_connect_attrs.h index 483001fcb91..9d39b6e5608 100644 --- a/storage/perfschema/table_session_account_connect_attrs.h +++ b/storage/perfschema/table_session_account_connect_attrs.h @@ -42,8 +42,7 @@ protected: table_session_account_connect_attrs(); public: - ~table_session_account_connect_attrs() - {} + ~table_session_account_connect_attrs() = default; protected: virtual bool thread_fits(PFS_thread *thread); diff --git a/storage/perfschema/table_session_connect_attrs.h b/storage/perfschema/table_session_connect_attrs.h index 927c3a92af2..f7939fd02d5 100644 --- a/storage/perfschema/table_session_connect_attrs.h +++ b/storage/perfschema/table_session_connect_attrs.h @@ -42,8 +42,7 @@ protected: table_session_connect_attrs(); public: - ~table_session_connect_attrs() - {} + ~table_session_connect_attrs() = default; private: /** Table share lock. */ diff --git a/storage/perfschema/table_setup_actors.h b/storage/perfschema/table_setup_actors.h index 6bfc480a9c5..28660dacc6a 100644 --- a/storage/perfschema/table_setup_actors.h +++ b/storage/perfschema/table_setup_actors.h @@ -88,8 +88,7 @@ protected: table_setup_actors(); public: - ~table_setup_actors() - {} + ~table_setup_actors() = default; private: void make_row(PFS_setup_actor *actor); diff --git a/storage/perfschema/table_setup_consumers.h b/storage/perfschema/table_setup_consumers.h index 90da55920c6..9e39b932829 100644 --- a/storage/perfschema/table_setup_consumers.h +++ b/storage/perfschema/table_setup_consumers.h @@ -73,8 +73,7 @@ protected: table_setup_consumers(); public: - ~table_setup_consumers() - {} + ~table_setup_consumers() = default; private: /** Table share lock. */ diff --git a/storage/perfschema/table_setup_instruments.h b/storage/perfschema/table_setup_instruments.h index cd3715cfe55..ff52d8fc0c3 100644 --- a/storage/perfschema/table_setup_instruments.h +++ b/storage/perfschema/table_setup_instruments.h @@ -105,8 +105,7 @@ protected: table_setup_instruments(); public: - ~table_setup_instruments() - {} + ~table_setup_instruments() = default; private: void make_row(PFS_instr_class *klass); diff --git a/storage/perfschema/table_setup_objects.h b/storage/perfschema/table_setup_objects.h index 570acc865ad..b5f86c87ea1 100644 --- a/storage/perfschema/table_setup_objects.h +++ b/storage/perfschema/table_setup_objects.h @@ -91,8 +91,7 @@ protected: table_setup_objects(); public: - ~table_setup_objects() - {} + ~table_setup_objects() = default; private: void make_row(PFS_setup_object *pfs); diff --git a/storage/perfschema/table_setup_timers.h b/storage/perfschema/table_setup_timers.h index d591f3e0b67..24180221e1e 100644 --- a/storage/perfschema/table_setup_timers.h +++ b/storage/perfschema/table_setup_timers.h @@ -71,8 +71,7 @@ protected: table_setup_timers(); public: - ~table_setup_timers() - {} + ~table_setup_timers() = default; private: /** Table share lock. */ diff --git a/storage/perfschema/table_socket_instances.h b/storage/perfschema/table_socket_instances.h index 41b5ee3fd21..1be68bca557 100644 --- a/storage/perfschema/table_socket_instances.h +++ b/storage/perfschema/table_socket_instances.h @@ -84,8 +84,7 @@ private: table_socket_instances(); public: - ~table_socket_instances() - {} + ~table_socket_instances() = default; private: void make_row(PFS_socket *pfs); diff --git a/storage/perfschema/table_socket_summary_by_event_name.h b/storage/perfschema/table_socket_summary_by_event_name.h index 4f679d89b09..36b01d9fd49 100644 --- a/storage/perfschema/table_socket_summary_by_event_name.h +++ b/storage/perfschema/table_socket_summary_by_event_name.h @@ -74,8 +74,7 @@ private: table_socket_summary_by_event_name(); public: - ~table_socket_summary_by_event_name() - {} + ~table_socket_summary_by_event_name() = default; private: void make_row(PFS_socket_class *socket_class); diff --git a/storage/perfschema/table_socket_summary_by_instance.h b/storage/perfschema/table_socket_summary_by_instance.h index a9eab8d18b6..3c6fe25d8e8 100644 --- a/storage/perfschema/table_socket_summary_by_instance.h +++ b/storage/perfschema/table_socket_summary_by_instance.h @@ -77,8 +77,7 @@ private: table_socket_summary_by_instance(); public: - ~table_socket_summary_by_instance() - {} + ~table_socket_summary_by_instance() = default; private: void make_row(PFS_socket *pfs); diff --git a/storage/perfschema/table_sync_instances.h b/storage/perfschema/table_sync_instances.h index 6f7e1bf5523..0d60090022e 100644 --- a/storage/perfschema/table_sync_instances.h +++ b/storage/perfschema/table_sync_instances.h @@ -76,8 +76,7 @@ private: table_mutex_instances(); public: - ~table_mutex_instances() - {} + ~table_mutex_instances() = default; private: void make_row(PFS_mutex *pfs); @@ -133,8 +132,7 @@ private: table_rwlock_instances(); public: - ~table_rwlock_instances() - {} + ~table_rwlock_instances() = default; private: void make_row(PFS_rwlock *pfs); @@ -184,8 +182,7 @@ private: table_cond_instances(); public: - ~table_cond_instances() - {} + ~table_cond_instances() = default; private: void make_row(PFS_cond *pfs); diff --git a/storage/perfschema/table_threads.h b/storage/perfschema/table_threads.h index 841b8102bca..029ab9634c6 100644 --- a/storage/perfschema/table_threads.h +++ b/storage/perfschema/table_threads.h @@ -101,8 +101,7 @@ protected: table_threads(); public: - ~table_threads() - {} + ~table_threads() = default; private: virtual void make_row(PFS_thread *pfs); diff --git a/storage/perfschema/table_tiws_by_index_usage.h b/storage/perfschema/table_tiws_by_index_usage.h index a284bc7f0bc..ac5d628199f 100644 --- a/storage/perfschema/table_tiws_by_index_usage.h +++ b/storage/perfschema/table_tiws_by_index_usage.h @@ -104,8 +104,7 @@ protected: table_tiws_by_index_usage(); public: - ~table_tiws_by_index_usage() - {} + ~table_tiws_by_index_usage() = default; protected: void make_row(PFS_table_share *table_share, uint index); diff --git a/storage/perfschema/table_tiws_by_table.h b/storage/perfschema/table_tiws_by_table.h index 7427ca797fa..b51398d6108 100644 --- a/storage/perfschema/table_tiws_by_table.h +++ b/storage/perfschema/table_tiws_by_table.h @@ -74,8 +74,7 @@ protected: table_tiws_by_table(); public: - ~table_tiws_by_table() - {} + ~table_tiws_by_table() = default; protected: void make_row(PFS_table_share *table_share); diff --git a/storage/perfschema/table_tlws_by_table.h b/storage/perfschema/table_tlws_by_table.h index b5872a07762..8aabfef145a 100644 --- a/storage/perfschema/table_tlws_by_table.h +++ b/storage/perfschema/table_tlws_by_table.h @@ -74,8 +74,7 @@ protected: table_tlws_by_table(); public: - ~table_tlws_by_table() - {} + ~table_tlws_by_table() = default; protected: void make_row(PFS_table_share *table_share); diff --git a/storage/perfschema/table_users.h b/storage/perfschema/table_users.h index 912f0f43714..8121262b040 100644 --- a/storage/perfschema/table_users.h +++ b/storage/perfschema/table_users.h @@ -66,8 +66,7 @@ protected: table_users(); public: - ~table_users() - {} + ~table_users() = default; private: virtual void make_row(PFS_user *pfs); diff --git a/storage/rocksdb/ha_rocksdb.cc b/storage/rocksdb/ha_rocksdb.cc index 9a77f6e6c99..5a5ad924a06 100644 --- a/storage/rocksdb/ha_rocksdb.cc +++ b/storage/rocksdb/ha_rocksdb.cc @@ -2257,7 +2257,7 @@ static inline uint32_t rocksdb_perf_context_level(THD *const thd) { */ interface Rdb_tx_list_walker { - virtual ~Rdb_tx_list_walker() {} + virtual ~Rdb_tx_list_walker() = default; virtual void process_tran(const Rdb_transaction *const) = 0; }; diff --git a/storage/rocksdb/ha_rocksdb.h b/storage/rocksdb/ha_rocksdb.h index 73f9b49b00f..1dad053972f 100644 --- a/storage/rocksdb/ha_rocksdb.h +++ b/storage/rocksdb/ha_rocksdb.h @@ -1045,7 +1045,7 @@ struct Rdb_inplace_alter_ctx : public my_core::inplace_alter_handler_ctx { m_n_dropped_keys(n_dropped_keys), m_max_auto_incr(max_auto_incr) {} - ~Rdb_inplace_alter_ctx() {} + ~Rdb_inplace_alter_ctx() = default; private: /* Disable Copying */ diff --git a/storage/rocksdb/rdb_compact_filter.h b/storage/rocksdb/rdb_compact_filter.h index 1cd27273b56..93767b23787 100644 --- a/storage/rocksdb/rdb_compact_filter.h +++ b/storage/rocksdb/rdb_compact_filter.h @@ -204,9 +204,9 @@ class Rdb_compact_filter_factory : public rocksdb::CompactionFilterFactory { Rdb_compact_filter_factory(const Rdb_compact_filter_factory &) = delete; Rdb_compact_filter_factory &operator=(const Rdb_compact_filter_factory &) = delete; - Rdb_compact_filter_factory() {} + Rdb_compact_filter_factory() = default; - ~Rdb_compact_filter_factory() {} + ~Rdb_compact_filter_factory() = default; const char *Name() const override { return "Rdb_compact_filter_factory"; } diff --git a/storage/rocksdb/rdb_datadic.h b/storage/rocksdb/rdb_datadic.h index 7bcc45d3f62..d17fb917363 100644 --- a/storage/rocksdb/rdb_datadic.h +++ b/storage/rocksdb/rdb_datadic.h @@ -1174,7 +1174,7 @@ class Rdb_seq_generator { interface Rdb_tables_scanner { virtual int add_table(Rdb_tbl_def * tdef) = 0; - virtual ~Rdb_tables_scanner() {} /* Keep the compiler happy */ + virtual ~Rdb_tables_scanner() = default; /* Keep the compiler happy */ }; /* @@ -1211,7 +1211,7 @@ class Rdb_ddl_manager { public: Rdb_ddl_manager(const Rdb_ddl_manager &) = delete; Rdb_ddl_manager &operator=(const Rdb_ddl_manager &) = delete; - Rdb_ddl_manager() {} + Rdb_ddl_manager() = default; /* Load the data dictionary from on-disk storage */ bool init(Rdb_dict_manager *const dict_arg, Rdb_cf_manager *const cf_manager, diff --git a/storage/rocksdb/rdb_mutex_wrapper.h b/storage/rocksdb/rdb_mutex_wrapper.h index 33eefe9d50c..fd0790aa8e6 100644 --- a/storage/rocksdb/rdb_mutex_wrapper.h +++ b/storage/rocksdb/rdb_mutex_wrapper.h @@ -122,7 +122,7 @@ class Rdb_mutex_factory : public rocksdb::TransactionDBMutexFactory { public: Rdb_mutex_factory(const Rdb_mutex_factory &) = delete; Rdb_mutex_factory &operator=(const Rdb_mutex_factory &) = delete; - Rdb_mutex_factory() {} + Rdb_mutex_factory() = default; /* Override parent class's virtual methods of interrest. */ @@ -137,7 +137,7 @@ class Rdb_mutex_factory : public rocksdb::TransactionDBMutexFactory { return std::make_shared(); } - virtual ~Rdb_mutex_factory() override {} + virtual ~Rdb_mutex_factory() override = default; }; } // namespace myrocks diff --git a/storage/rocksdb/rdb_threads.h b/storage/rocksdb/rdb_threads.h index 7d89fe0616b..d23419df3b9 100644 --- a/storage/rocksdb/rdb_threads.h +++ b/storage/rocksdb/rdb_threads.h @@ -125,7 +125,7 @@ class Rdb_thread { void uninit(); - virtual ~Rdb_thread() {} + virtual ~Rdb_thread() = default; private: static void *thread_func(void *const thread_ptr); diff --git a/storage/sequence/sequence.cc b/storage/sequence/sequence.cc index 8eae98955c3..b782327a347 100644 --- a/storage/sequence/sequence.cc +++ b/storage/sequence/sequence.cc @@ -370,7 +370,7 @@ public: TABLE_LIST *table_list_arg) : group_by_handler(thd_arg, sequence_hton), fields(fields_arg), table_list(table_list_arg) {} - ~ha_seq_group_by_handler() {} + ~ha_seq_group_by_handler() = default; int init_scan() { first_row= 1 ; return 0; } int next_row(); int end_scan() { return 0; } diff --git a/storage/spider/hs_client/hstcpcli.hpp b/storage/spider/hs_client/hstcpcli.hpp index 6894716e469..aac02ce7f46 100644 --- a/storage/spider/hs_client/hstcpcli.hpp +++ b/storage/spider/hs_client/hstcpcli.hpp @@ -51,7 +51,7 @@ struct hstresult { }; struct hstcpcli_i { - virtual ~hstcpcli_i() { } + virtual ~hstcpcli_i() = default; virtual void close() = 0; virtual int reconnect() = 0; virtual bool stable_point() = 0; diff --git a/storage/spider/hs_client/util.hpp b/storage/spider/hs_client/util.hpp index 93d78cc7dc0..60b5441703d 100644 --- a/storage/spider/hs_client/util.hpp +++ b/storage/spider/hs_client/util.hpp @@ -13,7 +13,7 @@ namespace dena { /* boost::noncopyable */ struct noncopyable { - noncopyable() { } + noncopyable() = default; private: noncopyable(const noncopyable&); noncopyable& operator =(const noncopyable&); diff --git a/storage/spider/spd_db_include.h b/storage/spider/spd_db_include.h index 71403212445..eaddddc6d72 100644 --- a/storage/spider/spd_db_include.h +++ b/storage/spider/spd_db_include.h @@ -813,8 +813,8 @@ class spider_db_util { public: uint dbton_id; - spider_db_util() {} - virtual ~spider_db_util() {} + spider_db_util() = default; + virtual ~spider_db_util() = default; virtual int append_name( spider_string *str, const char *name, @@ -949,7 +949,7 @@ public: uint dbton_id; SPIDER_DB_ROW *next_pos; spider_db_row(uint in_dbton_id) : dbton_id(in_dbton_id), next_pos(NULL) {} - virtual ~spider_db_row() {} + virtual ~spider_db_row() = default; virtual int store_to_field( Field *field, CHARSET_INFO *access_charset @@ -981,8 +981,8 @@ public: class spider_db_result_buffer { public: - spider_db_result_buffer() {} - virtual ~spider_db_result_buffer() {} + spider_db_result_buffer() = default; + virtual ~spider_db_result_buffer() = default; virtual void clear() = 0; virtual bool check_size( longlong size @@ -996,7 +996,7 @@ protected: public: uint dbton_id; spider_db_result(SPIDER_DB_CONN *in_db_conn); - virtual ~spider_db_result() {} + virtual ~spider_db_result() = default; virtual bool has_result() = 0; virtual void free_result() = 0; virtual SPIDER_DB_ROW *current_row() = 0; @@ -1062,7 +1062,7 @@ public: spider_db_conn( SPIDER_CONN *in_conn ); - virtual ~spider_db_conn() {} + virtual ~spider_db_conn() = default; virtual int init() = 0; virtual bool is_connected() = 0; virtual void bg_connect() = 0; @@ -1281,7 +1281,7 @@ public: st_spider_share *share, uint dbton_id ) : dbton_id(dbton_id), spider_share(share) {} - virtual ~spider_db_share() {} + virtual ~spider_db_share() = default; virtual int init() = 0; virtual uint get_column_name_length( uint field_index @@ -1328,7 +1328,7 @@ public: spider_db_handler(ha_spider *spider, spider_db_share *db_share) : dbton_id(db_share->dbton_id), spider(spider), db_share(db_share), first_link_idx(-1) {} - virtual ~spider_db_handler() {} + virtual ~spider_db_handler() = default; virtual int init() = 0; virtual int append_index_hint( spider_string *str, @@ -1815,7 +1815,7 @@ public: spider_db_share *db_share; spider_db_copy_table(spider_db_share *db_share) : dbton_id(db_share->dbton_id), db_share(db_share) {} - virtual ~spider_db_copy_table() {} + virtual ~spider_db_copy_table() = default; virtual int init() = 0; virtual void set_sql_charset( CHARSET_INFO *cs -- cgit v1.2.1 From c63768425b03148737ba62dda7b6948283b04c94 Mon Sep 17 00:00:00 2001 From: Igor Babaev Date: Wed, 8 Feb 2023 19:24:15 -0800 Subject: MDEV-30586 DELETE with aggregation in subquery of WHERE returns bogus error The parser code for single-table DELETE missed the call of the function LEX::check_main_unit_semantics(). As a result the the field nested level of SELECT_LEX structures remained set 0 for all non-top level selects. This could lead to different kind of problems. In particular this did not allow to determine properly the selects where set functions had to be aggregated when they were used in inner subqueries. Approved by Oleksandr Byelkin --- mysql-test/main/delete.result | 32 ++++++++++++++++++++++++++++++++ mysql-test/main/delete.test | 41 +++++++++++++++++++++++++++++++++++++++++ sql/sql_yacc.yy | 4 ++++ sql/sql_yacc_ora.yy | 4 ++++ 4 files changed, 81 insertions(+) diff --git a/mysql-test/main/delete.result b/mysql-test/main/delete.result index ed3683d52f9..7a9963abc71 100644 --- a/mysql-test/main/delete.result +++ b/mysql-test/main/delete.result @@ -525,3 +525,35 @@ DELETE v2 FROM v2; ERROR HY000: Can not delete from join view 'test.v2' DROP VIEW v2, v1; DROP TABLE t1, t2; +End of 5.5 tests +# +# MDEV-30586: DELETE with WHERE containing nested subquery +# with set function aggregated in outer subquery +# +create table t1 (a int); +insert into t1 values (3), (7), (1); +create table t2 (b int); +insert into t2 values (2), (1), (4), (7); +create table t3 (a int, b int); +insert into t3 values (2,10), (7,30), (2,30), (1,10), (7,40); +select * from t1 +where t1.a in (select t3.a from t3 group by t3.a +having t3.a > any (select t2.b from t2 +where t2.b*10 < sum(t3.b))); +a +7 +delete from t1 +where t1.a in (select t3.a from t3 group by t3.a +having t3.a > any (select t2.b from t2 +where t2.b*10 < sum(t3.b))); +select * from t1 +where t1.a in (select t3.a from t3 group by t3.a +having t3.a > any (select t2.b from t2 +where t2.b*10 < sum(t3.b))); +a +update t1 set t1.a=t1.a+10 +where t1.a in (select t3.a from t3 group by t3.a +having t3.a > any (select t2.b from t2 +where t2.b*10 < sum(t3.b))); +drop table t1,t2,t3; +End of 10.4 tests diff --git a/mysql-test/main/delete.test b/mysql-test/main/delete.test index c82420640c2..6d898ec769d 100644 --- a/mysql-test/main/delete.test +++ b/mysql-test/main/delete.test @@ -582,3 +582,44 @@ DELETE v2 FROM v2; DROP VIEW v2, v1; DROP TABLE t1, t2; + +--echo End of 5.5 tests + +--echo # +--echo # MDEV-30586: DELETE with WHERE containing nested subquery +--echo # with set function aggregated in outer subquery +--echo # + +create table t1 (a int); +insert into t1 values (3), (7), (1); + +create table t2 (b int); +insert into t2 values (2), (1), (4), (7); + +create table t3 (a int, b int); +insert into t3 values (2,10), (7,30), (2,30), (1,10), (7,40); + +let $c= + t1.a in (select t3.a from t3 group by t3.a + having t3.a > any (select t2.b from t2 + where t2.b*10 < sum(t3.b))); + +eval +select * from t1 + where $c; + +eval +delete from t1 + where $c; + +eval +select * from t1 + where $c; + +eval +update t1 set t1.a=t1.a+10 + where $c; + +drop table t1,t2,t3; + +--echo End of 10.4 tests diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy index 0221e4ed433..902b7d16022 100644 --- a/sql/sql_yacc.yy +++ b/sql/sql_yacc.yy @@ -14032,6 +14032,8 @@ delete_part2: { Lex->last_table()->vers_conditions= Lex->vers_conditions; Lex->pop_select(); //main select + if (Lex->check_main_unit_semantics()) + MYSQL_YYABORT; } ; @@ -14068,6 +14070,8 @@ single_multi: if ($3) Select->order_list= *($3); Lex->pop_select(); //main select + if (Lex->check_main_unit_semantics()) + MYSQL_YYABORT; } | table_wild_list { diff --git a/sql/sql_yacc_ora.yy b/sql/sql_yacc_ora.yy index f6cda75a677..1e1af943d83 100644 --- a/sql/sql_yacc_ora.yy +++ b/sql/sql_yacc_ora.yy @@ -14162,6 +14162,8 @@ delete_part2: { Lex->last_table()->vers_conditions= Lex->vers_conditions; Lex->pop_select(); //main select + if (Lex->check_main_unit_semantics()) + MYSQL_YYABORT; } ; @@ -14198,6 +14200,8 @@ single_multi: if ($3) Select->order_list= *($3); Lex->pop_select(); //main select + if (Lex->check_main_unit_semantics()) + MYSQL_YYABORT; } | table_wild_list { -- cgit v1.2.1 From eecd4f1459214b84207b426ed87e12fd89f236af Mon Sep 17 00:00:00 2001 From: Brandon Nesterenko Date: Wed, 8 Feb 2023 10:32:35 -0700 Subject: MDEV-30608: rpl.rpl_delayed_parallel_slave_sbm sometimes fails with Seconds_Behind_Master should not have used second transaction timestamp One of the constraints added in the MDEV-29639 patch, is that only the first event after idling should update last_master_timestamp; and as long as the replica has more events to execute, the variable should not be updated. The corresponding test, rpl_delayed_parallel_slave_sbm.test, aims to verify this; however, if the IO thread takes too long to queue events, the SQL thread can appear to catch up too fast. This fix ensures that the relay log has been fully written before executing the events. Note that the underlying cause of this test failure needs to be addressed as a bug-fix, this is a temporary fix to stop test failures. To track work on the bug-fix for the underlying issue, please see MDEV-30619. --- .../suite/rpl/r/rpl_delayed_parallel_slave_sbm.result | 12 ++++++++++++ .../suite/rpl/t/rpl_delayed_parallel_slave_sbm.test | 17 +++++++++++++++++ sql/slave.cc | 15 +++++++++++++++ 3 files changed, 44 insertions(+) diff --git a/mysql-test/suite/rpl/r/rpl_delayed_parallel_slave_sbm.result b/mysql-test/suite/rpl/r/rpl_delayed_parallel_slave_sbm.result index f783b1e0783..b00a8a5e1d7 100644 --- a/mysql-test/suite/rpl/r/rpl_delayed_parallel_slave_sbm.result +++ b/mysql-test/suite/rpl/r/rpl_delayed_parallel_slave_sbm.result @@ -35,9 +35,19 @@ connection master; insert into t1 values (1); # Sleep 3 to create gap between events insert into t1 values (2); +include/save_master_pos.inc connection slave; LOCK TABLES t1 WRITE; +SET @@global.debug_dbug="+d,pause_sql_thread_on_next_event"; START SLAVE IO_THREAD; +# Before we start processing the events, we ensure both transactions +# were written into the relay log. Otherwise, if the IO thread takes too +# long to queue the events, the sql thread can think it has caught up +# too quickly. +SET DEBUG_SYNC='now WAIT_FOR paused_on_event'; +include/sync_io_with_master.inc +SET @@global.debug_dbug="-d,pause_sql_thread_on_next_event"; +SET DEBUG_SYNC='now SIGNAL sql_thread_continue'; # Wait for first transaction to complete SQL delay and begin execution.. # Validate SBM calculation doesn't use the second transaction because SQL thread shouldn't have gone idle.. # ..and that SBM wasn't calculated using prior committed transactions @@ -50,6 +60,8 @@ UNLOCK TABLES; include/stop_slave.inc CHANGE MASTER TO master_delay=0; set @@GLOBAL.slave_parallel_threads=4; +SET @@global.debug_dbug=""; +SET DEBUG_SYNC='RESET'; include/start_slave.inc connection master; DROP TABLE t1; diff --git a/mysql-test/suite/rpl/t/rpl_delayed_parallel_slave_sbm.test b/mysql-test/suite/rpl/t/rpl_delayed_parallel_slave_sbm.test index 4bcb7ad9e3f..1ac1bc14468 100644 --- a/mysql-test/suite/rpl/t/rpl_delayed_parallel_slave_sbm.test +++ b/mysql-test/suite/rpl/t/rpl_delayed_parallel_slave_sbm.test @@ -12,9 +12,12 @@ # --source include/master-slave.inc +--source include/have_debug.inc +--source include/have_debug_sync.inc --connection slave --source include/stop_slave.inc +--let $old_debug_dbug= `SELECT @@global.debug_dbug` --let $master_delay= 3 --eval change master to master_delay=$master_delay, master_use_gtid=Slave_Pos --let $old_slave_threads= `SELECT @@GLOBAL.slave_parallel_threads` @@ -82,12 +85,24 @@ sleep 3; --eval insert into t1 values ($insert_ctr) --inc $insert_ctr --let $ts_trx_after_ins= `SELECT UNIX_TIMESTAMP()` +--source include/save_master_pos.inc --connection slave LOCK TABLES t1 WRITE; +SET @@global.debug_dbug="+d,pause_sql_thread_on_next_event"; + START SLAVE IO_THREAD; +--echo # Before we start processing the events, we ensure both transactions +--echo # were written into the relay log. Otherwise, if the IO thread takes too +--echo # long to queue the events, the sql thread can think it has caught up +--echo # too quickly. +SET DEBUG_SYNC='now WAIT_FOR paused_on_event'; +--source include/sync_io_with_master.inc +SET @@global.debug_dbug="-d,pause_sql_thread_on_next_event"; +SET DEBUG_SYNC='now SIGNAL sql_thread_continue'; + --echo # Wait for first transaction to complete SQL delay and begin execution.. --let $wait_condition= SELECT count(*) FROM information_schema.processlist WHERE state LIKE 'Waiting for table metadata lock%' AND command LIKE 'Slave_Worker'; --source include/wait_condition.inc @@ -120,6 +135,8 @@ UNLOCK TABLES; --source include/stop_slave.inc --eval CHANGE MASTER TO master_delay=0 --eval set @@GLOBAL.slave_parallel_threads=$old_slave_threads +--eval SET @@global.debug_dbug="$old_debug_dbug" +SET DEBUG_SYNC='RESET'; --source include/start_slave.inc --connection master diff --git a/sql/slave.cc b/sql/slave.cc index c788a206435..42c293dfce4 100644 --- a/sql/slave.cc +++ b/sql/slave.cc @@ -4135,6 +4135,21 @@ static int exec_relay_log_event(THD* thd, Relay_log_info* rli, int exec_res; Log_event_type typ= ev->get_type_code(); + DBUG_EXECUTE_IF( + "pause_sql_thread_on_next_event", + { + /* + Temporarily unlock data_lock so we can check-in with the IO thread + */ + mysql_mutex_unlock(&rli->data_lock); + DBUG_ASSERT(!debug_sync_set_action( + thd, + STRING_WITH_LEN( + "now SIGNAL paused_on_event WAIT_FOR sql_thread_continue"))); + DBUG_SET("-d,pause_sql_thread_on_next_event"); + mysql_mutex_lock(&rli->data_lock); + }); + /* Even if we don't execute this event, we keep the master timestamp, so that seconds behind master shows correct delta (there are events -- cgit v1.2.1 From cacea31687c098c0348deb1e433f4baddd817419 Mon Sep 17 00:00:00 2001 From: Daniel Black Date: Thu, 9 Feb 2023 12:49:17 +1100 Subject: =?UTF-8?q?MDEV-30621:=20T=C3=BCrkiye=20is=20the=20correct=20curre?= =?UTF-8?q?nt=20country=20naming?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit As requested to the UN the country formerly known as Turkey is to be refered to as Türkiye. Reviewer: Alexander Barkov --- mysql-test/suite/plugins/r/locales.result | 5 +++-- mysql-test/suite/plugins/t/locales.test | 1 + sql/sql_locale.cc | 4 ++-- 3 files changed, 6 insertions(+), 4 deletions(-) diff --git a/mysql-test/suite/plugins/r/locales.result b/mysql-test/suite/plugins/r/locales.result index 2ea88493705..e906d27c21e 100644 --- a/mysql-test/suite/plugins/r/locales.result +++ b/mysql-test/suite/plugins/r/locales.result @@ -1,3 +1,4 @@ +SET names utf8; select * from information_schema.locales; ID NAME DESCRIPTION MAX_MONTH_NAME_LENGTH MAX_DAY_NAME_LENGTH DECIMAL_POINT THOUSAND_SEP ERROR_MESSAGE_LANGUAGE 0 en_US English - United States 9 9 . , english @@ -52,7 +53,7 @@ ID NAME DESCRIPTION MAX_MONTH_NAME_LENGTH MAX_DAY_NAME_LENGTH DECIMAL_POINT THOU 49 ta_IN Tamil - India 10 8 . , english 50 te_IN Telugu - India 10 9 . , english 51 th_TH Thai - Thailand 10 8 . , english -52 tr_TR Turkish - Turkey 7 9 , . english +52 tr_TR Turkish - Türkiye 7 9 , . english 53 uk_UA Ukrainian - Ukraine 8 9 , . ukrainian 54 ur_PK Urdu - Pakistan 6 6 . , english 55 vi_VN Vietnamese - Vietnam 16 11 , . english @@ -165,7 +166,7 @@ Id Name Description Error_Message_Language 49 ta_IN Tamil - India english 50 te_IN Telugu - India english 51 th_TH Thai - Thailand english -52 tr_TR Turkish - Turkey english +52 tr_TR Turkish - Türkiye english 53 uk_UA Ukrainian - Ukraine ukrainian 54 ur_PK Urdu - Pakistan english 55 vi_VN Vietnamese - Vietnam english diff --git a/mysql-test/suite/plugins/t/locales.test b/mysql-test/suite/plugins/t/locales.test index a3afe75046f..2b4d56433d9 100644 --- a/mysql-test/suite/plugins/t/locales.test +++ b/mysql-test/suite/plugins/t/locales.test @@ -2,6 +2,7 @@ if (`select count(*) = 0 from information_schema.plugins where plugin_name = 'lo { --skip LOCALES plugin is not active } +SET names utf8; select * from information_schema.locales; show locales; diff --git a/sql/sql_locale.cc b/sql/sql_locale.cc index fb7fa26f245..dd19807dd6d 100644 --- a/sql/sql_locale.cc +++ b/sql/sql_locale.cc @@ -1919,7 +1919,7 @@ MY_LOCALE my_locale_th_TH ); /***** LOCALE END th_TH *****/ -/***** LOCALE BEGIN tr_TR: Turkish - Turkey *****/ +/***** LOCALE BEGIN tr_TR: Turkish - Türkiye *****/ static const char *my_locale_month_names_tr_TR[13] = {"Ocak","Şubat","Mart","Nisan","Mayıs","Haziran","Temmuz","Ağustos","Eylül","Ekim","Kasım","Aralık", NullS }; static const char *my_locale_ab_month_names_tr_TR[13] = @@ -1940,7 +1940,7 @@ MY_LOCALE my_locale_tr_TR ( 52, "tr_TR", - "Turkish - Turkey", + "Turkish - Türkiye", FALSE, &my_locale_typelib_month_names_tr_TR, &my_locale_typelib_ab_month_names_tr_TR, -- cgit v1.2.1 From c7fba948e133b20ca2e24aa30e59e80ae190bc45 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vicen=C8=9Biu=20Ciorbaru?= Date: Fri, 10 Feb 2023 14:44:45 +0200 Subject: Fix RPL tests post DEBUG_SYNC change The tests expect the SIGNAL to not be cleared. Thus set NO_CLEAR_EVENT within DBUG_EXECUTE_IF --- mysql-test/suite/rpl/disabled.def | 11 ----------- sql/sql_table.cc | 4 ++-- 2 files changed, 2 insertions(+), 13 deletions(-) diff --git a/mysql-test/suite/rpl/disabled.def b/mysql-test/suite/rpl/disabled.def index 860afb147c8..57907210693 100644 --- a/mysql-test/suite/rpl/disabled.def +++ b/mysql-test/suite/rpl/disabled.def @@ -15,14 +15,3 @@ rpl_row_binlog_max_cache_size : MDEV-11092 rpl_row_index_choice : MDEV-11666 rpl_auto_increment_update_failure : disabled for now rpl_current_user : waits for MDEV-22374 fix -rpl_start_alter_1 : DEBUG_SYNC timeout -rpl_start_alter_2 : DEBUG_SYNC timeout -rpl_start_alter_3 : DEBUG_SYNC timeout -rpl_start_alter_4 : DEBUG_SYNC timeout -rpl_start_alter_5 : DEBUG_SYNC timeout -rpl_start_alter_6 : DEBUG_SYNC timeout -rpl_start_alter_7 : DEBUG_SYNC timeout -rpl_start_alter_8 : DEBUG_SYNC timeout -rpl_start_alter_mysqlbinlog_1 : DEBUG_SYNC timeout -rpl_start_alter_mysqlbinlog_2 : DEBUG_SYNC timeout -rpl_start_alter_restart_slave : DEBUG_SYNC timeout diff --git a/sql/sql_table.cc b/sql/sql_table.cc index 529b0461f92..acd15d3f911 100644 --- a/sql/sql_table.cc +++ b/sql/sql_table.cc @@ -7675,7 +7675,7 @@ static bool mysql_inplace_alter_table(THD *thd, THD_STAGE_INFO(thd, stage_alter_inplace); DBUG_EXECUTE_IF("start_alter_delay_master", { debug_sync_set_action(thd, - STRING_WITH_LEN("now wait_for alter_cont")); + STRING_WITH_LEN("now wait_for alter_cont NO_CLEAR_EVENT")); }); /* We can abort alter table for any table type */ @@ -10856,7 +10856,7 @@ do_continue:; DBUG_EXECUTE_IF("start_alter_delay_master", { debug_sync_set_action(thd, - STRING_WITH_LEN("now wait_for alter_cont")); + STRING_WITH_LEN("now wait_for alter_cont NO_CLEAR_EVENT")); }); // It's now safe to take the table level lock. if (lock_tables(thd, table_list, alter_ctx.tables_opened, -- cgit v1.2.1 From 7aace5d5da8b80d5e7c0e798f8c80934b7410752 Mon Sep 17 00:00:00 2001 From: asklavou Date: Fri, 28 Oct 2022 11:14:44 +0100 Subject: MDEV-28839: remove current_pos where not intentionally being tested Task: ===== Update tests to reflect MDEV-20122, deprecation of master_use_gtid=current_pos. Change Master (CM) statements were either removed or modified with current_pos --> slave_pos based on original intention of the test. Reviewed by: ============ Brandon Nesterenko --- mysql-test/suite/multi_source/gtid.result | 12 +++------ mysql-test/suite/multi_source/gtid.test | 6 ++--- .../r/rpl_binlog_dump_slave_gtid_state_info.result | 4 +-- mysql-test/suite/rpl/r/rpl_gtid_crash.result | 4 +-- .../rpl/r/rpl_gtid_excess_initial_delay.result | 6 ++--- .../suite/rpl/r/rpl_gtid_master_promote.result | 18 +------------ mysql-test/suite/rpl/r/rpl_gtid_mdev4473.result | 18 +++---------- mysql-test/suite/rpl/r/rpl_gtid_misc.result | 3 --- mysql-test/suite/rpl/r/rpl_gtid_nobinlog.result | 11 ++------ mysql-test/suite/rpl/r/rpl_gtid_reconnect.result | 6 ----- mysql-test/suite/rpl/r/rpl_gtid_sort.result | 4 +-- mysql-test/suite/rpl/r/rpl_gtid_startpos.result | 30 +++++----------------- mysql-test/suite/rpl/r/rpl_gtid_stop_start.result | 3 --- mysql-test/suite/rpl/r/rpl_gtid_until.result | 12 +++------ mysql-test/suite/rpl/r/rpl_mdev6386.result | 3 --- .../suite/rpl/r/rpl_parallel_mdev6589.result | 3 --- .../suite/rpl/r/rpl_parallel_multilevel2.result | 6 ----- .../suite/rpl/r/rpl_parallel_temptable.result | 3 --- .../rpl/r/rpl_start_alter_mysqlbinlog_1.result | 3 --- .../suite/rpl/r/rpl_upgrade_master_info.result | 3 --- .../t/rpl_binlog_dump_slave_gtid_state_info.test | 4 +-- mysql-test/suite/rpl/t/rpl_gtid_crash.test | 2 +- .../suite/rpl/t/rpl_gtid_excess_initial_delay.test | 6 ++--- .../suite/rpl/t/rpl_gtid_master_promote.test | 6 +---- mysql-test/suite/rpl/t/rpl_gtid_mdev4473.test | 8 +++--- mysql-test/suite/rpl/t/rpl_gtid_misc.test | 1 - mysql-test/suite/rpl/t/rpl_gtid_nobinlog.test | 5 ++-- mysql-test/suite/rpl/t/rpl_gtid_reconnect.test | 5 ---- mysql-test/suite/rpl/t/rpl_gtid_sort.test | 2 +- mysql-test/suite/rpl/t/rpl_gtid_startpos.test | 10 ++++---- mysql-test/suite/rpl/t/rpl_gtid_stop_start.test | 1 - mysql-test/suite/rpl/t/rpl_gtid_until.test | 4 +-- mysql-test/suite/rpl/t/rpl_mdev6386.test | 1 - mysql-test/suite/rpl/t/rpl_parallel_mdev6589.test | 1 - .../suite/rpl/t/rpl_parallel_multilevel2.test | 2 -- mysql-test/suite/rpl/t/rpl_parallel_temptable.test | 1 - .../suite/rpl/t/rpl_start_alter_mysqlbinlog_1.test | 3 +-- .../suite/rpl/t/rpl_upgrade_master_info.test | 1 - 38 files changed, 50 insertions(+), 171 deletions(-) diff --git a/mysql-test/suite/multi_source/gtid.result b/mysql-test/suite/multi_source/gtid.result index dde53ca67b4..6530bb744ac 100644 --- a/mysql-test/suite/multi_source/gtid.result +++ b/mysql-test/suite/multi_source/gtid.result @@ -47,12 +47,8 @@ connection master2; INSERT INTO t2 VALUES (2, "switch1"); INSERT INTO t3 VALUES (202, "switch1 b"); connection slave2; -CHANGE MASTER 'slave1' TO master_port=MYPORT_1, master_host='127.0.0.1', master_user='root', master_use_gtid=current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead -CHANGE MASTER 'slave2' TO master_port=MYPORT_2, master_host='127.0.0.1', master_user='root', master_use_gtid=current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead +CHANGE MASTER 'slave1' TO master_port=MYPORT_1, master_host='127.0.0.1', master_user='root'; +CHANGE MASTER 'slave2' TO master_port=MYPORT_2, master_host='127.0.0.1', master_user='root'; SET default_master_connection = 'slave1'; START SLAVE; include/wait_for_slave_to_start.inc @@ -79,9 +75,7 @@ INSERT INTO t3 VALUES (204, "switch 3 b"); connection slave2; include/sync_with_master_gtid.inc connection slave1; -CHANGE MASTER TO master_port=MYPORT_4, master_host='127.0.0.1', master_user='root', master_use_gtid=current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead +CHANGE MASTER TO master_port=MYPORT_4, master_host='127.0.0.1', master_user='root'; START SLAVE; SELECT * FROM t1 ORDER BY a; a b diff --git a/mysql-test/suite/multi_source/gtid.test b/mysql-test/suite/multi_source/gtid.test index c81ca20a254..9fc7a66893c 100644 --- a/mysql-test/suite/multi_source/gtid.test +++ b/mysql-test/suite/multi_source/gtid.test @@ -73,9 +73,9 @@ INSERT INTO t3 VALUES (202, "switch1 b"); --connection slave2 --replace_result $SERVER_MYPORT_1 MYPORT_1 -eval CHANGE MASTER 'slave1' TO master_port=$SERVER_MYPORT_1, master_host='127.0.0.1', master_user='root', master_use_gtid=current_pos; +eval CHANGE MASTER 'slave1' TO master_port=$SERVER_MYPORT_1, master_host='127.0.0.1', master_user='root'; --replace_result $SERVER_MYPORT_2 MYPORT_2 -eval CHANGE MASTER 'slave2' TO master_port=$SERVER_MYPORT_2, master_host='127.0.0.1', master_user='root', master_use_gtid=current_pos; +eval CHANGE MASTER 'slave2' TO master_port=$SERVER_MYPORT_2, master_host='127.0.0.1', master_user='root'; SET default_master_connection = 'slave1'; START SLAVE; --source include/wait_for_slave_to_start.inc @@ -125,7 +125,7 @@ INSERT INTO t3 VALUES (204, "switch 3 b"); --connection slave1 --replace_result $SERVER_MYPORT_4 MYPORT_4 -eval CHANGE MASTER TO master_port=$SERVER_MYPORT_4, master_host='127.0.0.1', master_user='root', master_use_gtid=current_pos; +eval CHANGE MASTER TO master_port=$SERVER_MYPORT_4, master_host='127.0.0.1', master_user='root'; START SLAVE; --let $wait_condition= SELECT (SELECT COUNT(*) FROM t1)=3 AND (SELECT COUNT(*) FROM t2)=4 AND (SELECT COUNT(*) FROM t3)=7 --source include/wait_condition.inc diff --git a/mysql-test/suite/rpl/r/rpl_binlog_dump_slave_gtid_state_info.result b/mysql-test/suite/rpl/r/rpl_binlog_dump_slave_gtid_state_info.result index 96b14bc1d9c..b913a49b509 100644 --- a/mysql-test/suite/rpl/r/rpl_binlog_dump_slave_gtid_state_info.result +++ b/mysql-test/suite/rpl/r/rpl_binlog_dump_slave_gtid_state_info.result @@ -4,9 +4,7 @@ connection master; SET GLOBAL LOG_WARNINGS=2; connection slave; include/stop_slave.inc -CHANGE MASTER TO MASTER_USE_GTID=current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead +CHANGE MASTER TO MASTER_USE_GTID=slave_pos; include/start_slave.inc connection master; "Test Case 1: Start binlog_dump to slave_server(#), pos(master-bin.000001, ###), using_gtid(1), gtid('')" diff --git a/mysql-test/suite/rpl/r/rpl_gtid_crash.result b/mysql-test/suite/rpl/r/rpl_gtid_crash.result index fc8e69af861..2f764fe4a0d 100644 --- a/mysql-test/suite/rpl/r/rpl_gtid_crash.result +++ b/mysql-test/suite/rpl/r/rpl_gtid_crash.result @@ -14,9 +14,7 @@ call mtr.add_suppression('Master command COM_REGISTER_SLAVE failed: failed regis SET sql_log_bin=1; include/stop_slave.inc CHANGE MASTER TO master_host = '127.0.0.1', master_port = MASTER_PORT, -MASTER_USE_GTID=CURRENT_POS; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead +MASTER_USE_GTID=SLAVE_POS; connection server_1; INSERT INTO t1 VALUES (2,1); INSERT INTO t1 VALUES (3,1); diff --git a/mysql-test/suite/rpl/r/rpl_gtid_excess_initial_delay.result b/mysql-test/suite/rpl/r/rpl_gtid_excess_initial_delay.result index 302bf182ac2..4b2652ece8f 100644 --- a/mysql-test/suite/rpl/r/rpl_gtid_excess_initial_delay.result +++ b/mysql-test/suite/rpl/r/rpl_gtid_excess_initial_delay.result @@ -3,9 +3,7 @@ include/master-slave.inc CREATE TABLE t1 (i INT); connection slave; include/stop_slave.inc -CHANGE MASTER TO MASTER_USE_GTID= current_pos, MASTER_DELAY= 10; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead +CHANGE MASTER TO MASTER_DELAY= 10; include/start_slave.inc connection master; INSERT INTO t1 VALUES (1); @@ -16,7 +14,7 @@ connection slave; # Asserted this: One row shoule be found in table t1. "======= Clean up ========" STOP SLAVE; -CHANGE MASTER TO MASTER_USE_GTID=no, MASTER_DELAY=0; +CHANGE MASTER TO MASTER_DELAY=0; START SLAVE; connection master; DROP TABLE t1; diff --git a/mysql-test/suite/rpl/r/rpl_gtid_master_promote.result b/mysql-test/suite/rpl/r/rpl_gtid_master_promote.result index 19229a3c6c2..92430be199a 100644 --- a/mysql-test/suite/rpl/r/rpl_gtid_master_promote.result +++ b/mysql-test/suite/rpl/r/rpl_gtid_master_promote.result @@ -12,24 +12,12 @@ RETURN s; END| connection server_2; include/stop_slave.inc -CHANGE MASTER TO master_use_gtid=current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead connection server_3; include/stop_slave.inc -CHANGE MASTER TO master_use_gtid=current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead connection server_4; include/stop_slave.inc -CHANGE MASTER TO master_use_gtid=current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead connection server_5; include/stop_slave.inc -CHANGE MASTER TO master_use_gtid=current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead connection server_1; SET gtid_domain_id= 1; CREATE TABLE t1 (a INT PRIMARY KEY) ENGINE=InnoDB; @@ -347,9 +335,7 @@ a b *** Now let the old master join up as slave. *** connection server_1; CHANGE MASTER TO master_host = '127.0.0.1', master_port = SERVER_MYPORT_2, -master_user = "root", master_use_gtid = current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead +master_user = "root", master_use_gtid = slave_pos, master_demote_to_slave=1; include/start_slave.inc SELECT * FROM t1 ORDER BY a; a @@ -387,8 +373,6 @@ a b connection server_1; include/stop_slave.inc RESET SLAVE ALL; -Warnings: -Note 4190 RESET SLAVE is implicitly changing the value of 'Using_Gtid' from 'Current_Pos' to 'Slave_Pos' connection server_2; CHANGE MASTER TO master_host = '127.0.0.1', master_port = SERVER_MYPORT_1; include/start_slave.inc diff --git a/mysql-test/suite/rpl/r/rpl_gtid_mdev4473.result b/mysql-test/suite/rpl/r/rpl_gtid_mdev4473.result index e61df488d62..9524dafb524 100644 --- a/mysql-test/suite/rpl/r/rpl_gtid_mdev4473.result +++ b/mysql-test/suite/rpl/r/rpl_gtid_mdev4473.result @@ -12,9 +12,7 @@ include/wait_for_slave_to_stop.inc reset slave all; connection server_1; CHANGE MASTER TO master_host = '127.0.0.1', master_port = SERVER_MYPORT_2, -master_user='root', MASTER_USE_GTID=CURRENT_POS; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead +master_user='root', MASTER_USE_GTID=SLAVE_POS, master_demote_to_slave=1; include/start_slave.inc include/wait_for_slave_to_start.inc connection server_2; @@ -24,9 +22,7 @@ insert into t1 values (4); flush logs; connection server_3; CHANGE MASTER TO master_host = '127.0.0.1', master_port = SERVER_MYPORT_2, -MASTER_USE_GTID=CURRENT_POS; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead +MASTER_USE_GTID=SLAVE_POS; include/start_slave.inc select * from t1 order by n; n @@ -57,20 +53,14 @@ connection server_1; include/stop_slave.inc include/wait_for_slave_to_stop.inc reset slave all; -Warnings: -Note 4190 RESET SLAVE is implicitly changing the value of 'Using_Gtid' from 'Current_Pos' to 'Slave_Pos' connection server_2; CHANGE MASTER TO master_host = '127.0.0.1', master_port = SERVER_MYPORT_1, -master_user = 'root', MASTER_USE_GTID=CURRENT_POS; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead +master_user = 'root', MASTER_USE_GTID=SLAVE_POS, master_demote_to_slave=1; include/start_slave.inc connection server_3; include/stop_slave.inc CHANGE MASTER TO master_host = '127.0.0.1', master_port = SERVER_MYPORT_1, -MASTER_USE_GTID=CURRENT_POS; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead +MASTER_USE_GTID=SLAVE_POS; include/start_slave.inc connection server_1; drop table t1; diff --git a/mysql-test/suite/rpl/r/rpl_gtid_misc.result b/mysql-test/suite/rpl/r/rpl_gtid_misc.result index ad77aa2350e..c4a64a13753 100644 --- a/mysql-test/suite/rpl/r/rpl_gtid_misc.result +++ b/mysql-test/suite/rpl/r/rpl_gtid_misc.result @@ -9,9 +9,6 @@ include/stop_slave.inc SET sql_log_bin= 0; INSERT INTO t1 VALUES (1); SET sql_log_bin= 1; -CHANGE MASTER TO master_use_gtid= current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead connection master; CREATE TEMPORARY TABLE t2 LIKE t1; INSERT INTO t2 VALUE (1); diff --git a/mysql-test/suite/rpl/r/rpl_gtid_nobinlog.result b/mysql-test/suite/rpl/r/rpl_gtid_nobinlog.result index de5f30696fe..8b896560d39 100644 --- a/mysql-test/suite/rpl/r/rpl_gtid_nobinlog.result +++ b/mysql-test/suite/rpl/r/rpl_gtid_nobinlog.result @@ -21,9 +21,7 @@ a b include/stop_slave.inc connection server_1; CHANGE MASTER TO master_host = '127.0.0.1', master_port = SLAVE_PORT, -master_user = 'root', master_use_gtid = current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead +master_user = 'root'; START SLAVE; include/wait_for_slave_to_start.inc connection server_2; @@ -48,16 +46,11 @@ a b 4 2 include/stop_slave.inc RESET SLAVE; -Warnings: -Note 4190 RESET SLAVE is implicitly changing the value of 'Using_Gtid' from 'Current_Pos' to 'Slave_Pos' INSERT INTO t1 VALUES (5, 1); INSERT INTO t1 VALUES (6, 1); include/save_master_gtid.inc connection server_2; -CHANGE MASTER TO master_host = '127.0.0.1', master_port = MASTER_PORT, -master_use_gtid = current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead +CHANGE MASTER TO master_host = '127.0.0.1', master_port = MASTER_PORT; START SLAVE; include/sync_with_master_gtid.inc SELECT * FROM t1 ORDER BY a; diff --git a/mysql-test/suite/rpl/r/rpl_gtid_reconnect.result b/mysql-test/suite/rpl/r/rpl_gtid_reconnect.result index 6282e116733..f9d6cd3b743 100644 --- a/mysql-test/suite/rpl/r/rpl_gtid_reconnect.result +++ b/mysql-test/suite/rpl/r/rpl_gtid_reconnect.result @@ -1,10 +1,4 @@ include/rpl_init.inc [topology=1->2] -connection server_2; -include/stop_slave.inc -CHANGE MASTER TO master_use_gtid= current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead -include/start_slave.inc connection server_1; CREATE TABLE t1 (a INT); FLUSH LOGS; diff --git a/mysql-test/suite/rpl/r/rpl_gtid_sort.result b/mysql-test/suite/rpl/r/rpl_gtid_sort.result index bb1fb28e0e9..46a65e7d865 100644 --- a/mysql-test/suite/rpl/r/rpl_gtid_sort.result +++ b/mysql-test/suite/rpl/r/rpl_gtid_sort.result @@ -58,9 +58,7 @@ SHOW VARIABLES LIKE 'gtid_binlog_state'; Variable_name Value gtid_binlog_state CHANGE MASTER TO master_host = '127.0.0.1', master_port = MASTER_PORT, -MASTER_USE_GTID=CURRENT_POS; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead +MASTER_USE_GTID=SLAVE_POS; include/start_slave.inc SHOW VARIABLES LIKE 'gtid_binlog_pos'; Variable_name Value diff --git a/mysql-test/suite/rpl/r/rpl_gtid_startpos.result b/mysql-test/suite/rpl/r/rpl_gtid_startpos.result index 846854f8668..e38eddcc97a 100644 --- a/mysql-test/suite/rpl/r/rpl_gtid_startpos.result +++ b/mysql-test/suite/rpl/r/rpl_gtid_startpos.result @@ -11,9 +11,7 @@ CREATE TABLE t1 (a INT PRIMARY KEY) ENGINE=InnoDB; connection server_2; SET GLOBAL gtid_slave_pos=""; CHANGE MASTER TO master_host = '127.0.0.1', master_port = MASTER_PORT, -MASTER_USE_GTID=CURRENT_POS; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead +MASTER_USE_GTID=SLAVE_POS; include/start_slave.inc SELECT * FROM t1; a @@ -35,9 +33,7 @@ master-bin.000003 # connection server_2; SET GLOBAL gtid_slave_pos=""; CHANGE MASTER TO master_host = '127.0.0.1', master_port = MASTER_PORT, -MASTER_USE_GTID=CURRENT_POS; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead +MASTER_USE_GTID=SLAVE_POS; START SLAVE; include/wait_for_slave_io_error.inc [errno=1236] include/stop_slave.inc @@ -59,9 +55,7 @@ include/save_master_gtid.inc connection server_2; SET GLOBAL gtid_slave_pos='0-1-3'; CHANGE MASTER TO master_host = '127.0.0.1', master_port = MASTER_PORT, -MASTER_USE_GTID=CURRENT_POS; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead +MASTER_USE_GTID=SLAVE_POS; include/start_slave.inc include/sync_with_master_gtid.inc SELECT * FROM t1 ORDER by a; @@ -96,16 +90,12 @@ connection server_2; connection server_2; include/stop_slave.inc RESET SLAVE ALL; -Warnings: -Note 4190 RESET SLAVE is implicitly changing the value of 'Using_Gtid' from 'Current_Pos' to 'Slave_Pos' RESET MASTER; connection server_1; RESET MASTER; connection server_2; SET GLOBAL gtid_slave_pos=''; -CHANGE MASTER TO master_host='127.0.0.1', master_port=MASTER_PORT, master_user='root', master_use_gtid=current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead +CHANGE MASTER TO master_host='127.0.0.1', master_port=MASTER_PORT, master_user='root', master_use_gtid=slave_pos; include/start_slave.inc connection server_1; CREATE TABLE t1 (a INT PRIMARY KEY); @@ -129,8 +119,6 @@ connection server_2; include/stop_slave.inc DROP TABLE t1; RESET SLAVE; -Warnings: -Note 4190 RESET SLAVE is implicitly changing the value of 'Using_Gtid' from 'Current_Pos' to 'Slave_Pos' SET GLOBAL gtid_slave_pos=""; Warnings: Warning 1948 Specified value for @@gtid_slave_pos contains no value for replication domain 0. This conflicts with the binary log which contains GTID 0-2-4. If MASTER_GTID_POS=CURRENT_POS is used, the binlog position will override the new value of @@gtid_slave_pos @@ -162,9 +150,7 @@ Using_Gtid = 'No' START SLAVE; include/wait_for_slave_sql_error.inc [errno=1050] STOP SLAVE IO_THREAD; -CHANGE MASTER TO MASTER_USE_GTID=CURRENT_POS; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead +CHANGE MASTER TO MASTER_USE_GTID=SLAVE_POS; include/start_slave.inc connection server_1; INSERT INTO t1 VALUES(3); @@ -223,9 +209,9 @@ include/sync_with_master_gtid.inc SELECT * FROM t1; a 10 -SELECT 'Current_Pos' AS Using_Gtid; +SELECT 'Slave_Pos' AS Using_Gtid; Using_Gtid -Current_Pos +Slave_Pos SELECT '0-1-2' AS Gtid_Slave_Pos; Gtid_Slave_Pos 0-1-2 @@ -252,8 +238,6 @@ connection server_2; include/stop_slave.inc DROP TABLE t1; RESET SLAVE ALL; -Warnings: -Note 4190 RESET SLAVE is implicitly changing the value of 'Using_Gtid' from 'Current_Pos' to 'Slave_Pos' CHANGE MASTER TO MASTER_USE_GTID=NO; RESET MASTER; SET GLOBAL gtid_slave_pos= ""; diff --git a/mysql-test/suite/rpl/r/rpl_gtid_stop_start.result b/mysql-test/suite/rpl/r/rpl_gtid_stop_start.result index 2bdfcb14123..ae0050c353a 100644 --- a/mysql-test/suite/rpl/r/rpl_gtid_stop_start.result +++ b/mysql-test/suite/rpl/r/rpl_gtid_stop_start.result @@ -7,9 +7,6 @@ connection server_2; include/stop_slave.inc Master_Log_File = 'master-bin.000001' Using_Gtid = 'Slave_Pos' -CHANGE MASTER TO master_use_gtid=current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead FLUSH LOGS; connection server_1; FLUSH LOGS; diff --git a/mysql-test/suite/rpl/r/rpl_gtid_until.result b/mysql-test/suite/rpl/r/rpl_gtid_until.result index 85b066608e5..029d2367e50 100644 --- a/mysql-test/suite/rpl/r/rpl_gtid_until.result +++ b/mysql-test/suite/rpl/r/rpl_gtid_until.result @@ -29,9 +29,7 @@ ERROR HY000: Slave is already running include/stop_slave_io.inc START SLAVE UNTIL master_gtid_pos = ""; ERROR HY000: START SLAVE UNTIL master_gtid_pos requires that slave is using GTID -CHANGE MASTER TO master_use_gtid=current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead +CHANGE MASTER TO master_use_gtid=slave_pos; connection server_1; CREATE TABLE t1 (a INT PRIMARY KEY) ENGINE=InnoDB; INSERT INTO t1 VALUES(1); @@ -60,7 +58,7 @@ a include/stop_slave.inc START SLAVE UNTIL master_gtid_pos = "1-10-100,2-20-200,0-1-300"; include/wait_for_slave_to_start.inc -Using_Gtid = 'Current_Pos' +Using_Gtid = 'Slave_Pos' Until_Condition = 'Gtid' connection server_1; INSERT INTO t1 VALUES (3); @@ -205,8 +203,6 @@ include/start_slave.inc connection server_2; include/stop_slave.inc RESET SLAVE ALL; -Warnings: -Note 4190 RESET SLAVE is implicitly changing the value of 'Using_Gtid' from 'Current_Pos' to 'Slave_Pos' RESET MASTER; SET GLOBAL gtid_slave_pos=''; connection server_1; @@ -219,9 +215,7 @@ RESET MASTER; INSERT INTO t1 VALUES (10); connection server_2; CHANGE MASTER TO master_host = '127.0.0.1', master_port = SERVER_MYPORT_1, -master_user = "root", master_use_gtid = current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead +master_user = "root", master_use_gtid = slave_pos; START SLAVE UNTIL master_gtid_pos = '0-1-2'; include/wait_for_slave_to_start.inc connection server_1; diff --git a/mysql-test/suite/rpl/r/rpl_mdev6386.result b/mysql-test/suite/rpl/r/rpl_mdev6386.result index d62543d8488..63ce594a604 100644 --- a/mysql-test/suite/rpl/r/rpl_mdev6386.result +++ b/mysql-test/suite/rpl/r/rpl_mdev6386.result @@ -10,9 +10,6 @@ SET sql_log_bin= 0; CALL mtr.add_suppression("Commit failed due to failure of an earlier commit on which this one depends"); INSERT INTO t1 VALUES (1, 2); SET sql_log_bin= 1; -CHANGE MASTER TO master_use_gtid= current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead Contents on slave before: SELECT * FROM t1 ORDER BY a; a b diff --git a/mysql-test/suite/rpl/r/rpl_parallel_mdev6589.result b/mysql-test/suite/rpl/r/rpl_parallel_mdev6589.result index ed297d10f2a..2e5ac97bf4d 100644 --- a/mysql-test/suite/rpl/r/rpl_parallel_mdev6589.result +++ b/mysql-test/suite/rpl/r/rpl_parallel_mdev6589.result @@ -4,9 +4,6 @@ connection server_2; SET @old_parallel_threads=@@GLOBAL.slave_parallel_threads; include/stop_slave.inc SET GLOBAL slave_parallel_threads=10; -CHANGE MASTER TO master_use_gtid=current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead include/start_slave.inc *** MDEV-6589: Incorrect relay log start position when restarting SQL thread after error in parallel replication *** connection server_1; diff --git a/mysql-test/suite/rpl/r/rpl_parallel_multilevel2.result b/mysql-test/suite/rpl/r/rpl_parallel_multilevel2.result index 13508815877..ba59650983b 100644 --- a/mysql-test/suite/rpl/r/rpl_parallel_multilevel2.result +++ b/mysql-test/suite/rpl/r/rpl_parallel_multilevel2.result @@ -17,16 +17,10 @@ SET GLOBAL binlog_commit_wait_usec=2000000; SET @old_updates= @@GLOBAL.binlog_direct_non_transactional_updates; SET GLOBAL binlog_direct_non_transactional_updates=OFF; SET SESSION binlog_direct_non_transactional_updates=OFF; -CHANGE MASTER TO master_use_gtid=current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead connection server_3; SET @old_parallel_threads=@@GLOBAL.slave_parallel_threads; include/stop_slave.inc SET GLOBAL slave_parallel_threads=10; -CHANGE MASTER TO master_use_gtid=current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead connection server_1; BEGIN; CREATE TEMPORARY TABLE t2 (a INT PRIMARY KEY) ENGINE=MEMORY; diff --git a/mysql-test/suite/rpl/r/rpl_parallel_temptable.result b/mysql-test/suite/rpl/r/rpl_parallel_temptable.result index 9519bffaa27..e9bff03bd41 100644 --- a/mysql-test/suite/rpl/r/rpl_parallel_temptable.result +++ b/mysql-test/suite/rpl/r/rpl_parallel_temptable.result @@ -4,9 +4,6 @@ connection server_2; SET @old_parallel_threads=@@GLOBAL.slave_parallel_threads; include/stop_slave.inc SET GLOBAL slave_parallel_threads=5; -CHANGE MASTER TO master_use_gtid= current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead include/start_slave.inc connection server_1; CREATE TABLE t1 (a INT PRIMARY KEY, b VARCHAR(100) CHARACTER SET utf8); diff --git a/mysql-test/suite/rpl/r/rpl_start_alter_mysqlbinlog_1.result b/mysql-test/suite/rpl/r/rpl_start_alter_mysqlbinlog_1.result index 2c3b694c45d..bf9d9be0ec6 100644 --- a/mysql-test/suite/rpl/r/rpl_start_alter_mysqlbinlog_1.result +++ b/mysql-test/suite/rpl/r/rpl_start_alter_mysqlbinlog_1.result @@ -4,9 +4,6 @@ connection master; set global binlog_alter_two_phase=true; connection slave; include/stop_slave.inc -change master to master_use_gtid= current_pos; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead set global gtid_strict_mode=1; # Legacy Master Slave connect master_node,127.0.0.1,root,,$db_name, $M_port; diff --git a/mysql-test/suite/rpl/r/rpl_upgrade_master_info.result b/mysql-test/suite/rpl/r/rpl_upgrade_master_info.result index e58ea5eb0f2..1babddf9a6e 100644 --- a/mysql-test/suite/rpl/r/rpl_upgrade_master_info.result +++ b/mysql-test/suite/rpl/r/rpl_upgrade_master_info.result @@ -3,9 +3,6 @@ include/master-slave.inc *** MDEV-9383: Server fails to read master.info after upgrade 10.0 -> 10.1 *** connection slave; include/stop_slave.inc -CHANGE MASTER TO master_use_gtid=CURRENT_POS; -Warnings: -Warning 1681 'master_use_gtid=current_pos' is deprecated and will be removed in a future release. Please use master_demote_to_slave=1 instead include/rpl_stop_server.inc [server_number=2] include/rpl_start_server.inc [server_number=2] connection master; diff --git a/mysql-test/suite/rpl/t/rpl_binlog_dump_slave_gtid_state_info.test b/mysql-test/suite/rpl/t/rpl_binlog_dump_slave_gtid_state_info.test index f26e9565671..bba41295d16 100644 --- a/mysql-test/suite/rpl/t/rpl_binlog_dump_slave_gtid_state_info.test +++ b/mysql-test/suite/rpl/t/rpl_binlog_dump_slave_gtid_state_info.test @@ -8,7 +8,7 @@ # Steps: # 0 - Have LOG_WARNINGS=2 # 1 - On a fresh slave server which has not replicated any GTIDs execute -# "CHANGE MASTER TO MASTER_USE_GTID=current_pos;" command. Start the +# "CHANGE MASTER TO MASTER_USE_GTID=slave_pos;" command. Start the # slave. # 2 - In Master error log verify that pattern "using_gtid(1), gtid('')" is # present. @@ -43,7 +43,7 @@ SET GLOBAL LOG_WARNINGS=2; --connection slave --source include/stop_slave.inc -CHANGE MASTER TO MASTER_USE_GTID=current_pos; +CHANGE MASTER TO MASTER_USE_GTID=slave_pos; --source include/start_slave.inc --connection master diff --git a/mysql-test/suite/rpl/t/rpl_gtid_crash.test b/mysql-test/suite/rpl/t/rpl_gtid_crash.test index d0af69a65ed..1249a0f619e 100644 --- a/mysql-test/suite/rpl/t/rpl_gtid_crash.test +++ b/mysql-test/suite/rpl/t/rpl_gtid_crash.test @@ -27,7 +27,7 @@ SET sql_log_bin=1; --source include/stop_slave.inc --replace_result $MASTER_MYPORT MASTER_PORT eval CHANGE MASTER TO master_host = '127.0.0.1', master_port = $MASTER_MYPORT, - MASTER_USE_GTID=CURRENT_POS; + MASTER_USE_GTID=SLAVE_POS; --connection server_1 INSERT INTO t1 VALUES (2,1); diff --git a/mysql-test/suite/rpl/t/rpl_gtid_excess_initial_delay.test b/mysql-test/suite/rpl/t/rpl_gtid_excess_initial_delay.test index d840b67e9e8..6b1eec1984b 100644 --- a/mysql-test/suite/rpl/t/rpl_gtid_excess_initial_delay.test +++ b/mysql-test/suite/rpl/t/rpl_gtid_excess_initial_delay.test @@ -7,7 +7,7 @@ # # Steps: # 0 - Stop the slave and execute CHANGE MASTER command with -# master_use_gtid= curren_pos and master_delay= 10 +# master_delay= 10 # 1 - On slave introduce a sleep of 15 seconds and check that the # Seconds_Behind_Master is within specified master_delay limit. It should # not be more that "10" seconds. @@ -23,7 +23,7 @@ CREATE TABLE t1 (i INT); --sync_slave_with_master --source include/stop_slave.inc -CHANGE MASTER TO MASTER_USE_GTID= current_pos, MASTER_DELAY= 10; +CHANGE MASTER TO MASTER_DELAY= 10; --source include/start_slave.inc --connection master @@ -47,7 +47,7 @@ INSERT INTO t1 VALUES (1); --echo "======= Clean up ========" STOP SLAVE; -CHANGE MASTER TO MASTER_USE_GTID=no, MASTER_DELAY=0; +CHANGE MASTER TO MASTER_DELAY=0; START SLAVE; --connection master diff --git a/mysql-test/suite/rpl/t/rpl_gtid_master_promote.test b/mysql-test/suite/rpl/t/rpl_gtid_master_promote.test index bd5343d7558..064c70b123d 100644 --- a/mysql-test/suite/rpl/t/rpl_gtid_master_promote.test +++ b/mysql-test/suite/rpl/t/rpl_gtid_master_promote.test @@ -31,22 +31,18 @@ delimiter ;| --connection server_2 --sync_with_master --source include/stop_slave.inc -CHANGE MASTER TO master_use_gtid=current_pos; --connection server_3 --sync_with_master --source include/stop_slave.inc -CHANGE MASTER TO master_use_gtid=current_pos; --connection server_4 --sync_with_master --source include/stop_slave.inc -CHANGE MASTER TO master_use_gtid=current_pos; --connection server_5 --sync_with_master --source include/stop_slave.inc -CHANGE MASTER TO master_use_gtid=current_pos; # Create three separate replication streams on master server_1. @@ -225,7 +221,7 @@ SELECT * FROM t4 ORDER BY a,b; --connection server_1 --replace_result $SERVER_MYPORT_2 SERVER_MYPORT_2 eval CHANGE MASTER TO master_host = '127.0.0.1', master_port = $SERVER_MYPORT_2, - master_user = "root", master_use_gtid = current_pos; + master_user = "root", master_use_gtid = slave_pos, master_demote_to_slave=1; --source include/start_slave.inc --sync_with_master SELECT * FROM t1 ORDER BY a; diff --git a/mysql-test/suite/rpl/t/rpl_gtid_mdev4473.test b/mysql-test/suite/rpl/t/rpl_gtid_mdev4473.test index 01259eb5765..f52e51c2413 100644 --- a/mysql-test/suite/rpl/t/rpl_gtid_mdev4473.test +++ b/mysql-test/suite/rpl/t/rpl_gtid_mdev4473.test @@ -24,7 +24,7 @@ reset slave all; connection server_1; --replace_result $SERVER_MYPORT_2 SERVER_MYPORT_2 eval CHANGE MASTER TO master_host = '127.0.0.1', master_port = $SERVER_MYPORT_2, - master_user='root', MASTER_USE_GTID=CURRENT_POS; + master_user='root', MASTER_USE_GTID=SLAVE_POS, master_demote_to_slave=1; source include/start_slave.inc; source include/wait_for_slave_to_start.inc; @@ -38,7 +38,7 @@ save_master_pos; connection server_3; --replace_result $SERVER_MYPORT_2 SERVER_MYPORT_2 eval CHANGE MASTER TO master_host = '127.0.0.1', master_port = $SERVER_MYPORT_2, - MASTER_USE_GTID=CURRENT_POS; + MASTER_USE_GTID=SLAVE_POS; source include/start_slave.inc; sync_with_master; @@ -56,14 +56,14 @@ reset slave all; connection server_2; --replace_result $SERVER_MYPORT_1 SERVER_MYPORT_1 eval CHANGE MASTER TO master_host = '127.0.0.1', master_port = $SERVER_MYPORT_1, - master_user = 'root', MASTER_USE_GTID=CURRENT_POS; + master_user = 'root', MASTER_USE_GTID=SLAVE_POS, master_demote_to_slave=1; source include/start_slave.inc; connection server_3; source include/stop_slave.inc; --replace_result $SERVER_MYPORT_1 SERVER_MYPORT_1 eval CHANGE MASTER TO master_host = '127.0.0.1', master_port = $SERVER_MYPORT_1, - MASTER_USE_GTID=CURRENT_POS; + MASTER_USE_GTID=SLAVE_POS; source include/start_slave.inc; connection server_1; diff --git a/mysql-test/suite/rpl/t/rpl_gtid_misc.test b/mysql-test/suite/rpl/t/rpl_gtid_misc.test index 66d98ec8025..a78b74714a5 100644 --- a/mysql-test/suite/rpl/t/rpl_gtid_misc.test +++ b/mysql-test/suite/rpl/t/rpl_gtid_misc.test @@ -13,7 +13,6 @@ CREATE TABLE t1 (a INT PRIMARY KEY); SET sql_log_bin= 0; INSERT INTO t1 VALUES (1); SET sql_log_bin= 1; -CHANGE MASTER TO master_use_gtid= current_pos; --connection master diff --git a/mysql-test/suite/rpl/t/rpl_gtid_nobinlog.test b/mysql-test/suite/rpl/t/rpl_gtid_nobinlog.test index a5caebf0276..e140f335963 100644 --- a/mysql-test/suite/rpl/t/rpl_gtid_nobinlog.test +++ b/mysql-test/suite/rpl/t/rpl_gtid_nobinlog.test @@ -25,7 +25,7 @@ SELECT * FROM t1 ORDER BY a; --connection server_1 --replace_result $SLAVE_MYPORT SLAVE_PORT eval CHANGE MASTER TO master_host = '127.0.0.1', master_port = $SLAVE_MYPORT, - master_user = 'root', master_use_gtid = current_pos; + master_user = 'root'; START SLAVE; --source include/wait_for_slave_to_start.inc @@ -49,8 +49,7 @@ INSERT INTO t1 VALUES (6, 1); --connection server_2 --replace_result $MASTER_MYPORT MASTER_PORT -eval CHANGE MASTER TO master_host = '127.0.0.1', master_port = $MASTER_MYPORT, - master_use_gtid = current_pos; +eval CHANGE MASTER TO master_host = '127.0.0.1', master_port = $MASTER_MYPORT; START SLAVE; --source include/sync_with_master_gtid.inc diff --git a/mysql-test/suite/rpl/t/rpl_gtid_reconnect.test b/mysql-test/suite/rpl/t/rpl_gtid_reconnect.test index bc28ebddf5e..1452d6b01f0 100644 --- a/mysql-test/suite/rpl/t/rpl_gtid_reconnect.test +++ b/mysql-test/suite/rpl/t/rpl_gtid_reconnect.test @@ -4,11 +4,6 @@ --source include/have_debug.inc ---connection server_2 ---source include/stop_slave.inc -CHANGE MASTER TO master_use_gtid= current_pos; ---source include/start_slave.inc - --connection server_1 CREATE TABLE t1 (a INT); FLUSH LOGS; diff --git a/mysql-test/suite/rpl/t/rpl_gtid_sort.test b/mysql-test/suite/rpl/t/rpl_gtid_sort.test index dc3b18aa897..c31ba877bbf 100644 --- a/mysql-test/suite/rpl/t/rpl_gtid_sort.test +++ b/mysql-test/suite/rpl/t/rpl_gtid_sort.test @@ -47,7 +47,7 @@ SHOW VARIABLES LIKE 'gtid_slave_pos'; SHOW VARIABLES LIKE 'gtid_binlog_state'; --replace_result $MASTER_MYPORT MASTER_PORT eval CHANGE MASTER TO master_host = '127.0.0.1', master_port = $MASTER_MYPORT, - MASTER_USE_GTID=CURRENT_POS; + MASTER_USE_GTID=SLAVE_POS; --source include/start_slave.inc --sync_with_master SHOW VARIABLES LIKE 'gtid_binlog_pos'; diff --git a/mysql-test/suite/rpl/t/rpl_gtid_startpos.test b/mysql-test/suite/rpl/t/rpl_gtid_startpos.test index a7c93ff7ed5..c7bcc1bb97e 100644 --- a/mysql-test/suite/rpl/t/rpl_gtid_startpos.test +++ b/mysql-test/suite/rpl/t/rpl_gtid_startpos.test @@ -19,7 +19,7 @@ CREATE TABLE t1 (a INT PRIMARY KEY) ENGINE=InnoDB; SET GLOBAL gtid_slave_pos=""; --replace_result $MASTER_MYPORT MASTER_PORT eval CHANGE MASTER TO master_host = '127.0.0.1', master_port = $MASTER_MYPORT, - MASTER_USE_GTID=CURRENT_POS; + MASTER_USE_GTID=SLAVE_POS; --source include/start_slave.inc --sync_with_master SELECT * FROM t1; @@ -46,7 +46,7 @@ INSERT INTO t1 VALUES (2); SET GLOBAL gtid_slave_pos=""; --replace_result $MASTER_MYPORT MASTER_PORT eval CHANGE MASTER TO master_host = '127.0.0.1', master_port = $MASTER_MYPORT, - MASTER_USE_GTID=CURRENT_POS; + MASTER_USE_GTID=SLAVE_POS; START SLAVE; --let $slave_io_errno= 1236 --source include/wait_for_slave_io_error.inc @@ -73,7 +73,7 @@ INSERT INTO t1 VALUES(3); SET GLOBAL gtid_slave_pos='0-1-3'; --replace_result $MASTER_MYPORT MASTER_PORT eval CHANGE MASTER TO master_host = '127.0.0.1', master_port = $MASTER_MYPORT, - MASTER_USE_GTID=CURRENT_POS; + MASTER_USE_GTID=SLAVE_POS; --source include/start_slave.inc --source include/sync_with_master_gtid.inc SELECT * FROM t1 ORDER by a; @@ -118,7 +118,7 @@ RESET MASTER; --connection server_2 SET GLOBAL gtid_slave_pos=''; --replace_result $MASTER_MYPORT MASTER_PORT -eval CHANGE MASTER TO master_host='127.0.0.1', master_port=$MASTER_MYPORT, master_user='root', master_use_gtid=current_pos; +eval CHANGE MASTER TO master_host='127.0.0.1', master_port=$MASTER_MYPORT, master_user='root', master_use_gtid=slave_pos; --source include/start_slave.inc --connection server_1 @@ -199,7 +199,7 @@ START SLAVE; # Going back to using GTID should fix things. STOP SLAVE IO_THREAD; -CHANGE MASTER TO MASTER_USE_GTID=CURRENT_POS; +CHANGE MASTER TO MASTER_USE_GTID=SLAVE_POS; --source include/start_slave.inc --connection server_1 diff --git a/mysql-test/suite/rpl/t/rpl_gtid_stop_start.test b/mysql-test/suite/rpl/t/rpl_gtid_stop_start.test index 2cf184a3401..7fb457f6d7f 100644 --- a/mysql-test/suite/rpl/t/rpl_gtid_stop_start.test +++ b/mysql-test/suite/rpl/t/rpl_gtid_stop_start.test @@ -21,7 +21,6 @@ INSERT INTO t1 VALUES (1); --let $status_items= Master_Log_File,Using_Gtid --source include/show_slave_status.inc -CHANGE MASTER TO master_use_gtid=current_pos; # Now try to restart the slave mysqld server without starting the slave first # threads after the CHANGE MASTER. diff --git a/mysql-test/suite/rpl/t/rpl_gtid_until.test b/mysql-test/suite/rpl/t/rpl_gtid_until.test index 49baf7e68e6..c89cea23e93 100644 --- a/mysql-test/suite/rpl/t/rpl_gtid_until.test +++ b/mysql-test/suite/rpl/t/rpl_gtid_until.test @@ -45,7 +45,7 @@ START SLAVE UNTIL master_gtid_pos = ""; --error ER_UNTIL_REQUIRES_USING_GTID START SLAVE UNTIL master_gtid_pos = ""; -CHANGE MASTER TO master_use_gtid=current_pos; +CHANGE MASTER TO master_use_gtid=slave_pos; --connection server_1 CREATE TABLE t1 (a INT PRIMARY KEY) ENGINE=InnoDB; @@ -224,7 +224,7 @@ INSERT INTO t1 VALUES (10); --connection server_2 --replace_result $SERVER_MYPORT_1 SERVER_MYPORT_1 eval CHANGE MASTER TO master_host = '127.0.0.1', master_port = $SERVER_MYPORT_1, - master_user = "root", master_use_gtid = current_pos; + master_user = "root", master_use_gtid = slave_pos; eval START SLAVE UNTIL master_gtid_pos = '$until_condition'; --source include/wait_for_slave_to_start.inc diff --git a/mysql-test/suite/rpl/t/rpl_mdev6386.test b/mysql-test/suite/rpl/t/rpl_mdev6386.test index e6fb72dc788..f969d656ffb 100644 --- a/mysql-test/suite/rpl/t/rpl_mdev6386.test +++ b/mysql-test/suite/rpl/t/rpl_mdev6386.test @@ -13,7 +13,6 @@ SET sql_log_bin= 0; CALL mtr.add_suppression("Commit failed due to failure of an earlier commit on which this one depends"); INSERT INTO t1 VALUES (1, 2); SET sql_log_bin= 1; -CHANGE MASTER TO master_use_gtid= current_pos; --echo Contents on slave before: SELECT * FROM t1 ORDER BY a; diff --git a/mysql-test/suite/rpl/t/rpl_parallel_mdev6589.test b/mysql-test/suite/rpl/t/rpl_parallel_mdev6589.test index 981c6216376..3a5af7bd4a9 100644 --- a/mysql-test/suite/rpl/t/rpl_parallel_mdev6589.test +++ b/mysql-test/suite/rpl/t/rpl_parallel_mdev6589.test @@ -7,7 +7,6 @@ SET @old_parallel_threads=@@GLOBAL.slave_parallel_threads; --source include/stop_slave.inc SET GLOBAL slave_parallel_threads=10; -CHANGE MASTER TO master_use_gtid=current_pos; --source include/start_slave.inc diff --git a/mysql-test/suite/rpl/t/rpl_parallel_multilevel2.test b/mysql-test/suite/rpl/t/rpl_parallel_multilevel2.test index 4125394ef80..da8a996f570 100644 --- a/mysql-test/suite/rpl/t/rpl_parallel_multilevel2.test +++ b/mysql-test/suite/rpl/t/rpl_parallel_multilevel2.test @@ -25,7 +25,6 @@ SET GLOBAL binlog_commit_wait_usec=2000000; SET @old_updates= @@GLOBAL.binlog_direct_non_transactional_updates; SET GLOBAL binlog_direct_non_transactional_updates=OFF; SET SESSION binlog_direct_non_transactional_updates=OFF; -CHANGE MASTER TO master_use_gtid=current_pos; --connection server_3 --sync_with_master @@ -33,7 +32,6 @@ CHANGE MASTER TO master_use_gtid=current_pos; SET @old_parallel_threads=@@GLOBAL.slave_parallel_threads; --source include/stop_slave.inc SET GLOBAL slave_parallel_threads=10; -CHANGE MASTER TO master_use_gtid=current_pos; --connection server_1 diff --git a/mysql-test/suite/rpl/t/rpl_parallel_temptable.test b/mysql-test/suite/rpl/t/rpl_parallel_temptable.test index edb854842e1..3684763dad7 100644 --- a/mysql-test/suite/rpl/t/rpl_parallel_temptable.test +++ b/mysql-test/suite/rpl/t/rpl_parallel_temptable.test @@ -12,7 +12,6 @@ SET @old_parallel_threads=@@GLOBAL.slave_parallel_threads; --source include/stop_slave.inc SET GLOBAL slave_parallel_threads=5; -CHANGE MASTER TO master_use_gtid= current_pos; --source include/start_slave.inc --connection server_1 diff --git a/mysql-test/suite/rpl/t/rpl_start_alter_mysqlbinlog_1.test b/mysql-test/suite/rpl/t/rpl_start_alter_mysqlbinlog_1.test index 5c78eb290c8..f655d3c10ba 100644 --- a/mysql-test/suite/rpl/t/rpl_start_alter_mysqlbinlog_1.test +++ b/mysql-test/suite/rpl/t/rpl_start_alter_mysqlbinlog_1.test @@ -1,6 +1,6 @@ # # Start Alter with binlog applied using mysqlbinlog -# single maser with only one domain id +# single master with only one domain id # --source include/have_innodb.inc --source include/have_debug.inc @@ -10,7 +10,6 @@ set global binlog_alter_two_phase=true; --connection slave --source include/stop_slave.inc -change master to master_use_gtid= current_pos; set global gtid_strict_mode=1; --echo # Legacy Master Slave diff --git a/mysql-test/suite/rpl/t/rpl_upgrade_master_info.test b/mysql-test/suite/rpl/t/rpl_upgrade_master_info.test index 42b375c4579..fb0e3cf48f7 100644 --- a/mysql-test/suite/rpl/t/rpl_upgrade_master_info.test +++ b/mysql-test/suite/rpl/t/rpl_upgrade_master_info.test @@ -4,7 +4,6 @@ --connection slave --source include/stop_slave.inc -CHANGE MASTER TO master_use_gtid=CURRENT_POS; --let $datadir= `SELECT @@datadir` --let $rpl_server_number= 2 -- cgit v1.2.1 From badf6de1715bbdddcaf8c1535747f94602aaa13f Mon Sep 17 00:00:00 2001 From: Weijun Huang Date: Sun, 12 Feb 2023 18:42:23 +0100 Subject: MDEV-30412: JSON_OBJECTAGG doesn't escape double quote in key --- mysql-test/main/func_json.result | 12 ++++++++++++ mysql-test/main/func_json.test | 8 ++++++++ sql/item_jsonfunc.cc | 2 +- 3 files changed, 21 insertions(+), 1 deletion(-) diff --git a/mysql-test/main/func_json.result b/mysql-test/main/func_json.result index 2a293fc72c7..b9df193d3bd 100644 --- a/mysql-test/main/func_json.result +++ b/mysql-test/main/func_json.result @@ -1623,5 +1623,17 @@ id doc {"$oid":"611c0a463b150154132f6636"} { "_id" : { "$oid" : "611c0a463b150154132f6636" }, "a" : [ { "a" : [ { "a" : [ { "a" : [ { "a" : [ { "a" : [ { "a" : [ { "a" : [ { "a" : [ { "a" : [ { "a" : [ { "a" : [ { "a" : [ { "a" : [ { "a" : [ { "a" : 1.0 } ] } ] } ] } ] } ] } ] } ] } ] } ] } ] } ] } ] } ] } ] } ] } DROP TABLE arrNestTest; # +# MDEV-30412 JSON_OBJECTAGG doesn't escape double quote in key +# +SELECT JSON_OBJECTAGG('"', 1); +JSON_OBJECTAGG('"', 1) +{"\"":1} +SELECT JSON_OBJECTAGG('\"', 1); +JSON_OBJECTAGG('\"', 1) +{"\"":1} +SELECT JSON_OBJECTAGG('\\', 1); +JSON_OBJECTAGG('\\', 1) +{"\\":1} +# # End of 10.5 tests # diff --git a/mysql-test/main/func_json.test b/mysql-test/main/func_json.test index 35645bcb226..0a5d1638717 100644 --- a/mysql-test/main/func_json.test +++ b/mysql-test/main/func_json.test @@ -1067,6 +1067,14 @@ INSERT INTO test.arrNestTest (doc) VALUES ('{ "_id" : { "$oid" : "611c0a463b1501 SELECT * FROM arrNestTest; DROP TABLE arrNestTest; +--echo # +--echo # MDEV-30412 JSON_OBJECTAGG doesn't escape double quote in key +--echo # + +SELECT JSON_OBJECTAGG('"', 1); +SELECT JSON_OBJECTAGG('\"', 1); +SELECT JSON_OBJECTAGG('\\', 1); + --echo # --echo # End of 10.5 tests --echo # diff --git a/sql/item_jsonfunc.cc b/sql/item_jsonfunc.cc index 9843b6d14b1..b85adeff05d 100644 --- a/sql/item_jsonfunc.cc +++ b/sql/item_jsonfunc.cc @@ -4060,7 +4060,7 @@ bool Item_func_json_objectagg::add() result.append(", "); result.append("\""); - result.append(*key); + st_append_escaped(&result,key); result.append("\":"); buf.length(0); -- cgit v1.2.1 From 3eea2e8e10b6d8f5280e40478dcaac8961b74de4 Mon Sep 17 00:00:00 2001 From: Thirunarayanan Balathandayuthapani Date: Tue, 14 Feb 2023 14:35:35 +0530 Subject: MDEV-30551 InnoDB recovery hangs when buffer pool ran out of memory - During non-last batch of multi-batch recovery, InnoDB holds log_sys.mutex and preallocates the block which may intiate page flush, which may initiate log flush, which requires log_sys.mutex to acquire again. This leads to assert failure. So InnoDB recovery should release log_sys.mutex before preallocating the block. --- mysql-test/suite/innodb/r/alter_copy.result | 2 +- mysql-test/suite/innodb/t/alter_copy.test | 2 +- storage/innobase/buf/buf0lru.cc | 9 ++++++++- storage/innobase/log/log0recv.cc | 18 ++++++++++++++++++ 4 files changed, 28 insertions(+), 3 deletions(-) diff --git a/mysql-test/suite/innodb/r/alter_copy.result b/mysql-test/suite/innodb/r/alter_copy.result index 4d6d55f01cf..22916598083 100644 --- a/mysql-test/suite/innodb/r/alter_copy.result +++ b/mysql-test/suite/innodb/r/alter_copy.result @@ -51,7 +51,7 @@ ADD INDEX(a,b,d), ADD INDEX(a,d,b), ADD INDEX(b,c,d), ADD INDEX(b,d,c), ALGORITHM=COPY; connection default; SET DEBUG_SYNC='now WAIT_FOR hung'; -# restart: --innodb-force-recovery=3 +# restart: --innodb-force-recovery=3 --debug_dbug=+d,recv_ran_out_of_buffer disconnect hang; #sql-alter.frm #sql-alter.ibd diff --git a/mysql-test/suite/innodb/t/alter_copy.test b/mysql-test/suite/innodb/t/alter_copy.test index e67f6f9a66b..f321308ce26 100644 --- a/mysql-test/suite/innodb/t/alter_copy.test +++ b/mysql-test/suite/innodb/t/alter_copy.test @@ -57,7 +57,7 @@ ALTER TABLE t ADD INDEX(b,c,d,a),ADD INDEX(b,c,a,d),ADD INDEX(b,a,c,d),ADD INDEX connection default; SET DEBUG_SYNC='now WAIT_FOR hung'; let $shutdown_timeout=0; ---let $restart_parameters= --innodb-force-recovery=3 +--let $restart_parameters= --innodb-force-recovery=3 --debug_dbug="+d,recv_ran_out_of_buffer" --source include/restart_mysqld.inc disconnect hang; let $shutdown_timeout=; diff --git a/storage/innobase/buf/buf0lru.cc b/storage/innobase/buf/buf0lru.cc index f7a3543c493..6d83d448bd6 100644 --- a/storage/innobase/buf/buf0lru.cc +++ b/storage/innobase/buf/buf0lru.cc @@ -408,6 +408,11 @@ buf_block_t *buf_LRU_get_free_block(bool have_mutex) mysql_mutex_assert_owner(&buf_pool.mutex); goto got_mutex; } + DBUG_EXECUTE_IF("recv_ran_out_of_buffer", + if (recv_recovery_is_on() + && recv_sys.apply_log_recs) { + goto flush_lru; + }); mysql_mutex_lock(&buf_pool.mutex); got_mutex: buf_LRU_check_size_of_non_data_objects(); @@ -493,7 +498,9 @@ not_found: removing the block from buf_pool.page_hash and buf_pool.LRU is fairly involved (particularly in case of ROW_FORMAT=COMPRESSED pages). We can do that in a separate patch sometime in future. */ - +#ifndef DBUG_OFF +flush_lru: +#endif if (!buf_flush_LRU(innodb_lru_flush_size)) { MONITOR_INC(MONITOR_LRU_SINGLE_FLUSH_FAILURE_COUNT); ++flush_failures; diff --git a/storage/innobase/log/log0recv.cc b/storage/innobase/log/log0recv.cc index 4a6527962f6..eb2931adf0e 100644 --- a/storage/innobase/log/log0recv.cc +++ b/storage/innobase/log/log0recv.cc @@ -2692,8 +2692,23 @@ void recv_sys_t::apply(bool last_batch) fil_system.extend_to_recv_size(); + /* Release the log_sys mutex in non-last batches of multi-batch + recovery mode and recv_sys.mutex before preallocating the + block because while preallocating the block which may initiate + log flush which requires log_sys mutex to acquire again, which + should be acquired before recv_sys.mutex in order to avoid + deadlocks. */ + mutex_exit(&mutex); + if (!last_batch) + mysql_mutex_unlock(&log_sys.mutex); + + mysql_mutex_assert_not_owner(&log_sys.mutex); buf_block_t *free_block= buf_LRU_get_free_block(false); + if (!last_batch) + mysql_mutex_lock(&log_sys.mutex); + mutex_enter(&mutex); + for (map::iterator p= pages.begin(); p != pages.end(); ) { const page_id_t page_id= p->first; @@ -2708,7 +2723,10 @@ void recv_sys_t::apply(bool last_batch) if (UNIV_LIKELY(!!recover_low(page_id, p, mtr, free_block))) { mutex_exit(&mutex); + if (!last_batch) mysql_mutex_unlock(&log_sys.mutex); + mysql_mutex_assert_not_owner(&log_sys.mutex); free_block= buf_LRU_get_free_block(false); + if (!last_batch) mysql_mutex_lock(&log_sys.mutex); mutex_enter(&mutex); break; } -- cgit v1.2.1 From 1a5c7552ea3a0233e7abff56a167c3a532c7da0a Mon Sep 17 00:00:00 2001 From: Thirunarayanan Balathandayuthapani Date: Tue, 14 Feb 2023 14:36:17 +0530 Subject: MDEV-30552 InnoDB recovery crashes when error handling scenario - InnoDB fails to reset the after_apply variable before applying the redo log in last batch during multi-batch recovery. --- mysql-test/suite/innodb/r/recovery_memory.result | 20 ++++++++++++++++++++ mysql-test/suite/innodb/t/recovery_memory.test | 21 +++++++++++++++++++++ storage/innobase/ibuf/ibuf0ibuf.cc | 4 ++++ storage/innobase/log/log0recv.cc | 5 +++++ 4 files changed, 50 insertions(+) diff --git a/mysql-test/suite/innodb/r/recovery_memory.result b/mysql-test/suite/innodb/r/recovery_memory.result index 4fa31009130..6faea097616 100644 --- a/mysql-test/suite/innodb/r/recovery_memory.result +++ b/mysql-test/suite/innodb/r/recovery_memory.result @@ -1,3 +1,7 @@ +call mtr.add_suppression("InnoDB: The change buffer is corrupted"); +call mtr.add_suppression("InnoDB: Plugin initialization aborted at srv0start.cc"); +call mtr.add_suppression("Plugin 'InnoDB' init function returned error"); +call mtr.add_suppression("Plugin 'InnoDB' registration as a STORAGE ENGINE failed."); CREATE TABLE t1(c TEXT, KEY(c(3072)))ENGINE=InnoDB; CREATE PROCEDURE dorepeat() LOOP @@ -10,3 +14,19 @@ CALL dorepeat(); connection default; # restart: --innodb_buffer_pool_size=5242880 DROP TABLE t1; +DROP PROCEDURE dorepeat; +# +# MDEV-30552 InnoDB recovery crashes when error +# handling scenario +# +SET DEBUG_DBUG="+d,ib_log_checkpoint_avoid_hard"; +CREATE TABLE t1(f1 INT NOT NULL)ENGINE=InnoDB; +INSERT INTO t1 SELECT * FROM seq_1_to_65536; +# restart: --innodb_buffer_pool_size=5242880 --debug_dbug=+d,ibuf_init_corrupt +# restart +SHOW CREATE TABLE t1; +Table Create Table +t1 CREATE TABLE `t1` ( + `f1` int(11) NOT NULL +) ENGINE=InnoDB DEFAULT CHARSET=latin1 COLLATE=latin1_swedish_ci +DROP TABLE t1; diff --git a/mysql-test/suite/innodb/t/recovery_memory.test b/mysql-test/suite/innodb/t/recovery_memory.test index d9afd52c499..e723ba25d36 100644 --- a/mysql-test/suite/innodb/t/recovery_memory.test +++ b/mysql-test/suite/innodb/t/recovery_memory.test @@ -1,5 +1,10 @@ --source include/have_innodb.inc --source include/big_test.inc +--source include/have_sequence.inc +call mtr.add_suppression("InnoDB: The change buffer is corrupted"); +call mtr.add_suppression("InnoDB: Plugin initialization aborted at srv0start.cc"); +call mtr.add_suppression("Plugin 'InnoDB' init function returned error"); +call mtr.add_suppression("Plugin 'InnoDB' registration as a STORAGE ENGINE failed."); CREATE TABLE t1(c TEXT, KEY(c(3072)))ENGINE=InnoDB; DELIMITER |; @@ -19,3 +24,19 @@ let $shutdown_timeout=0; let $restart_parameters=--innodb_buffer_pool_size=5242880; --source include/restart_mysqld.inc DROP TABLE t1; +DROP PROCEDURE dorepeat; + +--echo # +--echo # MDEV-30552 InnoDB recovery crashes when error +--echo # handling scenario +--echo # +SET DEBUG_DBUG="+d,ib_log_checkpoint_avoid_hard"; +CREATE TABLE t1(f1 INT NOT NULL)ENGINE=InnoDB; +INSERT INTO t1 SELECT * FROM seq_1_to_65536; +let $shutdown_timeout=0; +let $restart_parameters=--innodb_buffer_pool_size=5242880 --debug_dbug="+d,ibuf_init_corrupt"; +--source include/restart_mysqld.inc +let $restart_parameters=; +--source include/restart_mysqld.inc +SHOW CREATE TABLE t1; +DROP TABLE t1; diff --git a/storage/innobase/ibuf/ibuf0ibuf.cc b/storage/innobase/ibuf/ibuf0ibuf.cc index d88c2b0027e..dff0ad57057 100644 --- a/storage/innobase/ibuf/ibuf0ibuf.cc +++ b/storage/innobase/ibuf/ibuf0ibuf.cc @@ -450,6 +450,10 @@ err_exit: root = buf_block_get_frame(block); } + DBUG_EXECUTE_IF("ibuf_init_corrupt", + err = DB_CORRUPTION; + goto err_exit;); + if (page_is_comp(root) || fil_page_get_type(root) != FIL_PAGE_INDEX || btr_page_get_index_id(root) != DICT_IBUF_ID_MIN) { err = DB_CORRUPTION; diff --git a/storage/innobase/log/log0recv.cc b/storage/innobase/log/log0recv.cc index eb2931adf0e..9b4ceb4f03e 100644 --- a/storage/innobase/log/log0recv.cc +++ b/storage/innobase/log/log0recv.cc @@ -3642,6 +3642,11 @@ completed: mysql_mutex_unlock(&log_sys.mutex); return(DB_ERROR); } + + /* In case of multi-batch recovery, + redo log for the last batch is not + applied yet. */ + ut_d(recv_sys.after_apply = false); } } else { ut_ad(!rescan || recv_sys.pages.empty()); -- cgit v1.2.1 From 951d81d92ebe442a639d29bcc71ca43a95e09368 Mon Sep 17 00:00:00 2001 From: Thirunarayanan Balathandayuthapani Date: Tue, 14 Feb 2023 15:43:33 +0530 Subject: MDEV-30426 Assertion !rec_offs_nth_extern(offsets2, n) during bulk insert - cmp_rec_rec_simple() fails to detect duplicate key error for bulk insert operation --- mysql-test/suite/innodb/r/insert_into_empty.result | 18 ++++++++++++++++++ mysql-test/suite/innodb/t/insert_into_empty.opt | 1 + mysql-test/suite/innodb/t/insert_into_empty.test | 19 +++++++++++++++++++ storage/innobase/rem/rem0cmp.cc | 9 ++++++--- 4 files changed, 44 insertions(+), 3 deletions(-) create mode 100644 mysql-test/suite/innodb/t/insert_into_empty.opt diff --git a/mysql-test/suite/innodb/r/insert_into_empty.result b/mysql-test/suite/innodb/r/insert_into_empty.result index 429e0174f9d..eedfb681929 100644 --- a/mysql-test/suite/innodb/r/insert_into_empty.result +++ b/mysql-test/suite/innodb/r/insert_into_empty.result @@ -405,3 +405,21 @@ nb_corrupted_rows 0 DROP TABLE t1; # End of 10.7 tests +# +# MDEV-30426 Assertion !rec_offs_nth_extern(offsets2, n) +# during bulk insert +# +CREATE TABLE t1(f1 TEXT NOT NULL, f2 TEXT NOT NULL, +f3 TEXT NOT NULL, f4 TEXT NOT NULL, +f5 TEXT NOT NULL, f6 TEXT NOT NULL, +PRIMARY KEY(f6(10)))ENGINE=InnoDB; +BEGIN; +INSERT INTO t1 VALUES +(repeat('a', 200), repeat('b', 200), repeat('c', 200), +repeat('d', 200), repeat('e', 200), repeat('f', 200)), +(repeat('b', 20000), repeat('c', 16000), repeat('d', 12000), +repeat('e', 12000), repeat('f', 12000), repeat('f', 12000)); +ERROR HY000: Got error 1 "Operation not permitted" during COMMIT +COMMIT; +DROP TABLE t1; +# End of 10.8 tests diff --git a/mysql-test/suite/innodb/t/insert_into_empty.opt b/mysql-test/suite/innodb/t/insert_into_empty.opt new file mode 100644 index 00000000000..c856c2d215a --- /dev/null +++ b/mysql-test/suite/innodb/t/insert_into_empty.opt @@ -0,0 +1 @@ +--innodb_sort_buffer_size=65536 diff --git a/mysql-test/suite/innodb/t/insert_into_empty.test b/mysql-test/suite/innodb/t/insert_into_empty.test index 64043e383dc..ee32a2d7cac 100644 --- a/mysql-test/suite/innodb/t/insert_into_empty.test +++ b/mysql-test/suite/innodb/t/insert_into_empty.test @@ -424,3 +424,22 @@ SELECT COUNT(*) AS nb_corrupted_rows FROM t1 WHERE data != REPEAT('X', @@innodb_ DROP TABLE t1; --echo # End of 10.7 tests + +--echo # +--echo # MDEV-30426 Assertion !rec_offs_nth_extern(offsets2, n) +--echo # during bulk insert +--echo # +CREATE TABLE t1(f1 TEXT NOT NULL, f2 TEXT NOT NULL, + f3 TEXT NOT NULL, f4 TEXT NOT NULL, + f5 TEXT NOT NULL, f6 TEXT NOT NULL, + PRIMARY KEY(f6(10)))ENGINE=InnoDB; +BEGIN; +--error ER_ERROR_DURING_COMMIT +INSERT INTO t1 VALUES + (repeat('a', 200), repeat('b', 200), repeat('c', 200), + repeat('d', 200), repeat('e', 200), repeat('f', 200)), + (repeat('b', 20000), repeat('c', 16000), repeat('d', 12000), + repeat('e', 12000), repeat('f', 12000), repeat('f', 12000)); +COMMIT; +DROP TABLE t1; +--echo # End of 10.8 tests diff --git a/storage/innobase/rem/rem0cmp.cc b/storage/innobase/rem/rem0cmp.cc index a77ddafd568..c2b2bc7120d 100644 --- a/storage/innobase/rem/rem0cmp.cc +++ b/storage/innobase/rem/rem0cmp.cc @@ -725,9 +725,12 @@ cmp_rec_rec_simple( /* If we ran out of fields, the ordering columns of rec1 were equal to rec2. Issue a duplicate key error if needed. */ - if (!null_eq && table && dict_index_is_unique(index)) { - /* Report erroneous row using new version of table. */ - innobase_rec_to_mysql(table, rec1, index, offsets1); + if (!null_eq && index->is_unique()) { + if (table) { + /* Report erroneous row using new version + of table. */ + innobase_rec_to_mysql(table, rec1, index, offsets1); + } return(0); } -- cgit v1.2.1 From 690fcfbd2954f9470047ce754c2a5c2fdfd15cf3 Mon Sep 17 00:00:00 2001 From: Andrew Hutchings Date: Wed, 18 Jan 2023 16:16:34 +0000 Subject: Fix S3 engine Coverity hits Very minor hits found by Coverity for the S3 engine. --- storage/maria/ha_s3.cc | 2 +- storage/maria/s3_func.c | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/storage/maria/ha_s3.cc b/storage/maria/ha_s3.cc index 158fa8d0430..b75481b3fc2 100644 --- a/storage/maria/ha_s3.cc +++ b/storage/maria/ha_s3.cc @@ -233,7 +233,7 @@ ha_create_table_option s3_table_option_list[]= ha_s3::ha_s3(handlerton *hton, TABLE_SHARE *table_arg) - :ha_maria(hton, table_arg), in_alter_table(S3_NO_ALTER) + :ha_maria(hton, table_arg), in_alter_table(S3_NO_ALTER), open_args(NULL) { /* Remove things that S3 doesn't support */ int_table_flags&= ~(HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE | diff --git a/storage/maria/s3_func.c b/storage/maria/s3_func.c index 491a8e0a323..3d18ba8800d 100644 --- a/storage/maria/s3_func.c +++ b/storage/maria/s3_func.c @@ -351,7 +351,7 @@ int aria_copy_to_s3(ms3_st *s3_client, const char *aws_bucket, if (display) printf("Copying frm file %s\n", filename); - end= strmov(aws_path_end,"/frm"); + strmov(aws_path_end,"/frm"); convert_frm_to_s3_format(alloc_block); /* Note that frm is not compressed! */ @@ -1232,7 +1232,7 @@ static void convert_index_to_s3_format(uchar *header, ulong block_size, uchar *base_pos; uint base_offset; - memcpy(state.header.file_version, header, sizeof(state.header)); + memcpy(&state.header, header, sizeof(state.header)); base_offset= mi_uint2korr(state.header.base_pos); base_pos= header + base_offset; @@ -1251,7 +1251,7 @@ static void convert_index_to_disk_format(uchar *header) uchar *base_pos; uint base_offset; - memcpy(state.header.file_version, header, sizeof(state.header)); + memcpy(&state.header, header, sizeof(state.header)); base_offset= mi_uint2korr(state.header.base_pos); base_pos= header + base_offset; -- cgit v1.2.1 From 192427e37d2b066f9f681cc1b998b2efdc407c55 Mon Sep 17 00:00:00 2001 From: Monty Date: Wed, 15 Feb 2023 13:56:33 +0200 Subject: MDEV-30333 Wrong result with not_null_range_scan and LEFT JOIN with empty table There was a bug in JOIN::make_notnull_conds_for_range_scans() when clearing TABLE->tmp_set, which was used to mark fields that could not be null. This function was only used if 'not_null_range_scan=on' is set. The effect was that tmp_set contained a 'random value' and this caused the optimizer to think that some fields could not be null. FLUSH TABLES clears tmp_set and because of this things worked temporarily. Fixed by clearing tmp_set properly. --- mysql-test/main/empty_table.result | 58 ++++++++++++++++++++++++++++++++++++++ mysql-test/main/empty_table.test | 36 ++++++++++++++++++++++- sql/sql_select.cc | 6 ++-- 3 files changed, 95 insertions(+), 5 deletions(-) diff --git a/mysql-test/main/empty_table.result b/mysql-test/main/empty_table.result index 2bca3e792fa..90aec2eda3b 100644 --- a/mysql-test/main/empty_table.result +++ b/mysql-test/main/empty_table.result @@ -16,3 +16,61 @@ ERROR 42S02: Table 'test.t2' doesn't exist show status like "Empty_queries"; Variable_name Value Empty_queries 2 +# End of 4.1 tests +# +# MDEV-30333 Wrong result with not_null_range_scan and LEFT JOIN with empty table +# +set @save_optimizer_switch=@@optimizer_switch; +CREATE TABLE t1 (a INT, b INT) ENGINE=MyISAM; +INSERT INTO t1 (b) VALUES (1),(2); +CREATE TABLE t2 (c INT) ENGINE=MyISAM; +SET optimizer_switch= 'not_null_range_scan=off'; +explain extended SELECT b FROM t1 LEFT JOIN t2 ON t2.c = a WHERE a IS NULL ORDER BY b; +id select_type table type possible_keys key key_len ref rows filtered Extra +1 SIMPLE t2 system NULL NULL NULL NULL 0 0.00 Const row not found +1 SIMPLE t1 ALL NULL NULL NULL NULL 2 100.00 Using where; Using filesort +Warnings: +Note 1003 select `test`.`t1`.`b` AS `b` from `test`.`t1` where `test`.`t1`.`a` is null order by `test`.`t1`.`b` +SELECT b FROM t1 LEFT JOIN t2 ON t2.c = a WHERE a IS NULL ORDER BY b; +b +1 +2 +SET optimizer_switch = 'not_null_range_scan=on'; +explain extended SELECT b FROM t1 LEFT JOIN t2 ON t2.c = a WHERE a IS NULL ORDER BY b; +id select_type table type possible_keys key key_len ref rows filtered Extra +1 SIMPLE t2 system NULL NULL NULL NULL 0 0.00 Const row not found +1 SIMPLE t1 ALL NULL NULL NULL NULL 2 100.00 Using where; Using filesort +Warnings: +Note 1003 select `test`.`t1`.`b` AS `b` from `test`.`t1` where `test`.`t1`.`a` is null order by `test`.`t1`.`b` +SELECT b FROM t1 LEFT JOIN t2 ON t2.c = a WHERE a IS NULL ORDER BY b; +b +1 +2 +flush tables; +SELECT b FROM t1 LEFT JOIN t2 ON t2.c = a WHERE a IS NULL ORDER BY b; +b +1 +2 +drop table t1,t2; +# Second test in MDEV-30333 +CREATE TABLE t1 (a int, b varchar(10)) ENGINE=MyISAM; +INSERT INTO t1 VALUES (69,'foo'),(71,'bar'); +CREATE TABLE t2 (c int) ENGINE=MyISAM; +INSERT INTO t2 VALUES (1),(2); +CREATE TABLE t3 (d int, e int, KEY(e)) ENGINE=MyISAM; +SELECT * FROM t1 LEFT JOIN t2 LEFT JOIN t3 ON t3.e = t3.d ON 1; +a b c d e +69 foo 1 NULL NULL +71 bar 1 NULL NULL +69 foo 2 NULL NULL +71 bar 2 NULL NULL +SET optimizer_switch = 'not_null_range_scan=on'; +SELECT * FROM t1 LEFT JOIN t2 LEFT JOIN t3 ON t3.e = t3.d ON 1; +a b c d e +69 foo 1 NULL NULL +71 bar 1 NULL NULL +69 foo 2 NULL NULL +71 bar 2 NULL NULL +DROP TABLE t1, t2, t3; +set @@optimizer_switch=@save_optimizer_switch; +End of 10.5 tests diff --git a/mysql-test/main/empty_table.test b/mysql-test/main/empty_table.test index 754671868ba..a17b0c897d5 100644 --- a/mysql-test/main/empty_table.test +++ b/mysql-test/main/empty_table.test @@ -21,4 +21,38 @@ drop table t1; select * from t2; show status like "Empty_queries"; -# End of 4.1 tests +--echo # End of 4.1 tests + +--echo # +--echo # MDEV-30333 Wrong result with not_null_range_scan and LEFT JOIN with empty table +--echo # + +set @save_optimizer_switch=@@optimizer_switch; +CREATE TABLE t1 (a INT, b INT) ENGINE=MyISAM; +INSERT INTO t1 (b) VALUES (1),(2); +CREATE TABLE t2 (c INT) ENGINE=MyISAM; +SET optimizer_switch= 'not_null_range_scan=off'; # Default +explain extended SELECT b FROM t1 LEFT JOIN t2 ON t2.c = a WHERE a IS NULL ORDER BY b; +SELECT b FROM t1 LEFT JOIN t2 ON t2.c = a WHERE a IS NULL ORDER BY b; +SET optimizer_switch = 'not_null_range_scan=on'; +explain extended SELECT b FROM t1 LEFT JOIN t2 ON t2.c = a WHERE a IS NULL ORDER BY b; +SELECT b FROM t1 LEFT JOIN t2 ON t2.c = a WHERE a IS NULL ORDER BY b; +flush tables; +SELECT b FROM t1 LEFT JOIN t2 ON t2.c = a WHERE a IS NULL ORDER BY b; +drop table t1,t2; + +--echo # Second test in MDEV-30333 + +CREATE TABLE t1 (a int, b varchar(10)) ENGINE=MyISAM; +INSERT INTO t1 VALUES (69,'foo'),(71,'bar'); +CREATE TABLE t2 (c int) ENGINE=MyISAM; +INSERT INTO t2 VALUES (1),(2); +CREATE TABLE t3 (d int, e int, KEY(e)) ENGINE=MyISAM; +SELECT * FROM t1 LEFT JOIN t2 LEFT JOIN t3 ON t3.e = t3.d ON 1; +SET optimizer_switch = 'not_null_range_scan=on'; +SELECT * FROM t1 LEFT JOIN t2 LEFT JOIN t3 ON t3.e = t3.d ON 1; +DROP TABLE t1, t2, t3; +set @@optimizer_switch=@save_optimizer_switch; + +--echo End of 10.5 tests + diff --git a/sql/sql_select.cc b/sql/sql_select.cc index 42711270f60..c28f104804f 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -29683,7 +29683,6 @@ void JOIN::make_notnull_conds_for_range_scans() { DBUG_ENTER("JOIN::make_notnull_conds_for_range_scans"); - if (impossible_where || !optimizer_flag(thd, OPTIMIZER_SWITCH_NOT_NULL_RANGE_SCAN)) { @@ -29769,7 +29768,6 @@ bool build_notnull_conds_for_range_scans(JOIN *join, Item *cond, table_map allowed) { THD *thd= join->thd; - DBUG_ENTER("build_notnull_conds_for_range_scans"); for (JOIN_TAB *s= join->join_tab; @@ -29777,13 +29775,13 @@ bool build_notnull_conds_for_range_scans(JOIN *join, Item *cond, { /* Clear all needed bitmaps to mark found fields */ if ((allowed & s->table->map) && - !(s->table->map && join->const_table_map)) + !(s->table->map & join->const_table_map)) bitmap_clear_all(&s->table->tmp_set); } /* Find all null-rejected fields assuming that cond is null-rejected and - only formulas over tables from 'allowed' are to be taken into account + only formulas over tables from 'allowed' are to be taken into account */ if (cond->find_not_null_fields(allowed)) DBUG_RETURN(true); -- cgit v1.2.1 From e83ae66e4a08f5efcbc7d86d47603db6f1570009 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vicen=C8=9Biu=20Ciorbaru?= Date: Sat, 4 Feb 2023 12:10:31 +0200 Subject: Update comments to match new debug_sync implementation --- mysql-test/main/debug_sync.test | 11 ++++------- sql/debug_sync.cc | 7 ++++--- 2 files changed, 8 insertions(+), 10 deletions(-) diff --git a/mysql-test/main/debug_sync.test b/mysql-test/main/debug_sync.test index 1dc3dc9c71e..6e75ba9624c 100644 --- a/mysql-test/main/debug_sync.test +++ b/mysql-test/main/debug_sync.test @@ -231,15 +231,12 @@ SHOW VARIABLES LIKE 'DEBUG_SYNC'; # immediately after setting of the DEBUG_SYNC variable. # So it is executed before the SET statement ends. # -# NOTE: There is only one global signal (say "signal post" or "flag mast"). -# A SIGNAL action writes its signal into it ("sets a flag"). -# The signal persists until explicitly overwritten. +# NOTE: There can be multiple active signals at the same time. +# A SIGNAL action appends its signal into signals set. +# The signal persists until waited on. # To avoid confusion for later tests, it is recommended to clear -# the signal by signalling "empty" ("setting the 'empty' flag"): -# SET DEBUG_SYNC= 'now SIGNAL empty'; -# Preferably you can reset the whole facility with: +# the signal set by running # SET DEBUG_SYNC= 'RESET'; -# The signal is then '' (really empty) which connot be done otherwise. # # diff --git a/sql/debug_sync.cc b/sql/debug_sync.cc index aa6956060b4..eac111d32d7 100644 --- a/sql/debug_sync.cc +++ b/sql/debug_sync.cc @@ -1344,7 +1344,8 @@ static bool debug_sync_eval_action(THD *thd, char *action_str, char *action_end) /* Try NO_CLEAR_EVENT. */ - if (!my_strcasecmp(system_charset_info, token, "NO_CLEAR_EVENT")) { + if (!my_strcasecmp(system_charset_info, token, "NO_CLEAR_EVENT")) + { action->clear_event= false; /* Get next token. If none follows, set action. */ if (!(ptr = debug_sync_token(&token, &token_length, ptr, action_end))) goto set_action; @@ -1634,8 +1635,8 @@ static void debug_sync_execute(THD *thd, st_debug_sync_action *action) /* - Wait until global signal string matches the wait_for string. - Interrupt when thread or query is killed or facility disabled. + Wait until the signal set contains the wait_for string. + Interrupt when thread or query is killed or facility is disabled. The facility can become disabled when some thread cannot get the required dynamic memory allocated. */ -- cgit v1.2.1 From d2b773d913cdcd35a727643bc16927527a5ee4bc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vicen=C8=9Biu=20Ciorbaru?= Date: Sat, 4 Feb 2023 12:11:15 +0200 Subject: Whitespace fix --- sql/sql_hset.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sql/sql_hset.h b/sql/sql_hset.h index c9ffc8a560b..41573fb5f03 100644 --- a/sql/sql_hset.h +++ b/sql/sql_hset.h @@ -40,7 +40,7 @@ public: Hash_set(PSI_memory_key psi_key, CHARSET_INFO *charset, ulong default_array_elements, size_t key_offset, size_t key_length, my_hash_get_key get_key, - void (*free_element)(void*),uint flags) + void (*free_element)(void*), uint flags) { my_hash_init(psi_key, &m_hash, charset, default_array_elements, key_offset, key_length, get_key, free_element, flags); -- cgit v1.2.1 From 4afa3b64c4e5ca12d755124befc373e0f35ff1e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vicen=C8=9Biu=20Ciorbaru?= Date: Wed, 15 Feb 2023 16:20:25 +0200 Subject: MDEV-30324: Wrong result upon SELECT DISTINCT ... WITH TIES WITH TIES would not take effect if SELECT DISTINCT was used in a context where an INDEX is used to resolve the ORDER BY clause. WITH TIES relies on the `JOIN::order` to contain the non-constant fields to test the equality of ORDER BY fiels required for WITH TIES. The cause of the problem was a premature removal of the `JOIN::order` member during a DISTINCT optimization. This lead to WITH TIES code assuming ORDER BY only contained "constant" elements. Disable this optimization when WITH TIES is in effect. (side-note: the order by removal does not impact any current tests, thus it will be removed in a future version) Reviewed by: monty@mariadb.org --- mysql-test/main/fetch_first.result | 28 ++++++++++++++++++++++++++++ mysql-test/main/fetch_first.test | 19 +++++++++++++++++++ sql/sql_select.cc | 2 +- 3 files changed, 48 insertions(+), 1 deletion(-) diff --git a/mysql-test/main/fetch_first.result b/mysql-test/main/fetch_first.result index 69a0336d722..df182381d1c 100644 --- a/mysql-test/main/fetch_first.result +++ b/mysql-test/main/fetch_first.result @@ -1378,3 +1378,31 @@ a bar foo DROP TABLE t; +# +# MDEV-30324: Wrong result upon SELECT DISTINCT .. WITH TIES using index +# +CREATE TABLE t1 (a int, b char(3), KEY (a)); +INSERT INTO t1 VALUES (2,'foo'),(3,'bar'),(3,'bar'),(3,'zzz'); +EXPLAIN SELECT DISTINCT a, b FROM t1 ORDER BY a FETCH FIRST 1 ROWS WITH TIES; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 index NULL a 5 NULL 1 Using temporary +SELECT DISTINCT a, b FROM t1 ORDER BY a FETCH FIRST 1 ROWS WITH TIES; +a b +2 foo +EXPLAIN SELECT DISTINCT a, b FROM t1 ORDER BY a FETCH FIRST 2 ROWS WITH TIES; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 index NULL a 5 NULL 2 Using temporary +SELECT DISTINCT a, b FROM t1 ORDER BY a FETCH FIRST 2 ROWS WITH TIES; +a b +2 foo +3 bar +3 zzz +EXPLAIN SELECT DISTINCT a, b FROM t1 ORDER BY a FETCH FIRST 3 ROWS WITH TIES; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 ALL NULL NULL NULL NULL 4 Using temporary; Using filesort +SELECT DISTINCT a, b FROM t1 ORDER BY a FETCH FIRST 3 ROWS WITH TIES; +a b +2 foo +3 bar +3 zzz +DROP TABLE t1; diff --git a/mysql-test/main/fetch_first.test b/mysql-test/main/fetch_first.test index 62cdd717f81..98bbf1ca06b 100644 --- a/mysql-test/main/fetch_first.test +++ b/mysql-test/main/fetch_first.test @@ -1059,3 +1059,22 @@ SELECT a FROM t ORDER BY a FETCH FIRST 2 ROWS WITH TIES; # Cleanup DROP TABLE t; + +--echo # +--echo # MDEV-30324: Wrong result upon SELECT DISTINCT .. WITH TIES using index +--echo # +CREATE TABLE t1 (a int, b char(3), KEY (a)); +INSERT INTO t1 VALUES (2,'foo'),(3,'bar'),(3,'bar'),(3,'zzz'); + +EXPLAIN SELECT DISTINCT a, b FROM t1 ORDER BY a FETCH FIRST 1 ROWS WITH TIES; +--sorted_result +SELECT DISTINCT a, b FROM t1 ORDER BY a FETCH FIRST 1 ROWS WITH TIES; +EXPLAIN SELECT DISTINCT a, b FROM t1 ORDER BY a FETCH FIRST 2 ROWS WITH TIES; +--sorted_result +SELECT DISTINCT a, b FROM t1 ORDER BY a FETCH FIRST 2 ROWS WITH TIES; +EXPLAIN SELECT DISTINCT a, b FROM t1 ORDER BY a FETCH FIRST 3 ROWS WITH TIES; +--sorted_result +SELECT DISTINCT a, b FROM t1 ORDER BY a FETCH FIRST 3 ROWS WITH TIES; + +# Cleanup +DROP TABLE t1; diff --git a/sql/sql_select.cc b/sql/sql_select.cc index e0beda6ec61..57bf9363b47 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -4170,7 +4170,7 @@ JOIN::optimize_distinct() } /* Optimize "select distinct b from t1 order by key_part_1 limit #" */ - if (order && skip_sort_order) + if (order && skip_sort_order && !unit->lim.is_with_ties()) { /* Should already have been optimized away */ DBUG_ASSERT(ordered_index_usage == ordered_index_order_by); -- cgit v1.2.1 From 5300c0fb7632e7e49a22997297bf731e691d3c24 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marko=20M=C3=A4kel=C3=A4?= Date: Wed, 15 Feb 2023 18:16:41 +0200 Subject: MDEV-30657 InnoDB: Not applying UNDO_APPEND due to corruption This almost completely reverts commit acd23da4c2363511aae7d984c24cc6847aa3f19c and retains a safe optimization: recv_sys_t::parse(): Remove any old redo log records for the truncated tablespace, to free up memory earlier. If recovery consists of multiple batches, then recv_sys_t::apply() will must invoke recv_sys_t::trim() again to avoid wrongly applying old log records to an already truncated undo tablespace. --- storage/innobase/include/log0recv.h | 12 +++++++++--- storage/innobase/log/log0recv.cc | 16 ++++++++++++---- 2 files changed, 21 insertions(+), 7 deletions(-) diff --git a/storage/innobase/include/log0recv.h b/storage/innobase/include/log0recv.h index 73d5724f612..e4a8f0d25a2 100644 --- a/storage/innobase/include/log0recv.h +++ b/storage/innobase/include/log0recv.h @@ -266,9 +266,15 @@ private: @param lsn log sequence number of the shrink operation */ inline void trim(const page_id_t page_id, lsn_t lsn); - /** Truncated undo tablespace size for which truncate has been logged - (indexed by page_id_t::space() - srv_undo_space_id_start), or 0 */ - unsigned truncated_undo_spaces[127]; + /** Undo tablespaces for which truncate has been logged + (indexed by page_id_t::space() - srv_undo_space_id_start) */ + struct trunc + { + /** log sequence number of FILE_CREATE, or 0 if none */ + lsn_t lsn; + /** truncated size of the tablespace, or 0 if not truncated */ + unsigned pages; + } truncated_undo_spaces[127]; public: /** The contents of the doublewrite buffer */ diff --git a/storage/innobase/log/log0recv.cc b/storage/innobase/log/log0recv.cc index 9b4ceb4f03e..c4217d7a1cb 100644 --- a/storage/innobase/log/log0recv.cc +++ b/storage/innobase/log/log0recv.cc @@ -1952,7 +1952,8 @@ same_page: /* The entire undo tablespace will be reinitialized by innodb_undo_log_truncate=ON. Discard old log for all pages. */ trim({space_id, 0}, recovered_lsn); - truncated_undo_spaces[space_id - srv_undo_space_id_start]= page_no; + truncated_undo_spaces[space_id - srv_undo_space_id_start]= + { recovered_lsn, page_no }; if (undo_space_trunc) undo_space_trunc(space_id); #endif @@ -2677,15 +2678,22 @@ void recv_sys_t::apply(bool last_batch) for (auto id= srv_undo_tablespaces_open; id--;) { - if (unsigned pages= truncated_undo_spaces[id]) + const trunc& t= truncated_undo_spaces[id]; + if (t.lsn) { - if (fil_space_t *space= fil_space_get(id + srv_undo_space_id_start)) + /* The entire undo tablespace will be reinitialized by + innodb_undo_log_truncate=ON. Discard old log for all pages. + Even though we recv_sys_t::parse() already invoked trim(), + this will be needed in case recovery consists of multiple batches + (there was an invocation with !last_batch). */ + trim({id + srv_undo_space_id_start, 0}, t.lsn); + if (fil_space_t *space = fil_space_get(id + srv_undo_space_id_start)) { ut_ad(UT_LIST_GET_LEN(space->chain) == 1); fil_node_t *file= UT_LIST_GET_FIRST(space->chain); ut_ad(file->is_open()); os_file_truncate(file->name, file->handle, - os_offset_t{pages} << srv_page_size_shift, true); + os_offset_t{t.pages} << srv_page_size_shift, true); } } } -- cgit v1.2.1 From 9c15799462d6a2673a6158eb1717d222c07cced4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marko=20M=C3=A4kel=C3=A4?= Date: Thu, 16 Feb 2023 08:28:14 +0200 Subject: MDEV-30397: MariaDB crash due to DB_FAIL reported for a corrupted page buf_read_page_low(): Map the buf_page_t::read_complete() return value DB_FAIL to DB_PAGE_CORRUPTED. The purpose of the DB_FAIL return value is to avoid error log noise when read-ahead brings in an unused page that is typically filled with NUL bytes. If a synchronous read is bringing in a corrupted page where the page frame does not contain the expected tablespace identifier and page number, that must be treated as an attempt to read a corrupted page. The correct error code for this is DB_PAGE_CORRUPTED. The error code DB_FAIL is not handled by row_mysql_handle_errors(). This was missed in commit 0b47c126e31cddda1e94588799599e138400bcf8 (MDEV-13542). --- storage/innobase/buf/buf0buf.cc | 6 +++--- storage/innobase/buf/buf0rea.cc | 3 +++ storage/innobase/include/buf0buf.h | 3 ++- 3 files changed, 8 insertions(+), 4 deletions(-) diff --git a/storage/innobase/buf/buf0buf.cc b/storage/innobase/buf/buf0buf.cc index 644d8680484..b17c49ab751 100644 --- a/storage/innobase/buf/buf0buf.cc +++ b/storage/innobase/buf/buf0buf.cc @@ -3449,8 +3449,7 @@ or decrypt/decompress just failed. @retval DB_SUCCESS if page has been read and is not corrupted @retval DB_PAGE_CORRUPTED if page based on checksum check is corrupted @retval DB_DECRYPTION_FAILED if page post encryption checksum matches but -after decryption normal page checksum does not match. -@retval DB_TABLESPACE_DELETED if accessed tablespace is not found */ +after decryption normal page checksum does not match. */ static dberr_t buf_page_check_corrupt(buf_page_t *bpage, const fil_node_t &node) { @@ -3507,7 +3506,8 @@ static dberr_t buf_page_check_corrupt(buf_page_t *bpage, @param node data file @return whether the operation succeeded @retval DB_PAGE_CORRUPTED if the checksum fails -@retval DB_DECRYPTION_FAILED if the page cannot be decrypted */ +@retval DB_DECRYPTION_FAILED if the page cannot be decrypted +@retval DB_FAIL if the page contains the wrong ID */ dberr_t buf_page_t::read_complete(const fil_node_t &node) { const page_id_t expected_id{id()}; diff --git a/storage/innobase/buf/buf0rea.cc b/storage/innobase/buf/buf0rea.cc index 2f15fa62796..b20b105a4c4 100644 --- a/storage/innobase/buf/buf0rea.cc +++ b/storage/innobase/buf/buf0rea.cc @@ -331,6 +331,9 @@ nothing_read: /* The i/o was already completed in space->io() */ *err = bpage->read_complete(*fio.node); space->release(); + if (*err == DB_FAIL) { + *err = DB_PAGE_CORRUPTED; + } } return true; diff --git a/storage/innobase/include/buf0buf.h b/storage/innobase/include/buf0buf.h index d33c5513dc5..b4d8c8b76ac 100644 --- a/storage/innobase/include/buf0buf.h +++ b/storage/innobase/include/buf0buf.h @@ -773,7 +773,8 @@ public: @param node data file @return whether the operation succeeded @retval DB_PAGE_CORRUPTED if the checksum fails - @retval DB_DECRYPTION_FAILED if the page cannot be decrypted */ + @retval DB_DECRYPTION_FAILED if the page cannot be decrypted + @retval DB_FAIL if the page contains the wrong ID */ dberr_t read_complete(const fil_node_t &node); /** Note that a block is no longer dirty, while not removing -- cgit v1.2.1 From 54c0ac72e300acb4405529a827a8c02c4a5e5d15 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marko=20M=C3=A4kel=C3=A4?= Date: Thu, 16 Feb 2023 08:29:44 +0200 Subject: MDEV-30134 Assertion failed in buf_page_t::unfix() in buf_pool_t::watch_unset() buf_pool_t::watch_set(): Always buffer-fix a block if one was found, no matter if it is a watch sentinel or a buffer page. The type of the block descriptor will be rechecked in buf_page_t::watch_unset(). Do not expect the caller to acquire the page hash latch. Starting with commit bd5a6403cace36c6ed428cde62e35adcd3f7e7d0 it is safe to release buf_pool.mutex before acquiring a buf_pool.page_hash latch. buf_page_get_low(): Adjust to the changed buf_pool_t::watch_set(). This simplifies the logic and fixes a bug that was reproduced when using debug builds and the setting innodb_change_buffering_debug=1. --- storage/innobase/buf/buf0buf.cc | 71 +++++++++++++++----------------------- storage/innobase/include/buf0buf.h | 12 +++---- 2 files changed, 33 insertions(+), 50 deletions(-) diff --git a/storage/innobase/buf/buf0buf.cc b/storage/innobase/buf/buf0buf.cc index b17c49ab751..47cc915a11d 100644 --- a/storage/innobase/buf/buf0buf.cc +++ b/storage/innobase/buf/buf0buf.cc @@ -1951,28 +1951,22 @@ static void buf_relocate(buf_page_t *bpage, buf_page_t *dpage) buf_pool.page_hash.replace(chain, bpage, dpage); } -/** Register a watch for a page identifier. The caller must hold an -exclusive page hash latch. The *hash_lock may be released, -relocated, and reacquired. -@param id page identifier -@param chain hash table chain with exclusively held page_hash -@return a buffer pool block corresponding to id -@retval nullptr if the block was not present, and a watch was installed */ -inline buf_page_t *buf_pool_t::watch_set(const page_id_t id, - buf_pool_t::hash_chain &chain) +buf_page_t *buf_pool_t::watch_set(const page_id_t id, + buf_pool_t::hash_chain &chain) { ut_ad(&chain == &page_hash.cell_get(id.fold())); - ut_ad(page_hash.lock_get(chain).is_write_locked()); + page_hash.lock_get(chain).lock(); -retry: - if (buf_page_t *bpage= page_hash.get(id, chain)) + buf_page_t *bpage= page_hash.get(id, chain); + + if (bpage) { - if (!watch_is_sentinel(*bpage)) - /* The page was loaded meanwhile. */ - return bpage; - /* Add to an existing watch. */ +got_block: bpage->fix(); - return nullptr; + if (watch_is_sentinel(*bpage)) + bpage= nullptr; + page_hash.lock_get(chain).unlock(); + return bpage; } page_hash.lock_get(chain).unlock(); @@ -2001,25 +1995,23 @@ retry: w->set_state(buf_page_t::UNFIXED + 1); w->id_= id; - buf_page_t *bpage= page_hash.get(id, chain); + page_hash.lock_get(chain).lock(); + bpage= page_hash.get(id, chain); if (UNIV_LIKELY_NULL(bpage)) { w->set_state(buf_page_t::NOT_USED); - page_hash.lock_get(chain).lock(); mysql_mutex_unlock(&mutex); - goto retry; + goto got_block; } - page_hash.lock_get(chain).lock(); ut_ad(w->state() == buf_page_t::UNFIXED + 1); buf_pool.page_hash.append(chain, w); mysql_mutex_unlock(&mutex); + page_hash.lock_get(chain).unlock(); return nullptr; } ut_error; - mysql_mutex_unlock(&mutex); - return nullptr; } /** Stop watching whether a page has been read in. @@ -2467,16 +2459,13 @@ loop: case BUF_PEEK_IF_IN_POOL: return nullptr; case BUF_GET_IF_IN_POOL_OR_WATCH: - /* We cannot easily use a memory transaction here. */ - hash_lock.lock(); + /* Buffer-fixing inside watch_set() will prevent eviction */ block = reinterpret_cast (buf_pool.watch_set(page_id, chain)); - /* buffer-fixing will prevent eviction */ - state = block ? block->page.fix() : 0; - hash_lock.unlock(); if (block) { - goto got_block; + state = block->page.state(); + goto got_block_fixed; } return nullptr; @@ -2515,6 +2504,7 @@ loop: got_block: ut_ad(!block->page.in_zip_hash); state++; +got_block_fixed: ut_ad(state > buf_page_t::FREED); if (state > buf_page_t::READ_FIX && state < buf_page_t::WRITE_FIX) { @@ -2724,24 +2714,19 @@ re_evict: const bool evicted = buf_LRU_free_page(&block->page, true); space->release(); + if (!evicted) { + block->fix(); + } + + mysql_mutex_unlock(&buf_pool.mutex); + if (evicted) { - page_hash_latch& hash_lock - = buf_pool.page_hash.lock_get(chain); - hash_lock.lock(); - mysql_mutex_unlock(&buf_pool.mutex); - /* We may set the watch, as it would have - been set if the page were not in the - buffer pool in the first place. */ - block= reinterpret_cast( - mode == BUF_GET_IF_IN_POOL_OR_WATCH - ? buf_pool.watch_set(page_id, chain) - : buf_pool.page_hash.get(page_id, chain)); - hash_lock.unlock(); + if (mode == BUF_GET_IF_IN_POOL_OR_WATCH) { + buf_pool.watch_set(page_id, chain); + } return(NULL); } - block->fix(); - mysql_mutex_unlock(&buf_pool.mutex); buf_flush_sync(); state = block->page.state(); diff --git a/storage/innobase/include/buf0buf.h b/storage/innobase/include/buf0buf.h index b4d8c8b76ac..2dccdda8a2f 100644 --- a/storage/innobase/include/buf0buf.h +++ b/storage/innobase/include/buf0buf.h @@ -1470,14 +1470,12 @@ public: return !watch_is_sentinel(*page_hash.get(id, chain)); } - /** Register a watch for a page identifier. The caller must hold an - exclusive page hash latch. The *hash_lock may be released, - relocated, and reacquired. + /** Register a watch for a page identifier. @param id page identifier - @param chain hash table chain with exclusively held page_hash - @return a buffer pool block corresponding to id - @retval nullptr if the block was not present, and a watch was installed */ - inline buf_page_t *watch_set(const page_id_t id, hash_chain &chain); + @param chain page_hash.cell_get(id.fold()) + @return a buffer page corresponding to id + @retval nullptr if the block was not present in page_hash */ + buf_page_t *watch_set(const page_id_t id, hash_chain &chain); /** Stop watching whether a page has been read in. watch_set(id) must have returned nullptr before. -- cgit v1.2.1 From 201cfc33e671705dc0f452fc69a98e3a09de61eb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marko=20M=C3=A4kel=C3=A4?= Date: Thu, 16 Feb 2023 08:30:20 +0200 Subject: MDEV-30638 Deadlock between INSERT and InnoDB non-persistent statistics update This is a partial revert of commit 8b6a308e463f937eb8d2498b04967a222c83af90 (MDEV-29883) and a follow-up to the merge commit 394fc71f4fa8f8b1b6d24adfead0ec45121d271e (MDEV-24569). The latching order related to any operation that accesses the allocation metadata of an InnoDB index tree is as follows: 1. Acquire dict_index_t::lock in non-shared mode. 2. Acquire the index root page latch in non-shared mode. 3. Possibly acquire further index page latches. Unless an exclusive dict_index_t::lock is held, this must follow the root-to-leaf, left-to-right order. 4. Acquire a *non-shared* fil_space_t::latch. 5. Acquire latches on the allocation metadata pages. 6. Possibly allocate and write some pages, or free some pages. btr_get_size_and_reserved(), dict_stats_update_transient_for_index(), dict_stats_analyze_index(): Acquire an exclusive fil_space_t::latch in order to avoid a deadlock in fseg_n_reserved_pages() in case of concurrent access to multiple indexes sharing the same "inode page". fseg_page_is_allocated(): Acquire an exclusive fil_space_t::latch in order to avoid deadlocks. All callers are holding latches on a buffer pool page, or an index, or both. Before commit edbde4a11fd0b6437202f8019a79911441b6fb32 (MDEV-24167) a third mode was available that would not conflict with the shared fil_space_t::latch acquired by ha_innobase::info_low(), i_s_sys_tablespaces_fill_table(), or i_s_tablespaces_encryption_fill_table(). Because those calls should be rather rare, it makes sense to use the simple rw_lock with only shared and exclusive modes. fil_crypt_get_page_throttle(): Avoid invoking fseg_page_is_allocated() on an allocation bitmap page (which can never be freed), to avoid acquiring a shared latch on top of an exclusive one. mtr_t::s_lock_space(), MTR_MEMO_SPACE_S_LOCK: Remove. --- storage/innobase/dict/dict0defrag_bg.cc | 2 +- storage/innobase/dict/dict0stats.cc | 4 ++-- storage/innobase/fil/fil0crypt.cc | 5 +++-- storage/innobase/fsp/fsp0fsp.cc | 2 +- storage/innobase/include/mtr0mtr.h | 16 ++-------------- storage/innobase/include/mtr0types.h | 4 +--- storage/innobase/mtr/mtr0mtr.cc | 13 +++---------- 7 files changed, 13 insertions(+), 33 deletions(-) diff --git a/storage/innobase/dict/dict0defrag_bg.cc b/storage/innobase/dict/dict0defrag_bg.cc index ea2914e52dc..bec6da8e6af 100644 --- a/storage/innobase/dict/dict0defrag_bg.cc +++ b/storage/innobase/dict/dict0defrag_bg.cc @@ -314,7 +314,7 @@ btr_get_size_and_reserved( return ULINT_UNDEFINED; } - mtr->s_lock_space(index->table->space); + mtr->x_lock_space(index->table->space); ulint n = fseg_n_reserved_pages(*root, PAGE_HEADER + PAGE_BTR_SEG_LEAF + root->page.frame, used, mtr); diff --git a/storage/innobase/dict/dict0stats.cc b/storage/innobase/dict/dict0stats.cc index 0d630583daa..7bdccd899b8 100644 --- a/storage/innobase/dict/dict0stats.cc +++ b/storage/innobase/dict/dict0stats.cc @@ -1490,7 +1490,7 @@ invalid: goto invalid; } - mtr.s_lock_space(index->table->space); + mtr.x_lock_space(index->table->space); ulint dummy, size; index->stat_index_size @@ -2697,7 +2697,7 @@ empty_index: } uint16_t root_level = btr_page_get_level(root->page.frame); - mtr.s_lock_space(index->table->space); + mtr.x_lock_space(index->table->space); ulint dummy, size; result.index_size = fseg_n_reserved_pages(*root, PAGE_HEADER + PAGE_BTR_SEG_LEAF diff --git a/storage/innobase/fil/fil0crypt.cc b/storage/innobase/fil/fil0crypt.cc index 7410986c441..fe75b7d58fa 100644 --- a/storage/innobase/fil/fil0crypt.cc +++ b/storage/innobase/fil/fil0crypt.cc @@ -1677,8 +1677,9 @@ fil_crypt_get_page_throttle( return NULL; } - if (DB_SUCCESS_LOCKED_REC - != fseg_page_is_allocated(space, state->offset)) { + if (offset % (zip_size ? zip_size : srv_page_size) + && DB_SUCCESS_LOCKED_REC + != fseg_page_is_allocated(space, offset)) { /* page is already freed */ return NULL; } diff --git a/storage/innobase/fsp/fsp0fsp.cc b/storage/innobase/fsp/fsp0fsp.cc index e9f3106feb0..514083d35cc 100644 --- a/storage/innobase/fsp/fsp0fsp.cc +++ b/storage/innobase/fsp/fsp0fsp.cc @@ -2653,7 +2653,7 @@ dberr_t fseg_page_is_allocated(fil_space_t *space, unsigned page) mtr.start(); if (!space->is_owner()) - mtr.s_lock_space(space); + mtr.x_lock_space(space); if (page >= space->free_limit || page >= space->size_in_header); else if (const buf_block_t *b= diff --git a/storage/innobase/include/mtr0mtr.h b/storage/innobase/include/mtr0mtr.h index 140cd3dc1b6..f3fe1841b2e 100644 --- a/storage/innobase/include/mtr0mtr.h +++ b/storage/innobase/include/mtr0mtr.h @@ -282,17 +282,6 @@ struct mtr_t { memo_push(lock, MTR_MEMO_SX_LOCK); } - /** Acquire a tablespace S-latch. - @param space tablespace */ - void s_lock_space(fil_space_t *space) - { - ut_ad(space->purpose == FIL_TYPE_TEMPORARY || - space->purpose == FIL_TYPE_IMPORT || - space->purpose == FIL_TYPE_TABLESPACE); - memo_push(space, MTR_MEMO_SPACE_S_LOCK); - space->s_lock(); - } - /** Acquire an exclusive tablespace latch. @param space tablespace */ void x_lock_space(fil_space_t *space); @@ -357,9 +346,8 @@ public: /** Check if we are holding tablespace latch @param space tablespace to search for - @param shared whether to look for shared latch, instead of exclusive @return whether space.latch is being held */ - bool memo_contains(const fil_space_t& space, bool shared= false) const + bool memo_contains(const fil_space_t& space) const MY_ATTRIBUTE((warn_unused_result)); #ifdef UNIV_DEBUG /** Check if we are holding an rw-latch in this mini-transaction @@ -412,7 +400,7 @@ public: break; case MTR_MEMO_MODIFY: case MTR_MEMO_S_LOCK: case MTR_MEMO_X_LOCK: case MTR_MEMO_SX_LOCK: - case MTR_MEMO_SPACE_X_LOCK: case MTR_MEMO_SPACE_S_LOCK: + case MTR_MEMO_SPACE_X_LOCK: ut_ad("invalid type" == 0); } #endif diff --git a/storage/innobase/include/mtr0types.h b/storage/innobase/include/mtr0types.h index 7acc255da36..465c20fe7d2 100644 --- a/storage/innobase/include/mtr0types.h +++ b/storage/innobase/include/mtr0types.h @@ -337,8 +337,6 @@ enum mtr_memo_type_t { MTR_MEMO_SX_LOCK = RW_SX_LATCH << 5, /** wr_lock() on fil_space_t::latch */ - MTR_MEMO_SPACE_X_LOCK = MTR_MEMO_SX_LOCK << 1, - /** rd_lock() on fil_space_t::latch */ - MTR_MEMO_SPACE_S_LOCK = MTR_MEMO_SX_LOCK << 2 + MTR_MEMO_SPACE_X_LOCK = MTR_MEMO_SX_LOCK << 1 }; #endif /* !UNIV_INNOCHECKSUM */ diff --git a/storage/innobase/mtr/mtr0mtr.cc b/storage/innobase/mtr/mtr0mtr.cc index 45a1424e572..2c004cb0aa6 100644 --- a/storage/innobase/mtr/mtr0mtr.cc +++ b/storage/innobase/mtr/mtr0mtr.cc @@ -55,9 +55,6 @@ void mtr_memo_slot_t::release() const static_cast(object)->set_committed_size(); static_cast(object)->x_unlock(); break; - case MTR_MEMO_SPACE_S_LOCK: - static_cast(object)->s_unlock(); - break; default: buf_page_t *bpage= static_cast(object); ut_d(const auto s=) @@ -912,18 +909,14 @@ bool mtr_t::have_u_or_x_latch(const buf_block_t &block) const /** Check if we are holding exclusive tablespace latch @param space tablespace to search for -@param shared whether to look for shared latch, instead of exclusive @return whether space.latch is being held */ -bool mtr_t::memo_contains(const fil_space_t& space, bool shared) const +bool mtr_t::memo_contains(const fil_space_t& space) const { - const mtr_memo_type_t type= shared - ? MTR_MEMO_SPACE_S_LOCK : MTR_MEMO_SPACE_X_LOCK; - for (const mtr_memo_slot_t &slot : m_memo) { - if (slot.object == &space && slot.type == type) + if (slot.object == &space && slot.type == MTR_MEMO_SPACE_X_LOCK) { - ut_ad(shared || space.is_owner()); + ut_ad(space.is_owner()); return true; } } -- cgit v1.2.1 From 34f0433c097f012247f91314a3cec5f3657e0d66 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marko=20M=C3=A4kel=C3=A4?= Date: Thu, 16 Feb 2023 09:17:40 +0200 Subject: MDEV-27774 fixup: Correct a comment --- extra/mariabackup/xtrabackup.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/extra/mariabackup/xtrabackup.cc b/extra/mariabackup/xtrabackup.cc index 7d62b5d7476..34b345a0dca 100644 --- a/extra/mariabackup/xtrabackup.cc +++ b/extra/mariabackup/xtrabackup.cc @@ -3159,7 +3159,7 @@ static void log_copying_thread() my_thread_end(); } -/** whether io_watching_thread() is active; protected by log_sys.mutex */ +/** whether io_watching_thread() is active; protected by recv_sys.mutex */ static bool have_io_watching_thread; /* io throttle watching (rough) */ -- cgit v1.2.1 From 0c79ae94626406afe29c053c54257356d9beda00 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marko=20M=C3=A4kel=C3=A4?= Date: Thu, 16 Feb 2023 10:09:19 +0200 Subject: Fix clang -Winconsistent-missing-override --- sql/item.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sql/item.h b/sql/item.h index 38773fd3ba8..79e93fda35f 100644 --- a/sql/item.h +++ b/sql/item.h @@ -3512,7 +3512,7 @@ public: { return Sql_mode_dependency(0, field->value_depends_on_sql_mode()); } - bool hash_not_null(Hasher *hasher) + bool hash_not_null(Hasher *hasher) override { if (field->is_null()) return true; -- cgit v1.2.1 From d3f35aa47bc3ee0c9b2798555f9a79057895809a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marko=20M=C3=A4kel=C3=A4?= Date: Thu, 16 Feb 2023 10:16:38 +0200 Subject: MDEV-30552 fixup: Fix the test for non-debug --- mysql-test/suite/innodb/r/recovery_memory.result | 2 +- mysql-test/suite/innodb/t/recovery_memory.test | 11 ++++++++++- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/mysql-test/suite/innodb/r/recovery_memory.result b/mysql-test/suite/innodb/r/recovery_memory.result index 6faea097616..9aba9bccdb3 100644 --- a/mysql-test/suite/innodb/r/recovery_memory.result +++ b/mysql-test/suite/innodb/r/recovery_memory.result @@ -22,7 +22,7 @@ DROP PROCEDURE dorepeat; SET DEBUG_DBUG="+d,ib_log_checkpoint_avoid_hard"; CREATE TABLE t1(f1 INT NOT NULL)ENGINE=InnoDB; INSERT INTO t1 SELECT * FROM seq_1_to_65536; -# restart: --innodb_buffer_pool_size=5242880 --debug_dbug=+d,ibuf_init_corrupt +# restart: with restart_parameters # restart SHOW CREATE TABLE t1; Table Create Table diff --git a/mysql-test/suite/innodb/t/recovery_memory.test b/mysql-test/suite/innodb/t/recovery_memory.test index e723ba25d36..145b39d56f6 100644 --- a/mysql-test/suite/innodb/t/recovery_memory.test +++ b/mysql-test/suite/innodb/t/recovery_memory.test @@ -1,6 +1,7 @@ --source include/have_innodb.inc --source include/big_test.inc --source include/have_sequence.inc +--source include/maybe_debug.inc call mtr.add_suppression("InnoDB: The change buffer is corrupted"); call mtr.add_suppression("InnoDB: Plugin initialization aborted at srv0start.cc"); call mtr.add_suppression("Plugin 'InnoDB' init function returned error"); @@ -30,12 +31,20 @@ DROP PROCEDURE dorepeat; --echo # MDEV-30552 InnoDB recovery crashes when error --echo # handling scenario --echo # +if ($have_debug) { SET DEBUG_DBUG="+d,ib_log_checkpoint_avoid_hard"; +let $restart_parameters=--innodb_buffer_pool_size=5242880 --debug_dbug="+d,ibuf_init_corrupt"; +} +if (!$have_debug) { +--echo SET DEBUG_DBUG="+d,ib_log_checkpoint_avoid_hard"; +let $restart_parameters=--innodb_buffer_pool_size=5242880; +} CREATE TABLE t1(f1 INT NOT NULL)ENGINE=InnoDB; INSERT INTO t1 SELECT * FROM seq_1_to_65536; +let $restart_noprint=1; let $shutdown_timeout=0; -let $restart_parameters=--innodb_buffer_pool_size=5242880 --debug_dbug="+d,ibuf_init_corrupt"; --source include/restart_mysqld.inc +let $restart_noprint=0; let $restart_parameters=; --source include/restart_mysqld.inc SHOW CREATE TABLE t1; -- cgit v1.2.1